OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-stable/] [gdb-7.2/] [bfd/] [coff-mips.c] - Blame information for rev 865

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 330 jeremybenn 
/* BFD back-end for MIPS Extended-Coff files.
2 
   Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
3 
   2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009
4 
   Free Software Foundation, Inc.
5 
   Original version by Per Bothner.
6 
   Full support added by Ian Lance Taylor, ian@cygnus.com.
7 
 
8 
   This file is part of BFD, the Binary File Descriptor library.
9 
 
10 
   This program is free software; you can redistribute it and/or modify
11 
   it under the terms of the GNU General Public License as published by
12 
   the Free Software Foundation; either version 3 of the License, or
13 
   (at your option) any later version.
14 
 
15 
   This program is distributed in the hope that it will be useful,
16 
   but WITHOUT ANY WARRANTY; without even the implied warranty of
17 
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18 
   GNU General Public License for more details.
19 
 
20 
   You should have received a copy of the GNU General Public License
21 
   along with this program; if not, write to the Free Software
22 
   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
23 
   MA 02110-1301, USA.  */
24 
 
25 
#include "sysdep.h"
26 
#include "bfd.h"
27 
#include "bfdlink.h"
28 
#include "libbfd.h"
29 
#include "coff/internal.h"
30 
#include "coff/sym.h"
31 
#include "coff/symconst.h"
32 
#include "coff/ecoff.h"
33 
#include "coff/mips.h"
34 
#include "libcoff.h"
35 
#include "libecoff.h"
36 
 
37 
/* Prototypes for static functions.  */
38 
 
39 
static bfd_boolean mips_ecoff_bad_format_hook
40 
  PARAMS ((bfd *abfd, PTR filehdr));
41 
static void mips_ecoff_swap_reloc_in
42 
  PARAMS ((bfd *, PTR, struct internal_reloc *));
43 
static void mips_ecoff_swap_reloc_out
44 
  PARAMS ((bfd *, const struct internal_reloc *, PTR));
45 
static void mips_adjust_reloc_in
46 
  PARAMS ((bfd *, const struct internal_reloc *, arelent *));
47 
static void mips_adjust_reloc_out
48 
  PARAMS ((bfd *, const arelent *, struct internal_reloc *));
49 
static bfd_reloc_status_type mips_generic_reloc
50 
  PARAMS ((bfd *abfd, arelent *reloc, asymbol *symbol, PTR data,
51 
           asection *section, bfd *output_bfd, char **error));
52 
static bfd_reloc_status_type mips_refhi_reloc
53 
  PARAMS ((bfd *abfd, arelent *reloc, asymbol *symbol, PTR data,
54 
           asection *section, bfd *output_bfd, char **error));
55 
static bfd_reloc_status_type mips_reflo_reloc
56 
  PARAMS ((bfd *abfd, arelent *reloc, asymbol *symbol, PTR data,
57 
           asection *section, bfd *output_bfd, char **error));
58 
static bfd_reloc_status_type mips_gprel_reloc
59 
  PARAMS ((bfd *abfd, arelent *reloc, asymbol *symbol, PTR data,
60 
           asection *section, bfd *output_bfd, char **error));
61 
static void mips_relocate_hi
62 
  PARAMS ((struct internal_reloc *refhi, struct internal_reloc *reflo,
63 
           bfd *input_bfd, asection *input_section, bfd_byte *contents,
64 
           bfd_vma relocation));
65 
static bfd_boolean mips_relocate_section
66 
  PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *, PTR));
67 
static reloc_howto_type *mips_bfd_reloc_type_lookup
68 
  PARAMS ((bfd *, bfd_reloc_code_real_type));
69 
 
70 
/* ECOFF has COFF sections, but the debugging information is stored in
71 
   a completely different format.  ECOFF targets use some of the
72 
   swapping routines from coffswap.h, and some of the generic COFF
73 
   routines in coffgen.c, but, unlike the real COFF targets, do not
74 
   use coffcode.h itself.
75 
 
76 
   Get the generic COFF swapping routines, except for the reloc,
77 
   symbol, and lineno ones.  Give them ECOFF names.  */
78 
#define MIPSECOFF
79 
#define NO_COFF_RELOCS
80 
#define NO_COFF_SYMBOLS
81 
#define NO_COFF_LINENOS
82 
#define coff_swap_filehdr_in mips_ecoff_swap_filehdr_in
83 
#define coff_swap_filehdr_out mips_ecoff_swap_filehdr_out
84 
#define coff_swap_aouthdr_in mips_ecoff_swap_aouthdr_in
85 
#define coff_swap_aouthdr_out mips_ecoff_swap_aouthdr_out
86 
#define coff_swap_scnhdr_in mips_ecoff_swap_scnhdr_in
87 
#define coff_swap_scnhdr_out mips_ecoff_swap_scnhdr_out
88 
 
89 
#include "coffswap.h"
90 
 
91 
/* Get the ECOFF swapping routines.  */
92 
#define ECOFF_32
93 
#include "ecoffswap.h"
94 
 
95 
/* How to process the various relocs types.  */
96 
 
97 
static reloc_howto_type mips_howto_table[] =
98 
{
99 
  /* Reloc type 0 is ignored.  The reloc reading code ensures that
100 
     this is a reference to the .abs section, which will cause
101 
     bfd_perform_relocation to do nothing.  */
102 
  HOWTO (MIPS_R_IGNORE, /* type */
103 
         0,                      /* rightshift */
104 
         0,                      /* size (0 = byte, 1 = short, 2 = long) */
105 
         8,                     /* bitsize */
106 
         FALSE,                 /* pc_relative */
107 
         0,                      /* bitpos */
108 
         complain_overflow_dont, /* complain_on_overflow */
109 
         0,                      /* special_function */
110 
         "IGNORE",              /* name */
111 
         FALSE,                 /* partial_inplace */
112 
         0,                      /* src_mask */
113 
         0,                      /* dst_mask */
114 
         FALSE),                /* pcrel_offset */
115 
 
116 
  /* A 16 bit reference to a symbol, normally from a data section.  */
117 
  HOWTO (MIPS_R_REFHALF,        /* type */
118 
         0,                      /* rightshift */
119 
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
120 
         16,                    /* bitsize */
121 
         FALSE,                 /* pc_relative */
122 
         0,                      /* bitpos */
123 
         complain_overflow_bitfield, /* complain_on_overflow */
124 
         mips_generic_reloc,    /* special_function */
125 
         "REFHALF",             /* name */
126 
         TRUE,                  /* partial_inplace */
127 
         0xffff,                /* src_mask */
128 
         0xffff,                /* dst_mask */
129 
         FALSE),                /* pcrel_offset */
130 
 
131 
  /* A 32 bit reference to a symbol, normally from a data section.  */
132 
  HOWTO (MIPS_R_REFWORD,        /* type */
133 
         0,                      /* rightshift */
134 
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
135 
         32,                    /* bitsize */
136 
         FALSE,                 /* pc_relative */
137 
         0,                      /* bitpos */
138 
         complain_overflow_bitfield, /* complain_on_overflow */
139 
         mips_generic_reloc,    /* special_function */
140 
         "REFWORD",             /* name */
141 
         TRUE,                  /* partial_inplace */
142 
         0xffffffff,            /* src_mask */
143 
         0xffffffff,            /* dst_mask */
144 
         FALSE),                /* pcrel_offset */
145 
 
146 
  /* A 26 bit absolute jump address.  */
147 
  HOWTO (MIPS_R_JMPADDR,        /* type */
148 
         2,                     /* rightshift */
149 
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
150 
         26,                    /* bitsize */
151 
         FALSE,                 /* pc_relative */
152 
         0,                      /* bitpos */
153 
         complain_overflow_dont, /* complain_on_overflow */
154 
                                /* This needs complex overflow
155 
                                   detection, because the upper four
156 
                                   bits must match the PC.  */
157 
         mips_generic_reloc,    /* special_function */
158 
         "JMPADDR",             /* name */
159 
         TRUE,                  /* partial_inplace */
160 
         0x3ffffff,             /* src_mask */
161 
         0x3ffffff,             /* dst_mask */
162 
         FALSE),                /* pcrel_offset */
163 
 
164 
  /* The high 16 bits of a symbol value.  Handled by the function
165 
     mips_refhi_reloc.  */
166 
  HOWTO (MIPS_R_REFHI,          /* type */
167 
         16,                    /* rightshift */
168 
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
169 
         16,                    /* bitsize */
170 
         FALSE,                 /* pc_relative */
171 
         0,                      /* bitpos */
172 
         complain_overflow_bitfield, /* complain_on_overflow */
173 
         mips_refhi_reloc,      /* special_function */
174 
         "REFHI",               /* name */
175 
         TRUE,                  /* partial_inplace */
176 
         0xffff,                /* src_mask */
177 
         0xffff,                /* dst_mask */
178 
         FALSE),                /* pcrel_offset */
179 
 
180 
  /* The low 16 bits of a symbol value.  */
181 
  HOWTO (MIPS_R_REFLO,          /* type */
182 
         0,                      /* rightshift */
183 
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
184 
         16,                    /* bitsize */
185 
         FALSE,                 /* pc_relative */
186 
         0,                      /* bitpos */
187 
         complain_overflow_dont, /* complain_on_overflow */
188 
         mips_reflo_reloc,      /* special_function */
189 
         "REFLO",               /* name */
190 
         TRUE,                  /* partial_inplace */
191 
         0xffff,                /* src_mask */
192 
         0xffff,                /* dst_mask */
193 
         FALSE),                /* pcrel_offset */
194 
 
195 
  /* A reference to an offset from the gp register.  Handled by the
196 
     function mips_gprel_reloc.  */
197 
  HOWTO (MIPS_R_GPREL,          /* type */
198 
         0,                      /* rightshift */
199 
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
200 
         16,                    /* bitsize */
201 
         FALSE,                 /* pc_relative */
202 
         0,                      /* bitpos */
203 
         complain_overflow_signed, /* complain_on_overflow */
204 
         mips_gprel_reloc,      /* special_function */
205 
         "GPREL",               /* name */
206 
         TRUE,                  /* partial_inplace */
207 
         0xffff,                /* src_mask */
208 
         0xffff,                /* dst_mask */
209 
         FALSE),                /* pcrel_offset */
210 
 
211 
  /* A reference to a literal using an offset from the gp register.
212 
     Handled by the function mips_gprel_reloc.  */
213 
  HOWTO (MIPS_R_LITERAL,        /* type */
214 
         0,                      /* rightshift */
215 
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
216 
         16,                    /* bitsize */
217 
         FALSE,                 /* pc_relative */
218 
         0,                      /* bitpos */
219 
         complain_overflow_signed, /* complain_on_overflow */
220 
         mips_gprel_reloc,      /* special_function */
221 
         "LITERAL",             /* name */
222 
         TRUE,                  /* partial_inplace */
223 
         0xffff,                /* src_mask */
224 
         0xffff,                /* dst_mask */
225 
         FALSE),                /* pcrel_offset */
226 
 
227 
  EMPTY_HOWTO (8),
228 
  EMPTY_HOWTO (9),
229 
  EMPTY_HOWTO (10),
230 
  EMPTY_HOWTO (11),
231 
 
232 
  /* FIXME: This relocation is used (internally only) to represent branches
233 
     when assembling.  It should never appear in output files, and
234 
     be removed.  (It used to be used for embedded-PIC support.)  */
235 
  HOWTO (MIPS_R_PCREL16,        /* type */
236 
         2,                     /* rightshift */
237 
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
238 
         16,                    /* bitsize */
239 
         TRUE,                  /* pc_relative */
240 
         0,                      /* bitpos */
241 
         complain_overflow_signed, /* complain_on_overflow */
242 
         mips_generic_reloc,    /* special_function */
243 
         "PCREL16",             /* name */
244 
         TRUE,                  /* partial_inplace */
245 
         0xffff,                /* src_mask */
246 
         0xffff,                /* dst_mask */
247 
         TRUE),                 /* pcrel_offset */
248 
};
249 
 
250 
#define MIPS_HOWTO_COUNT \
251 
  (sizeof mips_howto_table / sizeof mips_howto_table[0])
252 
 
253 
/* See whether the magic number matches.  */
254 
 
255 
static bfd_boolean
256 
mips_ecoff_bad_format_hook (abfd, filehdr)
257 
     bfd *abfd;
258 
     PTR filehdr;
259 
{
260 
  struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
261 
 
262 
  switch (internal_f->f_magic)
263 
    {
264 
    case MIPS_MAGIC_1:
265 
      /* I don't know what endianness this implies.  */
266 
      return TRUE;
267 
 
268 
    case MIPS_MAGIC_BIG:
269 
    case MIPS_MAGIC_BIG2:
270 
    case MIPS_MAGIC_BIG3:
271 
      return bfd_big_endian (abfd);
272 
 
273 
    case MIPS_MAGIC_LITTLE:
274 
    case MIPS_MAGIC_LITTLE2:
275 
    case MIPS_MAGIC_LITTLE3:
276 
      return bfd_little_endian (abfd);
277 
 
278 
    default:
279 
      return FALSE;
280 
    }
281 
}
282 
 
283 
/* Reloc handling.  MIPS ECOFF relocs are packed into 8 bytes in
284 
   external form.  They use a bit which indicates whether the symbol
285 
   is external.  */
286 
 
287 
/* Swap a reloc in.  */
288 
 
289 
static void
290 
mips_ecoff_swap_reloc_in (abfd, ext_ptr, intern)
291 
     bfd *abfd;
292 
     PTR ext_ptr;
293 
     struct internal_reloc *intern;
294 
{
295 
  const RELOC *ext = (RELOC *) ext_ptr;
296 
 
297 
  intern->r_vaddr = H_GET_32 (abfd, ext->r_vaddr);
298 
  if (bfd_header_big_endian (abfd))
299 
    {
300 
      intern->r_symndx = (((int) ext->r_bits[0]
301 
                           << RELOC_BITS0_SYMNDX_SH_LEFT_BIG)
302 
                          | ((int) ext->r_bits[1]
303 
                             << RELOC_BITS1_SYMNDX_SH_LEFT_BIG)
304 
                          | ((int) ext->r_bits[2]
305 
                             << RELOC_BITS2_SYMNDX_SH_LEFT_BIG));
306 
      intern->r_type = ((ext->r_bits[3] & RELOC_BITS3_TYPE_BIG)
307 
                        >> RELOC_BITS3_TYPE_SH_BIG);
308 
      intern->r_extern = (ext->r_bits[3] & RELOC_BITS3_EXTERN_BIG) != 0;
309 
    }
310 
  else
311 
    {
312 
      intern->r_symndx = (((int) ext->r_bits[0]
313 
                           << RELOC_BITS0_SYMNDX_SH_LEFT_LITTLE)
314 
                          | ((int) ext->r_bits[1]
315 
                             << RELOC_BITS1_SYMNDX_SH_LEFT_LITTLE)
316 
                          | ((int) ext->r_bits[2]
317 
                             << RELOC_BITS2_SYMNDX_SH_LEFT_LITTLE));
318 
      intern->r_type = (((ext->r_bits[3] & RELOC_BITS3_TYPE_LITTLE)
319 
                         >> RELOC_BITS3_TYPE_SH_LITTLE)
320 
                        | ((ext->r_bits[3] & RELOC_BITS3_TYPEHI_LITTLE)
321 
                           << RELOC_BITS3_TYPEHI_SH_LITTLE));
322 
      intern->r_extern = (ext->r_bits[3] & RELOC_BITS3_EXTERN_LITTLE) != 0;
323 
    }
324 
}
325 
 
326 
/* Swap a reloc out.  */
327 
 
328 
static void
329 
mips_ecoff_swap_reloc_out (abfd, intern, dst)
330 
     bfd *abfd;
331 
     const struct internal_reloc *intern;
332 
     PTR dst;
333 
{
334 
  RELOC *ext = (RELOC *) dst;
335 
  long r_symndx;
336 
 
337 
  BFD_ASSERT (intern->r_extern
338 
              || (intern->r_symndx >= 0 && intern->r_symndx <= 12));
339 
 
340 
  r_symndx = intern->r_symndx;
341 
 
342 
  H_PUT_32 (abfd, intern->r_vaddr, ext->r_vaddr);
343 
  if (bfd_header_big_endian (abfd))
344 
    {
345 
      ext->r_bits[0] = r_symndx >> RELOC_BITS0_SYMNDX_SH_LEFT_BIG;
346 
      ext->r_bits[1] = r_symndx >> RELOC_BITS1_SYMNDX_SH_LEFT_BIG;
347 
      ext->r_bits[2] = r_symndx >> RELOC_BITS2_SYMNDX_SH_LEFT_BIG;
348 
      ext->r_bits[3] = (((intern->r_type << RELOC_BITS3_TYPE_SH_BIG)
349 
                         & RELOC_BITS3_TYPE_BIG)
350 
                        | (intern->r_extern ? RELOC_BITS3_EXTERN_BIG : 0));
351 
    }
352 
  else
353 
    {
354 
      ext->r_bits[0] = r_symndx >> RELOC_BITS0_SYMNDX_SH_LEFT_LITTLE;
355 
      ext->r_bits[1] = r_symndx >> RELOC_BITS1_SYMNDX_SH_LEFT_LITTLE;
356 
      ext->r_bits[2] = r_symndx >> RELOC_BITS2_SYMNDX_SH_LEFT_LITTLE;
357 
      ext->r_bits[3] = (((intern->r_type << RELOC_BITS3_TYPE_SH_LITTLE)
358 
                         & RELOC_BITS3_TYPE_LITTLE)
359 
                        | ((intern->r_type >> RELOC_BITS3_TYPEHI_SH_LITTLE
360 
                            & RELOC_BITS3_TYPEHI_LITTLE))
361 
                        | (intern->r_extern ? RELOC_BITS3_EXTERN_LITTLE : 0));
362 
    }
363 
}
364 
 
365 
/* Finish canonicalizing a reloc.  Part of this is generic to all
366 
   ECOFF targets, and that part is in ecoff.c.  The rest is done in
367 
   this backend routine.  It must fill in the howto field.  */
368 
 
369 
static void
370 
mips_adjust_reloc_in (abfd, intern, rptr)
371 
     bfd *abfd;
372 
     const struct internal_reloc *intern;
373 
     arelent *rptr;
374 
{
375 
  if (intern->r_type > MIPS_R_PCREL16)
376 
    abort ();
377 
 
378 
  if (! intern->r_extern
379 
      && (intern->r_type == MIPS_R_GPREL
380 
          || intern->r_type == MIPS_R_LITERAL))
381 
    rptr->addend += ecoff_data (abfd)->gp;
382 
 
383 
  /* If the type is MIPS_R_IGNORE, make sure this is a reference to
384 
     the absolute section so that the reloc is ignored.  */
385 
  if (intern->r_type == MIPS_R_IGNORE)
386 
    rptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
387 
 
388 
  rptr->howto = &mips_howto_table[intern->r_type];
389 
}
390 
 
391 
/* Make any adjustments needed to a reloc before writing it out.  None
392 
   are needed for MIPS.  */
393 
 
394 
static void
395 
mips_adjust_reloc_out (abfd, rel, intern)
396 
     bfd *abfd ATTRIBUTE_UNUSED;
397 
     const arelent *rel ATTRIBUTE_UNUSED;
398 
     struct internal_reloc *intern ATTRIBUTE_UNUSED;
399 
{
400 
}
401 
 
402 
/* ECOFF relocs are either against external symbols, or against
403 
   sections.  If we are producing relocatable output, and the reloc
404 
   is against an external symbol, and nothing has given us any
405 
   additional addend, the resulting reloc will also be against the
406 
   same symbol.  In such a case, we don't want to change anything
407 
   about the way the reloc is handled, since it will all be done at
408 
   final link time.  Rather than put special case code into
409 
   bfd_perform_relocation, all the reloc types use this howto
410 
   function.  It just short circuits the reloc if producing
411 
   relocatable output against an external symbol.  */
412 
 
413 
static bfd_reloc_status_type
414 
mips_generic_reloc (abfd,
415 
                    reloc_entry,
416 
                    symbol,
417 
                    data,
418 
                    input_section,
419 
                    output_bfd,
420 
                    error_message)
421 
     bfd *abfd ATTRIBUTE_UNUSED;
422 
     arelent *reloc_entry;
423 
     asymbol *symbol;
424 
     PTR data ATTRIBUTE_UNUSED;
425 
     asection *input_section;
426 
     bfd *output_bfd;
427 
     char **error_message ATTRIBUTE_UNUSED;
428 
{
429 
  if (output_bfd != (bfd *) NULL
430 
      && (symbol->flags & BSF_SECTION_SYM) == 0
431 
      && reloc_entry->addend == 0)
432 
    {
433 
      reloc_entry->address += input_section->output_offset;
434 
      return bfd_reloc_ok;
435 
    }
436 
 
437 
  return bfd_reloc_continue;
438 
}
439 
 
440 
/* Do a REFHI relocation.  This has to be done in combination with a
441 
   REFLO reloc, because there is a carry from the REFLO to the REFHI.
442 
   Here we just save the information we need; we do the actual
443 
   relocation when we see the REFLO.  MIPS ECOFF requires that the
444 
   REFLO immediately follow the REFHI.  As a GNU extension, we permit
445 
   an arbitrary number of HI relocs to be associated with a single LO
446 
   reloc.  This extension permits gcc to output the HI and LO relocs
447 
   itself.  */
448 
 
449 
struct mips_hi
450 
{
451 
  struct mips_hi *next;
452 
  bfd_byte *addr;
453 
  bfd_vma addend;
454 
};
455 
 
456 
/* FIXME: This should not be a static variable.  */
457 
 
458 
static struct mips_hi *mips_refhi_list;
459 
 
460 
static bfd_reloc_status_type
461 
mips_refhi_reloc (abfd,
462 
                  reloc_entry,
463 
                  symbol,
464 
                  data,
465 
                  input_section,
466 
                  output_bfd,
467 
                  error_message)
468 
     bfd *abfd ATTRIBUTE_UNUSED;
469 
     arelent *reloc_entry;
470 
     asymbol *symbol;
471 
     PTR data;
472 
     asection *input_section;
473 
     bfd *output_bfd;
474 
     char **error_message ATTRIBUTE_UNUSED;
475 
{
476 
  bfd_reloc_status_type ret;
477 
  bfd_vma relocation;
478 
  struct mips_hi *n;
479 
 
480 
  /* If we're relocating, and this an external symbol, we don't want
481 
     to change anything.  */
482 
  if (output_bfd != (bfd *) NULL
483 
      && (symbol->flags & BSF_SECTION_SYM) == 0
484 
      && reloc_entry->addend == 0)
485 
    {
486 
      reloc_entry->address += input_section->output_offset;
487 
      return bfd_reloc_ok;
488 
    }
489 
 
490 
  ret = bfd_reloc_ok;
491 
  if (bfd_is_und_section (symbol->section)
492 
      && output_bfd == (bfd *) NULL)
493 
    ret = bfd_reloc_undefined;
494 
 
495 
  if (bfd_is_com_section (symbol->section))
496 
    relocation = 0;
497 
  else
498 
    relocation = symbol->value;
499 
 
500 
  relocation += symbol->section->output_section->vma;
501 
  relocation += symbol->section->output_offset;
502 
  relocation += reloc_entry->addend;
503 
 
504 
  if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
505 
    return bfd_reloc_outofrange;
506 
 
507 
  /* Save the information, and let REFLO do the actual relocation.  */
508 
  n = (struct mips_hi *) bfd_malloc ((bfd_size_type) sizeof *n);
509 
  if (n == NULL)
510 
    return bfd_reloc_outofrange;
511 
  n->addr = (bfd_byte *) data + reloc_entry->address;
512 
  n->addend = relocation;
513 
  n->next = mips_refhi_list;
514 
  mips_refhi_list = n;
515 
 
516 
  if (output_bfd != (bfd *) NULL)
517 
    reloc_entry->address += input_section->output_offset;
518 
 
519 
  return ret;
520 
}
521 
 
522 
/* Do a REFLO relocation.  This is a straightforward 16 bit inplace
523 
   relocation; this function exists in order to do the REFHI
524 
   relocation described above.  */
525 
 
526 
static bfd_reloc_status_type
527 
mips_reflo_reloc (abfd,
528 
                  reloc_entry,
529 
                  symbol,
530 
                  data,
531 
                  input_section,
532 
                  output_bfd,
533 
                  error_message)
534 
     bfd *abfd;
535 
     arelent *reloc_entry;
536 
     asymbol *symbol;
537 
     PTR data;
538 
     asection *input_section;
539 
     bfd *output_bfd;
540 
     char **error_message;
541 
{
542 
  if (mips_refhi_list != NULL)
543 
    {
544 
      struct mips_hi *l;
545 
 
546 
      l = mips_refhi_list;
547 
      while (l != NULL)
548 
        {
549 
          unsigned long insn;
550 
          unsigned long val;
551 
          unsigned long vallo;
552 
          struct mips_hi *next;
553 
 
554 
          /* Do the REFHI relocation.  Note that we actually don't
555 
             need to know anything about the REFLO itself, except
556 
             where to find the low 16 bits of the addend needed by the
557 
             REFHI.  */
558 
          insn = bfd_get_32 (abfd, l->addr);
559 
          vallo = (bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address)
560 
                   & 0xffff);
561 
          val = ((insn & 0xffff) << 16) + vallo;
562 
          val += l->addend;
563 
 
564 
          /* The low order 16 bits are always treated as a signed
565 
             value.  Therefore, a negative value in the low order bits
566 
             requires an adjustment in the high order bits.  We need
567 
             to make this adjustment in two ways: once for the bits we
568 
             took from the data, and once for the bits we are putting
569 
             back in to the data.  */
570 
          if ((vallo & 0x8000) != 0)
571 
            val -= 0x10000;
572 
          if ((val & 0x8000) != 0)
573 
            val += 0x10000;
574 
 
575 
          insn = (insn &~ (unsigned) 0xffff) | ((val >> 16) & 0xffff);
576 
          bfd_put_32 (abfd, (bfd_vma) insn, l->addr);
577 
 
578 
          next = l->next;
579 
          free (l);
580 
          l = next;
581 
        }
582 
 
583 
      mips_refhi_list = NULL;
584 
    }
585 
 
586 
  /* Now do the REFLO reloc in the usual way.  */
587 
  return mips_generic_reloc (abfd, reloc_entry, symbol, data,
588 
                              input_section, output_bfd, error_message);
589 
}
590 
 
591 
/* Do a GPREL relocation.  This is a 16 bit value which must become
592 
   the offset from the gp register.  */
593 
 
594 
static bfd_reloc_status_type
595 
mips_gprel_reloc (abfd,
596 
                  reloc_entry,
597 
                  symbol,
598 
                  data,
599 
                  input_section,
600 
                  output_bfd,
601 
                  error_message)
602 
     bfd *abfd;
603 
     arelent *reloc_entry;
604 
     asymbol *symbol;
605 
     PTR data;
606 
     asection *input_section;
607 
     bfd *output_bfd;
608 
     char **error_message;
609 
{
610 
  bfd_boolean relocatable;
611 
  bfd_vma gp;
612 
  bfd_vma relocation;
613 
  unsigned long val;
614 
  unsigned long insn;
615 
 
616 
  /* If we're relocating, and this is an external symbol with no
617 
     addend, we don't want to change anything.  We will only have an
618 
     addend if this is a newly created reloc, not read from an ECOFF
619 
     file.  */
620 
  if (output_bfd != (bfd *) NULL
621 
      && (symbol->flags & BSF_SECTION_SYM) == 0
622 
      && reloc_entry->addend == 0)
623 
    {
624 
      reloc_entry->address += input_section->output_offset;
625 
      return bfd_reloc_ok;
626 
    }
627 
 
628 
  if (output_bfd != (bfd *) NULL)
629 
    relocatable = TRUE;
630 
  else
631 
    {
632 
      relocatable = FALSE;
633 
      output_bfd = symbol->section->output_section->owner;
634 
    }
635 
 
636 
  if (bfd_is_und_section (symbol->section) && ! relocatable)
637 
    return bfd_reloc_undefined;
638 
 
639 
  /* We have to figure out the gp value, so that we can adjust the
640 
     symbol value correctly.  We look up the symbol _gp in the output
641 
     BFD.  If we can't find it, we're stuck.  We cache it in the ECOFF
642 
     target data.  We don't need to adjust the symbol value for an
643 
     external symbol if we are producing relocatable output.  */
644 
  gp = _bfd_get_gp_value (output_bfd);
645 
  if (gp == 0
646 
      && (! relocatable
647 
          || (symbol->flags & BSF_SECTION_SYM) != 0))
648 
    {
649 
      if (relocatable)
650 
        {
651 
          /* Make up a value.  */
652 
          gp = symbol->section->output_section->vma + 0x4000;
653 
          _bfd_set_gp_value (output_bfd, gp);
654 
        }
655 
      else
656 
        {
657 
          unsigned int count;
658 
          asymbol **sym;
659 
          unsigned int i;
660 
 
661 
          count = bfd_get_symcount (output_bfd);
662 
          sym = bfd_get_outsymbols (output_bfd);
663 
 
664 
          if (sym == (asymbol **) NULL)
665 
            i = count;
666 
          else
667 
            {
668 
              for (i = 0; i < count; i++, sym++)
669 
                {
670 
                  register const char *name;
671 
 
672 
                  name = bfd_asymbol_name (*sym);
673 
                  if (*name == '_' && strcmp (name, "_gp") == 0)
674 
                    {
675 
                      gp = bfd_asymbol_value (*sym);
676 
                      _bfd_set_gp_value (output_bfd, gp);
677 
                      break;
678 
                    }
679 
                }
680 
            }
681 
 
682 
          if (i >= count)
683 
            {
684 
              /* Only get the error once.  */
685 
              gp = 4;
686 
              _bfd_set_gp_value (output_bfd, gp);
687 
              *error_message =
688 
                (char *) _("GP relative relocation when _gp not defined");
689 
              return bfd_reloc_dangerous;
690 
            }
691 
        }
692 
    }
693 
 
694 
  if (bfd_is_com_section (symbol->section))
695 
    relocation = 0;
696 
  else
697 
    relocation = symbol->value;
698 
 
699 
  relocation += symbol->section->output_section->vma;
700 
  relocation += symbol->section->output_offset;
701 
 
702 
  if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
703 
    return bfd_reloc_outofrange;
704 
 
705 
  insn = bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address);
706 
 
707 
  /* Set val to the offset into the section or symbol.  */
708 
  val = ((insn & 0xffff) + reloc_entry->addend) & 0xffff;
709 
  if (val & 0x8000)
710 
    val -= 0x10000;
711 
 
712 
  /* Adjust val for the final section location and GP value.  If we
713 
     are producing relocatable output, we don't want to do this for
714 
     an external symbol.  */
715 
  if (! relocatable
716 
      || (symbol->flags & BSF_SECTION_SYM) != 0)
717 
    val += relocation - gp;
718 
 
719 
  insn = (insn &~ (unsigned) 0xffff) | (val & 0xffff);
720 
  bfd_put_32 (abfd, (bfd_vma) insn, (bfd_byte *) data + reloc_entry->address);
721 
 
722 
  if (relocatable)
723 
    reloc_entry->address += input_section->output_offset;
724 
 
725 
  /* Make sure it fit in 16 bits.  */
726 
  if ((long) val >= 0x8000 || (long) val < -0x8000)
727 
    return bfd_reloc_overflow;
728 
 
729 
  return bfd_reloc_ok;
730 
}
731 
 
732 
/* Get the howto structure for a generic reloc type.  */
733 
 
734 
static reloc_howto_type *
735 
mips_bfd_reloc_type_lookup (abfd, code)
736 
     bfd *abfd ATTRIBUTE_UNUSED;
737 
     bfd_reloc_code_real_type code;
738 
{
739 
  int mips_type;
740 
 
741 
  switch (code)
742 
    {
743 
    case BFD_RELOC_16:
744 
      mips_type = MIPS_R_REFHALF;
745 
      break;
746 
    case BFD_RELOC_32:
747 
    case BFD_RELOC_CTOR:
748 
      mips_type = MIPS_R_REFWORD;
749 
      break;
750 
    case BFD_RELOC_MIPS_JMP:
751 
      mips_type = MIPS_R_JMPADDR;
752 
      break;
753 
    case BFD_RELOC_HI16_S:
754 
      mips_type = MIPS_R_REFHI;
755 
      break;
756 
    case BFD_RELOC_LO16:
757 
      mips_type = MIPS_R_REFLO;
758 
      break;
759 
    case BFD_RELOC_GPREL16:
760 
      mips_type = MIPS_R_GPREL;
761 
      break;
762 
    case BFD_RELOC_MIPS_LITERAL:
763 
      mips_type = MIPS_R_LITERAL;
764 
      break;
765 
    case BFD_RELOC_16_PCREL_S2:
766 
      mips_type = MIPS_R_PCREL16;
767 
      break;
768 
    default:
769 
      return (reloc_howto_type *) NULL;
770 
    }
771 
 
772 
  return &mips_howto_table[mips_type];
773 
}
774 
 
775 
static reloc_howto_type *
776 
mips_bfd_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
777 
                            const char *r_name)
778 
{
779 
  unsigned int i;
780 
 
781 
  for (i = 0;
782 
       i < sizeof (mips_howto_table) / sizeof (mips_howto_table[0]);
783 
       i++)
784 
    if (mips_howto_table[i].name != NULL
785 
        && strcasecmp (mips_howto_table[i].name, r_name) == 0)
786 
      return &mips_howto_table[i];
787 
 
788 
  return NULL;
789 
}
790 
 
791 
/* A helper routine for mips_relocate_section which handles the REFHI
792 
   relocations.  The REFHI relocation must be followed by a REFLO
793 
   relocation, and the addend used is formed from the addends of both
794 
   instructions.  */
795 
 
796 
static void
797 
mips_relocate_hi (refhi, reflo, input_bfd, input_section, contents,
798 
                  relocation)
799 
     struct internal_reloc *refhi;
800 
     struct internal_reloc *reflo;
801 
     bfd *input_bfd;
802 
     asection *input_section;
803 
     bfd_byte *contents;
804 
     bfd_vma relocation;
805 
{
806 
  unsigned long insn;
807 
  unsigned long val;
808 
  unsigned long vallo;
809 
 
810 
  if (refhi == NULL)
811 
    return;
812 
 
813 
  insn = bfd_get_32 (input_bfd,
814 
                     contents + refhi->r_vaddr - input_section->vma);
815 
  if (reflo == NULL)
816 
    vallo = 0;
817 
  else
818 
    vallo = (bfd_get_32 (input_bfd,
819 
                         contents + reflo->r_vaddr - input_section->vma)
820 
             & 0xffff);
821 
 
822 
  val = ((insn & 0xffff) << 16) + vallo;
823 
  val += relocation;
824 
 
825 
  /* The low order 16 bits are always treated as a signed value.
826 
     Therefore, a negative value in the low order bits requires an
827 
     adjustment in the high order bits.  We need to make this
828 
     adjustment in two ways: once for the bits we took from the data,
829 
     and once for the bits we are putting back in to the data.  */
830 
  if ((vallo & 0x8000) != 0)
831 
    val -= 0x10000;
832 
 
833 
  if ((val & 0x8000) != 0)
834 
    val += 0x10000;
835 
 
836 
  insn = (insn &~ (unsigned) 0xffff) | ((val >> 16) & 0xffff);
837 
  bfd_put_32 (input_bfd, (bfd_vma) insn,
838 
              contents + refhi->r_vaddr - input_section->vma);
839 
}
840 
 
841 
/* Relocate a section while linking a MIPS ECOFF file.  */
842 
 
843 
static bfd_boolean
844 
mips_relocate_section (output_bfd, info, input_bfd, input_section,
845 
                       contents, external_relocs)
846 
     bfd *output_bfd;
847 
     struct bfd_link_info *info;
848 
     bfd *input_bfd;
849 
     asection *input_section;
850 
     bfd_byte *contents;
851 
     PTR external_relocs;
852 
{
853 
  asection **symndx_to_section;
854 
  struct ecoff_link_hash_entry **sym_hashes;
855 
  bfd_vma gp;
856 
  bfd_boolean gp_undefined;
857 
  struct external_reloc *ext_rel;
858 
  struct external_reloc *ext_rel_end;
859 
  unsigned int i;
860 
  bfd_boolean got_lo;
861 
  struct internal_reloc lo_int_rel;
862 
  bfd_size_type amt;
863 
 
864 
  BFD_ASSERT (input_bfd->xvec->byteorder
865 
              == output_bfd->xvec->byteorder);
866 
 
867 
  /* We keep a table mapping the symndx found in an internal reloc to
868 
     the appropriate section.  This is faster than looking up the
869 
     section by name each time.  */
870 
  symndx_to_section = ecoff_data (input_bfd)->symndx_to_section;
871 
  if (symndx_to_section == (asection **) NULL)
872 
    {
873 
      amt = NUM_RELOC_SECTIONS * sizeof (asection *);
874 
      symndx_to_section = (asection **) bfd_alloc (input_bfd, amt);
875 
      if (!symndx_to_section)
876 
        return FALSE;
877 
 
878 
      symndx_to_section[RELOC_SECTION_NONE] = NULL;
879 
      symndx_to_section[RELOC_SECTION_TEXT] =
880 
        bfd_get_section_by_name (input_bfd, ".text");
881 
      symndx_to_section[RELOC_SECTION_RDATA] =
882 
        bfd_get_section_by_name (input_bfd, ".rdata");
883 
      symndx_to_section[RELOC_SECTION_DATA] =
884 
        bfd_get_section_by_name (input_bfd, ".data");
885 
      symndx_to_section[RELOC_SECTION_SDATA] =
886 
        bfd_get_section_by_name (input_bfd, ".sdata");
887 
      symndx_to_section[RELOC_SECTION_SBSS] =
888 
        bfd_get_section_by_name (input_bfd, ".sbss");
889 
      symndx_to_section[RELOC_SECTION_BSS] =
890 
        bfd_get_section_by_name (input_bfd, ".bss");
891 
      symndx_to_section[RELOC_SECTION_INIT] =
892 
        bfd_get_section_by_name (input_bfd, ".init");
893 
      symndx_to_section[RELOC_SECTION_LIT8] =
894 
        bfd_get_section_by_name (input_bfd, ".lit8");
895 
      symndx_to_section[RELOC_SECTION_LIT4] =
896 
        bfd_get_section_by_name (input_bfd, ".lit4");
897 
      symndx_to_section[RELOC_SECTION_XDATA] = NULL;
898 
      symndx_to_section[RELOC_SECTION_PDATA] = NULL;
899 
      symndx_to_section[RELOC_SECTION_FINI] =
900 
        bfd_get_section_by_name (input_bfd, ".fini");
901 
      symndx_to_section[RELOC_SECTION_LITA] = NULL;
902 
      symndx_to_section[RELOC_SECTION_ABS] = NULL;
903 
 
904 
      ecoff_data (input_bfd)->symndx_to_section = symndx_to_section;
905 
    }
906 
 
907 
  sym_hashes = ecoff_data (input_bfd)->sym_hashes;
908 
 
909 
  gp = _bfd_get_gp_value (output_bfd);
910 
  if (gp == 0)
911 
    gp_undefined = TRUE;
912 
  else
913 
    gp_undefined = FALSE;
914 
 
915 
  got_lo = FALSE;
916 
 
917 
  ext_rel = (struct external_reloc *) external_relocs;
918 
  ext_rel_end = ext_rel + input_section->reloc_count;
919 
  for (i = 0; ext_rel < ext_rel_end; ext_rel++, i++)
920 
    {
921 
      struct internal_reloc int_rel;
922 
      bfd_boolean use_lo = FALSE;
923 
      bfd_vma addend;
924 
      reloc_howto_type *howto;
925 
      struct ecoff_link_hash_entry *h = NULL;
926 
      asection *s = NULL;
927 
      bfd_vma relocation;
928 
      bfd_reloc_status_type r;
929 
 
930 
      if (! got_lo)
931 
        mips_ecoff_swap_reloc_in (input_bfd, (PTR) ext_rel, &int_rel);
932 
      else
933 
        {
934 
          int_rel = lo_int_rel;
935 
          got_lo = FALSE;
936 
        }
937 
 
938 
      BFD_ASSERT (int_rel.r_type
939 
                  < sizeof mips_howto_table / sizeof mips_howto_table[0]);
940 
 
941 
      /* The REFHI reloc requires special handling.  It must be followed
942 
         by a REFLO reloc, and the addend is formed from both relocs.  */
943 
      if (int_rel.r_type == MIPS_R_REFHI)
944 
        {
945 
          struct external_reloc *lo_ext_rel;
946 
 
947 
          /* As a GNU extension, permit an arbitrary number of REFHI
948 
             relocs before the REFLO reloc.  This permits gcc to emit
949 
             the HI and LO relocs itself.  */
950 
          for (lo_ext_rel = ext_rel + 1;
951 
               lo_ext_rel < ext_rel_end;
952 
               lo_ext_rel++)
953 
            {
954 
              mips_ecoff_swap_reloc_in (input_bfd, (PTR) lo_ext_rel,
955 
                                        &lo_int_rel);
956 
              if (lo_int_rel.r_type != int_rel.r_type)
957 
                break;
958 
            }
959 
 
960 
          if (lo_ext_rel < ext_rel_end
961 
              && lo_int_rel.r_type == MIPS_R_REFLO
962 
              && int_rel.r_extern == lo_int_rel.r_extern
963 
              && int_rel.r_symndx == lo_int_rel.r_symndx)
964 
            {
965 
              use_lo = TRUE;
966 
              if (lo_ext_rel == ext_rel + 1)
967 
                got_lo = TRUE;
968 
            }
969 
        }
970 
 
971 
      howto = &mips_howto_table[int_rel.r_type];
972 
 
973 
      if (int_rel.r_extern)
974 
        {
975 
          h = sym_hashes[int_rel.r_symndx];
976 
          /* If h is NULL, that means that there is a reloc against an
977 
             external symbol which we thought was just a debugging
978 
             symbol.  This should not happen.  */
979 
          if (h == (struct ecoff_link_hash_entry *) NULL)
980 
            abort ();
981 
        }
982 
      else
983 
        {
984 
          if (int_rel.r_symndx < 0 || int_rel.r_symndx >= NUM_RELOC_SECTIONS)
985 
            s = NULL;
986 
          else
987 
            s = symndx_to_section[int_rel.r_symndx];
988 
 
989 
          if (s == (asection *) NULL)
990 
            abort ();
991 
        }
992 
 
993 
      /* The GPREL reloc uses an addend: the difference in the GP
994 
         values.  */
995 
      if (int_rel.r_type != MIPS_R_GPREL
996 
          && int_rel.r_type != MIPS_R_LITERAL)
997 
        addend = 0;
998 
      else
999 
        {
1000 
          if (gp_undefined)
1001 
            {
1002 
              if (! ((*info->callbacks->reloc_dangerous)
1003 
                     (info, _("GP relative relocation used when GP not defined"),
1004 
                      input_bfd, input_section,
1005 
                      int_rel.r_vaddr - input_section->vma)))
1006 
                return FALSE;
1007 
              /* Only give the error once per link.  */
1008 
              gp = 4;
1009 
              _bfd_set_gp_value (output_bfd, gp);
1010 
              gp_undefined = FALSE;
1011 
            }
1012 
          if (! int_rel.r_extern)
1013 
            {
1014 
              /* This is a relocation against a section.  The current
1015 
                 addend in the instruction is the difference between
1016 
                 INPUT_SECTION->vma and the GP value of INPUT_BFD.  We
1017 
                 must change this to be the difference between the
1018 
                 final definition (which will end up in RELOCATION)
1019 
                 and the GP value of OUTPUT_BFD (which is in GP).  */
1020 
              addend = ecoff_data (input_bfd)->gp - gp;
1021 
            }
1022 
          else if (! info->relocatable
1023 
                   || h->root.type == bfd_link_hash_defined
1024 
                   || h->root.type == bfd_link_hash_defweak)
1025 
            {
1026 
              /* This is a relocation against a defined symbol.  The
1027 
                 current addend in the instruction is simply the
1028 
                 desired offset into the symbol (normally zero).  We
1029 
                 are going to change this into a relocation against a
1030 
                 defined symbol, so we want the instruction to hold
1031 
                 the difference between the final definition of the
1032 
                 symbol (which will end up in RELOCATION) and the GP
1033 
                 value of OUTPUT_BFD (which is in GP).  */
1034 
              addend = - gp;
1035 
            }
1036 
          else
1037 
            {
1038 
              /* This is a relocation against an undefined or common
1039 
                 symbol.  The current addend in the instruction is
1040 
                 simply the desired offset into the symbol (normally
1041 
                 zero).  We are generating relocatable output, and we
1042 
                 aren't going to define this symbol, so we just leave
1043 
                 the instruction alone.  */
1044 
              addend = 0;
1045 
            }
1046 
        }
1047 
 
1048 
      if (info->relocatable)
1049 
        {
1050 
          /* We are generating relocatable output, and must convert
1051 
             the existing reloc.  */
1052 
          if (int_rel.r_extern)
1053 
            {
1054 
              if ((h->root.type == bfd_link_hash_defined
1055 
                   || h->root.type == bfd_link_hash_defweak)
1056 
                  && ! bfd_is_abs_section (h->root.u.def.section))
1057 
                {
1058 
                  const char *name;
1059 
 
1060 
                  /* This symbol is defined in the output.  Convert
1061 
                     the reloc from being against the symbol to being
1062 
                     against the section.  */
1063 
 
1064 
                  /* Clear the r_extern bit.  */
1065 
                  int_rel.r_extern = 0;
1066 
 
1067 
                  /* Compute a new r_symndx value.  */
1068 
                  s = h->root.u.def.section;
1069 
                  name = bfd_get_section_name (output_bfd,
1070 
                                               s->output_section);
1071 
 
1072 
                  int_rel.r_symndx = -1;
1073 
                  switch (name[1])
1074 
                    {
1075 
                    case 'b':
1076 
                      if (strcmp (name, ".bss") == 0)
1077 
                        int_rel.r_symndx = RELOC_SECTION_BSS;
1078 
                      break;
1079 
                    case 'd':
1080 
                      if (strcmp (name, ".data") == 0)
1081 
                        int_rel.r_symndx = RELOC_SECTION_DATA;
1082 
                      break;
1083 
                    case 'f':
1084 
                      if (strcmp (name, ".fini") == 0)
1085 
                        int_rel.r_symndx = RELOC_SECTION_FINI;
1086 
                      break;
1087 
                    case 'i':
1088 
                      if (strcmp (name, ".init") == 0)
1089 
                        int_rel.r_symndx = RELOC_SECTION_INIT;
1090 
                      break;
1091 
                    case 'l':
1092 
                      if (strcmp (name, ".lit8") == 0)
1093 
                        int_rel.r_symndx = RELOC_SECTION_LIT8;
1094 
                      else if (strcmp (name, ".lit4") == 0)
1095 
                        int_rel.r_symndx = RELOC_SECTION_LIT4;
1096 
                      break;
1097 
                    case 'r':
1098 
                      if (strcmp (name, ".rdata") == 0)
1099 
                        int_rel.r_symndx = RELOC_SECTION_RDATA;
1100 
                      break;
1101 
                    case 's':
1102 
                      if (strcmp (name, ".sdata") == 0)
1103 
                        int_rel.r_symndx = RELOC_SECTION_SDATA;
1104 
                      else if (strcmp (name, ".sbss") == 0)
1105 
                        int_rel.r_symndx = RELOC_SECTION_SBSS;
1106 
                      break;
1107 
                    case 't':
1108 
                      if (strcmp (name, ".text") == 0)
1109 
                        int_rel.r_symndx = RELOC_SECTION_TEXT;
1110 
                      break;
1111 
                    }
1112 
 
1113 
                  if (int_rel.r_symndx == -1)
1114 
                    abort ();
1115 
 
1116 
                  /* Add the section VMA and the symbol value.  */
1117 
                  relocation = (h->root.u.def.value
1118 
                                + s->output_section->vma
1119 
                                + s->output_offset);
1120 
 
1121 
                  /* For a PC relative relocation, the object file
1122 
                     currently holds just the addend.  We must adjust
1123 
                     by the address to get the right value.  */
1124 
                  if (howto->pc_relative)
1125 
                    relocation -= int_rel.r_vaddr - input_section->vma;
1126 
 
1127 
                  h = NULL;
1128 
                }
1129 
              else
1130 
                {
1131 
                  /* Change the symndx value to the right one for the
1132 
                     output BFD.  */
1133 
                  int_rel.r_symndx = h->indx;
1134 
                  if (int_rel.r_symndx == -1)
1135 
                    {
1136 
                      /* This symbol is not being written out.  */
1137 
                      if (! ((*info->callbacks->unattached_reloc)
1138 
                             (info, h->root.root.string, input_bfd,
1139 
                              input_section,
1140 
                              int_rel.r_vaddr - input_section->vma)))
1141 
                        return FALSE;
1142 
                      int_rel.r_symndx = 0;
1143 
                    }
1144 
                  relocation = 0;
1145 
                }
1146 
            }
1147 
          else
1148 
            {
1149 
              /* This is a relocation against a section.  Adjust the
1150 
                 value by the amount the section moved.  */
1151 
              relocation = (s->output_section->vma
1152 
                            + s->output_offset
1153 
                            - s->vma);
1154 
            }
1155 
 
1156 
          relocation += addend;
1157 
          addend = 0;
1158 
 
1159 
          /* Adjust a PC relative relocation by removing the reference
1160 
             to the original address in the section and including the
1161 
             reference to the new address.  */
1162 
          if (howto->pc_relative)
1163 
            relocation -= (input_section->output_section->vma
1164 
                           + input_section->output_offset
1165 
                           - input_section->vma);
1166 
 
1167 
          /* Adjust the contents.  */
1168 
          if (relocation == 0)
1169 
            r = bfd_reloc_ok;
1170 
          else
1171 
            {
1172 
              if (int_rel.r_type != MIPS_R_REFHI)
1173 
                r = _bfd_relocate_contents (howto, input_bfd, relocation,
1174 
                                            (contents
1175 
                                             + int_rel.r_vaddr
1176 
                                             - input_section->vma));
1177 
              else
1178 
                {
1179 
                  mips_relocate_hi (&int_rel,
1180 
                                    use_lo ? &lo_int_rel : NULL,
1181 
                                    input_bfd, input_section, contents,
1182 
                                    relocation);
1183 
                  r = bfd_reloc_ok;
1184 
                }
1185 
            }
1186 
 
1187 
          /* Adjust the reloc address.  */
1188 
          int_rel.r_vaddr += (input_section->output_section->vma
1189 
                              + input_section->output_offset
1190 
                              - input_section->vma);
1191 
 
1192 
          /* Save the changed reloc information.  */
1193 
          mips_ecoff_swap_reloc_out (input_bfd, &int_rel, (PTR) ext_rel);
1194 
        }
1195 
      else
1196 
        {
1197 
          /* We are producing a final executable.  */
1198 
          if (int_rel.r_extern)
1199 
            {
1200 
              /* This is a reloc against a symbol.  */
1201 
              if (h->root.type == bfd_link_hash_defined
1202 
                  || h->root.type == bfd_link_hash_defweak)
1203 
                {
1204 
                  asection *hsec;
1205 
 
1206 
                  hsec = h->root.u.def.section;
1207 
                  relocation = (h->root.u.def.value
1208 
                                + hsec->output_section->vma
1209 
                                + hsec->output_offset);
1210 
                }
1211 
              else
1212 
                {
1213 
                  if (! ((*info->callbacks->undefined_symbol)
1214 
                         (info, h->root.root.string, input_bfd,
1215 
                          input_section,
1216 
                          int_rel.r_vaddr - input_section->vma, TRUE)))
1217 
                    return FALSE;
1218 
                  relocation = 0;
1219 
                }
1220 
            }
1221 
          else
1222 
            {
1223 
              /* This is a reloc against a section.  */
1224 
              relocation = (s->output_section->vma
1225 
                            + s->output_offset
1226 
                            - s->vma);
1227 
 
1228 
              /* A PC relative reloc is already correct in the object
1229 
                 file.  Make it look like a pcrel_offset relocation by
1230 
                 adding in the start address.  */
1231 
              if (howto->pc_relative)
1232 
                relocation += int_rel.r_vaddr;
1233 
            }
1234 
 
1235 
          if (int_rel.r_type != MIPS_R_REFHI)
1236 
            r = _bfd_final_link_relocate (howto,
1237 
                                          input_bfd,
1238 
                                          input_section,
1239 
                                          contents,
1240 
                                          (int_rel.r_vaddr
1241 
                                           - input_section->vma),
1242 
                                          relocation,
1243 
                                          addend);
1244 
          else
1245 
            {
1246 
              mips_relocate_hi (&int_rel,
1247 
                                use_lo ? &lo_int_rel : NULL,
1248 
                                input_bfd, input_section, contents,
1249 
                                relocation);
1250 
              r = bfd_reloc_ok;
1251 
            }
1252 
        }
1253 
 
1254 
      /* MIPS_R_JMPADDR requires peculiar overflow detection.  The
1255 
         instruction provides a 28 bit address (the two lower bits are
1256 
         implicit zeroes) which is combined with the upper four bits
1257 
         of the instruction address.  */
1258 
      if (r == bfd_reloc_ok
1259 
          && int_rel.r_type == MIPS_R_JMPADDR
1260 
          && (((relocation
1261 
                + addend
1262 
                + (int_rel.r_extern ? 0 : s->vma))
1263 
               & 0xf0000000)
1264 
              != ((input_section->output_section->vma
1265 
                   + input_section->output_offset
1266 
                   + (int_rel.r_vaddr - input_section->vma))
1267 
                  & 0xf0000000)))
1268 
        r = bfd_reloc_overflow;
1269 
 
1270 
      if (r != bfd_reloc_ok)
1271 
        {
1272 
          switch (r)
1273 
            {
1274 
            default:
1275 
            case bfd_reloc_outofrange:
1276 
              abort ();
1277 
            case bfd_reloc_overflow:
1278 
              {
1279 
                const char *name;
1280 
 
1281 
                if (int_rel.r_extern)
1282 
                  name = NULL;
1283 
                else
1284 
                  name = bfd_section_name (input_bfd, s);
1285 
                if (! ((*info->callbacks->reloc_overflow)
1286 
                       (info, (h ? &h->root : NULL), name, howto->name,
1287 
                        (bfd_vma) 0, input_bfd, input_section,
1288 
                        int_rel.r_vaddr - input_section->vma)))
1289 
                  return FALSE;
1290 
              }
1291 
              break;
1292 
            }
1293 
        }
1294 
    }
1295 
 
1296 
  return TRUE;
1297 
}
1298 
 
1299 
/* This is the ECOFF backend structure.  The backend field of the
1300 
   target vector points to this.  */
1301 
 
1302 
static const struct ecoff_backend_data mips_ecoff_backend_data =
1303 
{
1304 
  /* COFF backend structure.  */
1305 
  {
1306 
    (void (*) PARAMS ((bfd *,PTR,int,int,int,int,PTR))) bfd_void, /* aux_in */
1307 
    (void (*) PARAMS ((bfd *,PTR,PTR))) bfd_void, /* sym_in */
1308 
    (void (*) PARAMS ((bfd *,PTR,PTR))) bfd_void, /* lineno_in */
1309 
    (unsigned (*) PARAMS ((bfd *,PTR,int,int,int,int,PTR)))bfd_void,/*aux_out*/
1310 
    (unsigned (*) PARAMS ((bfd *,PTR,PTR))) bfd_void, /* sym_out */
1311 
    (unsigned (*) PARAMS ((bfd *,PTR,PTR))) bfd_void, /* lineno_out */
1312 
    (unsigned (*) PARAMS ((bfd *,PTR,PTR))) bfd_void, /* reloc_out */
1313 
    mips_ecoff_swap_filehdr_out, mips_ecoff_swap_aouthdr_out,
1314 
    mips_ecoff_swap_scnhdr_out,
1315 
    FILHSZ, AOUTSZ, SCNHSZ, 0, 0, 0, 0, FILNMLEN, TRUE,
1316 
    ECOFF_NO_LONG_SECTION_NAMES, 4, FALSE, 2,
1317 
    mips_ecoff_swap_filehdr_in, mips_ecoff_swap_aouthdr_in,
1318 
    mips_ecoff_swap_scnhdr_in, NULL,
1319 
    mips_ecoff_bad_format_hook, _bfd_ecoff_set_arch_mach_hook,
1320 
    _bfd_ecoff_mkobject_hook, _bfd_ecoff_styp_to_sec_flags,
1321 
    _bfd_ecoff_set_alignment_hook, _bfd_ecoff_slurp_symbol_table,
1322 
    NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1323 
    NULL, NULL, NULL
1324 
  },
1325 
  /* Supported architecture.  */
1326 
  bfd_arch_mips,
1327 
  /* Initial portion of armap string.  */
1328 
  "__________",
1329 
  /* The page boundary used to align sections in a demand-paged
1330 
     executable file.  E.g., 0x1000.  */
1331 
  0x1000,
1332 
  /* TRUE if the .rdata section is part of the text segment, as on the
1333 
     Alpha.  FALSE if .rdata is part of the data segment, as on the
1334 
     MIPS.  */
1335 
  FALSE,
1336 
  /* Bitsize of constructor entries.  */
1337 
  32,
1338 
  /* Reloc to use for constructor entries.  */
1339 
  &mips_howto_table[MIPS_R_REFWORD],
1340 
  {
1341 
    /* Symbol table magic number.  */
1342 
    magicSym,
1343 
    /* Alignment of debugging information.  E.g., 4.  */
1344 
    4,
1345 
    /* Sizes of external symbolic information.  */
1346 
    sizeof (struct hdr_ext),
1347 
    sizeof (struct dnr_ext),
1348 
    sizeof (struct pdr_ext),
1349 
    sizeof (struct sym_ext),
1350 
    sizeof (struct opt_ext),
1351 
    sizeof (struct fdr_ext),
1352 
    sizeof (struct rfd_ext),
1353 
    sizeof (struct ext_ext),
1354 
    /* Functions to swap in external symbolic data.  */
1355 
    ecoff_swap_hdr_in,
1356 
    ecoff_swap_dnr_in,
1357 
    ecoff_swap_pdr_in,
1358 
    ecoff_swap_sym_in,
1359 
    ecoff_swap_opt_in,
1360 
    ecoff_swap_fdr_in,
1361 
    ecoff_swap_rfd_in,
1362 
    ecoff_swap_ext_in,
1363 
    _bfd_ecoff_swap_tir_in,
1364 
    _bfd_ecoff_swap_rndx_in,
1365 
    /* Functions to swap out external symbolic data.  */
1366 
    ecoff_swap_hdr_out,
1367 
    ecoff_swap_dnr_out,
1368 
    ecoff_swap_pdr_out,
1369 
    ecoff_swap_sym_out,
1370 
    ecoff_swap_opt_out,
1371 
    ecoff_swap_fdr_out,
1372 
    ecoff_swap_rfd_out,
1373 
    ecoff_swap_ext_out,
1374 
    _bfd_ecoff_swap_tir_out,
1375 
    _bfd_ecoff_swap_rndx_out,
1376 
    /* Function to read in symbolic data.  */
1377 
    _bfd_ecoff_slurp_symbolic_info
1378 
  },
1379 
  /* External reloc size.  */
1380 
  RELSZ,
1381 
  /* Reloc swapping functions.  */
1382 
  mips_ecoff_swap_reloc_in,
1383 
  mips_ecoff_swap_reloc_out,
1384 
  /* Backend reloc tweaking.  */
1385 
  mips_adjust_reloc_in,
1386 
  mips_adjust_reloc_out,
1387 
  /* Relocate section contents while linking.  */
1388 
  mips_relocate_section,
1389 
  /* Do final adjustments to filehdr and aouthdr.  */
1390 
  NULL,
1391 
  /* Read an element from an archive at a given file position.  */
1392 
  _bfd_get_elt_at_filepos
1393 
};
1394 
 
1395 
/* Looking up a reloc type is MIPS specific.  */
1396 
#define _bfd_ecoff_bfd_reloc_type_lookup mips_bfd_reloc_type_lookup
1397 
#define _bfd_ecoff_bfd_reloc_name_lookup mips_bfd_reloc_name_lookup
1398 
 
1399 
/* Getting relocated section contents is generic.  */
1400 
#define _bfd_ecoff_bfd_get_relocated_section_contents \
1401 
  bfd_generic_get_relocated_section_contents
1402 
 
1403 
/* Handling file windows is generic.  */
1404 
#define _bfd_ecoff_get_section_contents_in_window \
1405 
  _bfd_generic_get_section_contents_in_window
1406 
 
1407 
/* Relaxing sections is MIPS specific.  */
1408 
#define _bfd_ecoff_bfd_relax_section bfd_generic_relax_section
1409 
 
1410 
/* GC of sections is not done.  */
1411 
#define _bfd_ecoff_bfd_gc_sections bfd_generic_gc_sections
1412 
 
1413 
/* Merging of sections is not done.  */
1414 
#define _bfd_ecoff_bfd_merge_sections bfd_generic_merge_sections
1415 
 
1416 
#define _bfd_ecoff_bfd_is_group_section bfd_generic_is_group_section
1417 
#define _bfd_ecoff_bfd_discard_group bfd_generic_discard_group
1418 
#define _bfd_ecoff_section_already_linked \
1419 
  _bfd_generic_section_already_linked
1420 
#define _bfd_ecoff_bfd_define_common_symbol bfd_generic_define_common_symbol
1421 
 
1422 
extern const bfd_target ecoff_big_vec;
1423 
 
1424 
const bfd_target ecoff_little_vec =
1425 
{
1426 
  "ecoff-littlemips",           /* name */
1427 
  bfd_target_ecoff_flavour,
1428 
  BFD_ENDIAN_LITTLE,            /* data byte order is little */
1429 
  BFD_ENDIAN_LITTLE,            /* header byte order is little */
1430 
 
1431 
  (HAS_RELOC | EXEC_P |         /* object flags */
1432 
   HAS_LINENO | HAS_DEBUG |
1433 
   HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED),
1434 
 
1435 
  (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_CODE | SEC_DATA),
1436 
  0,                             /* leading underscore */
1437 
  ' ',                          /* ar_pad_char */
1438 
  15,                           /* ar_max_namelen */
1439 
  bfd_getl64, bfd_getl_signed_64, bfd_putl64,
1440 
     bfd_getl32, bfd_getl_signed_32, bfd_putl32,
1441 
     bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* data */
1442 
  bfd_getl64, bfd_getl_signed_64, bfd_putl64,
1443 
     bfd_getl32, bfd_getl_signed_32, bfd_putl32,
1444 
     bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* hdrs */
1445 
 
1446 
  {_bfd_dummy_target, coff_object_p, /* bfd_check_format */
1447 
     bfd_generic_archive_p, _bfd_dummy_target},
1448 
  {bfd_false, _bfd_ecoff_mkobject,  /* bfd_set_format */
1449 
     _bfd_generic_mkarchive, bfd_false},
1450 
  {bfd_false, _bfd_ecoff_write_object_contents, /* bfd_write_contents */
1451 
     _bfd_write_archive_contents, bfd_false},
1452 
 
1453 
     BFD_JUMP_TABLE_GENERIC (_bfd_ecoff),
1454 
     BFD_JUMP_TABLE_COPY (_bfd_ecoff),
1455 
     BFD_JUMP_TABLE_CORE (_bfd_nocore),
1456 
     BFD_JUMP_TABLE_ARCHIVE (_bfd_ecoff),
1457 
     BFD_JUMP_TABLE_SYMBOLS (_bfd_ecoff),
1458 
     BFD_JUMP_TABLE_RELOCS (_bfd_ecoff),
1459 
     BFD_JUMP_TABLE_WRITE (_bfd_ecoff),
1460 
     BFD_JUMP_TABLE_LINK (_bfd_ecoff),
1461 
     BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
1462 
 
1463 
  & ecoff_big_vec,
1464 
 
1465 
  (PTR) &mips_ecoff_backend_data
1466 
};
1467 
 
1468 
const bfd_target ecoff_big_vec =
1469 
{
1470 
  "ecoff-bigmips",              /* name */
1471 
  bfd_target_ecoff_flavour,
1472 
  BFD_ENDIAN_BIG,               /* data byte order is big */
1473 
  BFD_ENDIAN_BIG,               /* header byte order is big */
1474 
 
1475 
  (HAS_RELOC | EXEC_P |         /* object flags */
1476 
   HAS_LINENO | HAS_DEBUG |
1477 
   HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED),
1478 
 
1479 
  (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_CODE | SEC_DATA),
1480 
  0,                             /* leading underscore */
1481 
  ' ',                          /* ar_pad_char */
1482 
  15,                           /* ar_max_namelen */
1483 
  bfd_getb64, bfd_getb_signed_64, bfd_putb64,
1484 
     bfd_getb32, bfd_getb_signed_32, bfd_putb32,
1485 
     bfd_getb16, bfd_getb_signed_16, bfd_putb16,
1486 
  bfd_getb64, bfd_getb_signed_64, bfd_putb64,
1487 
     bfd_getb32, bfd_getb_signed_32, bfd_putb32,
1488 
     bfd_getb16, bfd_getb_signed_16, bfd_putb16,
1489 
 {_bfd_dummy_target, coff_object_p, /* bfd_check_format */
1490 
    bfd_generic_archive_p, _bfd_dummy_target},
1491 
 {bfd_false, _bfd_ecoff_mkobject, /* bfd_set_format */
1492 
    _bfd_generic_mkarchive, bfd_false},
1493 
 {bfd_false, _bfd_ecoff_write_object_contents, /* bfd_write_contents */
1494 
    _bfd_write_archive_contents, bfd_false},
1495 
 
1496 
     BFD_JUMP_TABLE_GENERIC (_bfd_ecoff),
1497 
     BFD_JUMP_TABLE_COPY (_bfd_ecoff),
1498 
     BFD_JUMP_TABLE_CORE (_bfd_nocore),
1499 
     BFD_JUMP_TABLE_ARCHIVE (_bfd_ecoff),
1500 
     BFD_JUMP_TABLE_SYMBOLS (_bfd_ecoff),
1501 
     BFD_JUMP_TABLE_RELOCS (_bfd_ecoff),
1502 
     BFD_JUMP_TABLE_WRITE (_bfd_ecoff),
1503 
     BFD_JUMP_TABLE_LINK (_bfd_ecoff),
1504 
     BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
1505 
 
1506 
  & ecoff_little_vec,
1507 
 
1508 
  (PTR) &mips_ecoff_backend_data
1509 
};
1510 
 
1511 
const bfd_target ecoff_biglittle_vec =
1512 
{
1513 
  "ecoff-biglittlemips",                /* name */
1514 
  bfd_target_ecoff_flavour,
1515 
  BFD_ENDIAN_LITTLE,            /* data byte order is little */
1516 
  BFD_ENDIAN_BIG,               /* header byte order is big */
1517 
 
1518 
  (HAS_RELOC | EXEC_P |         /* object flags */
1519 
   HAS_LINENO | HAS_DEBUG |
1520 
   HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED),
1521 
 
1522 
  (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_CODE | SEC_DATA),
1523 
  0,                             /* leading underscore */
1524 
  ' ',                          /* ar_pad_char */
1525 
  15,                           /* ar_max_namelen */
1526 
  bfd_getl64, bfd_getl_signed_64, bfd_putl64,
1527 
     bfd_getl32, bfd_getl_signed_32, bfd_putl32,
1528 
     bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* data */
1529 
  bfd_getb64, bfd_getb_signed_64, bfd_putb64,
1530 
     bfd_getb32, bfd_getb_signed_32, bfd_putb32,
1531 
     bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* hdrs */
1532 
 
1533 
  {_bfd_dummy_target, coff_object_p, /* bfd_check_format */
1534 
     bfd_generic_archive_p, _bfd_dummy_target},
1535 
  {bfd_false, _bfd_ecoff_mkobject,  /* bfd_set_format */
1536 
     _bfd_generic_mkarchive, bfd_false},
1537 
  {bfd_false, _bfd_ecoff_write_object_contents, /* bfd_write_contents */
1538 
     _bfd_write_archive_contents, bfd_false},
1539 
 
1540 
     BFD_JUMP_TABLE_GENERIC (_bfd_ecoff),
1541 
     BFD_JUMP_TABLE_COPY (_bfd_ecoff),
1542 
     BFD_JUMP_TABLE_CORE (_bfd_nocore),
1543 
     BFD_JUMP_TABLE_ARCHIVE (_bfd_ecoff),
1544 
     BFD_JUMP_TABLE_SYMBOLS (_bfd_ecoff),
1545 
     BFD_JUMP_TABLE_RELOCS (_bfd_ecoff),
1546 
     BFD_JUMP_TABLE_WRITE (_bfd_ecoff),
1547 
     BFD_JUMP_TABLE_LINK (_bfd_ecoff),
1548 
     BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
1549 
 
1550 
  NULL,
1551 
 
1552 
  (PTR) &mips_ecoff_backend_data
1553 
};

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.