* aout-arm.c, aout-target.h, aoutx.h, archive.c, armnetbsd.c,
[external/binutils.git] / bfd / pe-mips.c
1 /* BFD back-end for MIPS PE COFF files.
2    Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
3    2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
4    Modified from coff-i386.c by DJ Delorie, dj@cygnus.com
5
6 This file is part of BFD, the Binary File Descriptor library.
7
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
12
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
21
22 #define COFF_WITH_PE
23 #define COFF_LONG_SECTION_NAMES
24 #define PCRELOFFSET TRUE
25
26 #include "bfd.h"
27 #include "sysdep.h"
28 #include "libbfd.h"
29
30 #include "coff/mipspe.h"
31
32 #include "coff/internal.h"
33
34 #include "coff/pe.h"
35
36 #include "libcoff.h"
37
38 static bfd_reloc_status_type coff_mips_reloc
39   PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
40 static reloc_howto_type *coff_mips_rtype_to_howto
41   PARAMS ((bfd *, asection *, struct internal_reloc *,
42            struct coff_link_hash_entry *, struct internal_syment *,
43            bfd_vma *));
44
45 static bfd_boolean in_reloc_p
46   PARAMS ((bfd *, reloc_howto_type *));
47 static reloc_howto_type * coff_mips_reloc_type_lookup
48   PARAMS ((bfd *, bfd_reloc_code_real_type));
49 static void mips_swap_reloc_in
50   PARAMS ((bfd *, PTR, PTR));
51 static unsigned int mips_swap_reloc_out
52   PARAMS ((bfd *, PTR, PTR));
53 static bfd_boolean coff_pe_mips_relocate_section
54   PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
55            struct internal_reloc *, struct internal_syment *, asection **));
56
57 #define COFF_DEFAULT_SECTION_ALIGNMENT_POWER (2)
58 /* The page size is a guess based on ELF.  */
59
60 #define COFF_PAGE_SIZE 0x1000
61
62 /* For some reason when using mips COFF the value stored in the .text
63    section for a reference to a common symbol is the value itself plus
64    any desired offset.  Ian Taylor, Cygnus Support.  */
65
66 /* If we are producing relocatable output, we need to do some
67    adjustments to the object file that are not done by the
68    bfd_perform_relocation function.  This function is called by every
69    reloc type to make any required adjustments.  */
70
71 static bfd_reloc_status_type
72 coff_mips_reloc (abfd, reloc_entry, symbol, data, input_section, output_bfd,
73                  error_message)
74      bfd *abfd;
75      arelent *reloc_entry;
76      asymbol *symbol;
77      PTR data;
78      asection *input_section ATTRIBUTE_UNUSED;
79      bfd *output_bfd;
80      char **error_message ATTRIBUTE_UNUSED;
81 {
82   symvalue diff;
83
84   if (output_bfd == (bfd *) NULL)
85     return bfd_reloc_continue;
86
87   if (bfd_is_com_section (symbol->section))
88     {
89 #ifndef COFF_WITH_PE
90       /* We are relocating a common symbol.  The current value in the
91          object file is ORIG + OFFSET, where ORIG is the value of the
92          common symbol as seen by the object file when it was compiled
93          (this may be zero if the symbol was undefined) and OFFSET is
94          the offset into the common symbol (normally zero, but may be
95          non-zero when referring to a field in a common structure).
96          ORIG is the negative of reloc_entry->addend, which is set by
97          the CALC_ADDEND macro below.  We want to replace the value in
98          the object file with NEW + OFFSET, where NEW is the value of
99          the common symbol which we are going to put in the final
100          object file.  NEW is symbol->value.  */
101       diff = symbol->value + reloc_entry->addend;
102 #else
103       /* In PE mode, we do not offset the common symbol.  */
104       diff = reloc_entry->addend;
105 #endif
106     }
107   else
108     {
109       /* For some reason bfd_perform_relocation always effectively
110          ignores the addend for a COFF target when producing
111          relocatable output.  This seems to be always wrong for 386
112          COFF, so we handle the addend here instead.  */
113       diff = reloc_entry->addend;
114     }
115
116 #define DOIT(x) \
117   x = ((x & ~howto->dst_mask) | (((x & howto->src_mask) + (diff >> howto->rightshift)) & howto->dst_mask))
118
119     if (diff != 0)
120       {
121         reloc_howto_type *howto = reloc_entry->howto;
122         unsigned char *addr = (unsigned char *) data + reloc_entry->address;
123
124         switch (howto->size)
125           {
126           case 0:
127             {
128               char x = bfd_get_8 (abfd, addr);
129               DOIT (x);
130               bfd_put_8 (abfd, x, addr);
131             }
132             break;
133
134           case 1:
135             {
136               short x = bfd_get_16 (abfd, addr);
137               DOIT (x);
138               bfd_put_16 (abfd, (bfd_vma) x, addr);
139             }
140             break;
141
142           case 2:
143             {
144               long x = bfd_get_32 (abfd, addr);
145               DOIT (x);
146               bfd_put_32 (abfd, (bfd_vma) x, addr);
147             }
148             break;
149
150           default:
151             abort ();
152           }
153       }
154
155   /* Now let bfd_perform_relocation finish everything up.  */
156   return bfd_reloc_continue;
157 }
158
159 #ifdef COFF_WITH_PE
160 /* Return TRUE if this relocation should
161    appear in the output .reloc section.  */
162
163 static bfd_boolean
164 in_reloc_p (abfd, howto)
165      bfd * abfd ATTRIBUTE_UNUSED;
166      reloc_howto_type *howto;
167 {
168   return ! howto->pc_relative && howto->type != MIPS_R_RVA;
169 }
170 #endif
171
172 #ifndef PCRELOFFSET
173 #define PCRELOFFSET FALSE
174 #endif
175
176 static reloc_howto_type howto_table[] =
177 {
178   /* Reloc type 0 is ignored.  The reloc reading code ensures that
179      this is a reference to the .abs section, which will cause
180      bfd_perform_relocation to do nothing.  */
181   HOWTO (MIPS_R_ABSOLUTE,       /* type */
182          0,                     /* rightshift */
183          0,                     /* size (0 = byte, 1 = short, 2 = long) */
184          8,                     /* bitsize */
185          FALSE,                 /* pc_relative */
186          0,                     /* bitpos */
187          complain_overflow_dont, /* complain_on_overflow */
188          0,                     /* special_function */
189          "IGNORE",              /* name */
190          FALSE,                 /* partial_inplace */
191          0,                     /* src_mask */
192          0,                     /* dst_mask */
193          FALSE),                /* pcrel_offset */
194
195   /* A 16 bit reference to a symbol, normally from a data section.  */
196   HOWTO (MIPS_R_REFHALF,        /* type */
197          0,                     /* rightshift */
198          1,                     /* size (0 = byte, 1 = short, 2 = long) */
199          16,                    /* bitsize */
200          FALSE,                 /* pc_relative */
201          0,                     /* bitpos */
202          complain_overflow_bitfield, /* complain_on_overflow */
203          coff_mips_reloc,       /* special_function */
204          "REFHALF",             /* name */
205          TRUE,                  /* partial_inplace */
206          0xffff,                /* src_mask */
207          0xffff,                /* dst_mask */
208          FALSE),                /* pcrel_offset */
209
210   /* A 32 bit reference to a symbol, normally from a data section.  */
211   HOWTO (MIPS_R_REFWORD,        /* type */
212          0,                     /* rightshift */
213          2,                     /* size (0 = byte, 1 = short, 2 = long) */
214          32,                    /* bitsize */
215          FALSE,                 /* pc_relative */
216          0,                     /* bitpos */
217          complain_overflow_bitfield, /* complain_on_overflow */
218          coff_mips_reloc,       /* special_function */
219          "REFWORD",             /* name */
220          TRUE,                  /* partial_inplace */
221          0xffffffff,            /* src_mask */
222          0xffffffff,            /* dst_mask */
223          FALSE),                /* pcrel_offset */
224
225   /* A 26 bit absolute jump address.  */
226   HOWTO (MIPS_R_JMPADDR,        /* type */
227          2,                     /* rightshift */
228          2,                     /* size (0 = byte, 1 = short, 2 = long) */
229          26,                    /* bitsize */
230          FALSE,                 /* pc_relative */
231          0,                     /* bitpos */
232          complain_overflow_dont, /* complain_on_overflow */
233                                 /* This needs complex overflow
234                                    detection, because the upper four
235                                    bits must match the PC.  */
236          coff_mips_reloc,       /* special_function */
237          "JMPADDR",             /* name */
238          TRUE,                  /* partial_inplace */
239          0x3ffffff,             /* src_mask */
240          0x3ffffff,             /* dst_mask */
241          FALSE),                /* pcrel_offset */
242
243   /* The high 16 bits of a symbol value.  Handled by the function
244      mips_refhi_reloc.  */
245   HOWTO (MIPS_R_REFHI,          /* type */
246          16,                    /* rightshift */
247          2,                     /* size (0 = byte, 1 = short, 2 = long) */
248          16,                    /* bitsize */
249          FALSE,                 /* pc_relative */
250          0,                     /* bitpos */
251          complain_overflow_bitfield, /* complain_on_overflow */
252          coff_mips_reloc,       /* special_function */
253          "REFHI",               /* name */
254          TRUE,                  /* partial_inplace */
255          0xffff,                /* src_mask */
256          0xffff,                /* dst_mask */
257          FALSE),                /* pcrel_offset */
258
259   /* The low 16 bits of a symbol value.  */
260   HOWTO (MIPS_R_REFLO,          /* type */
261          0,                     /* rightshift */
262          2,                     /* size (0 = byte, 1 = short, 2 = long) */
263          16,                    /* bitsize */
264          FALSE,                 /* pc_relative */
265          0,                     /* bitpos */
266          complain_overflow_dont, /* complain_on_overflow */
267          coff_mips_reloc,       /* special_function */
268          "REFLO",               /* name */
269          TRUE,                  /* partial_inplace */
270          0xffff,                /* src_mask */
271          0xffff,                /* dst_mask */
272          FALSE),                /* pcrel_offset */
273
274   /* A reference to an offset from the gp register.  Handled by the
275      function mips_gprel_reloc.  */
276   HOWTO (MIPS_R_GPREL,          /* type */
277          0,                     /* rightshift */
278          2,                     /* size (0 = byte, 1 = short, 2 = long) */
279          16,                    /* bitsize */
280          FALSE,                 /* pc_relative */
281          0,                     /* bitpos */
282          complain_overflow_signed, /* complain_on_overflow */
283          coff_mips_reloc,       /* special_function */
284          "GPREL",               /* name */
285          TRUE,                  /* partial_inplace */
286          0xffff,                /* src_mask */
287          0xffff,                /* dst_mask */
288          FALSE),                /* pcrel_offset */
289
290   /* A reference to a literal using an offset from the gp register.
291      Handled by the function mips_gprel_reloc.  */
292   HOWTO (MIPS_R_LITERAL,        /* type */
293          0,                     /* rightshift */
294          2,                     /* size (0 = byte, 1 = short, 2 = long) */
295          16,                    /* bitsize */
296          FALSE,                 /* pc_relative */
297          0,                     /* bitpos */
298          complain_overflow_signed, /* complain_on_overflow */
299          coff_mips_reloc,       /* special_function */
300          "LITERAL",             /* name */
301          TRUE,                  /* partial_inplace */
302          0xffff,                /* src_mask */
303          0xffff,                /* dst_mask */
304          FALSE),                /* pcrel_offset */
305
306   EMPTY_HOWTO (8),
307   EMPTY_HOWTO (9),
308   EMPTY_HOWTO (10),
309   EMPTY_HOWTO (11),
310   EMPTY_HOWTO (12),
311   EMPTY_HOWTO (13),
312   EMPTY_HOWTO (14),
313   EMPTY_HOWTO (15),
314   EMPTY_HOWTO (16),
315   EMPTY_HOWTO (17),
316   EMPTY_HOWTO (18),
317   EMPTY_HOWTO (19),
318   EMPTY_HOWTO (20),
319   EMPTY_HOWTO (21),
320   EMPTY_HOWTO (22),
321   EMPTY_HOWTO (23),
322   EMPTY_HOWTO (24),
323   EMPTY_HOWTO (25),
324   EMPTY_HOWTO (26),
325   EMPTY_HOWTO (27),
326   EMPTY_HOWTO (28),
327   EMPTY_HOWTO (29),
328   EMPTY_HOWTO (30),
329   EMPTY_HOWTO (31),
330   EMPTY_HOWTO (32),
331   EMPTY_HOWTO (33),
332   HOWTO (MIPS_R_RVA,            /* type */
333          0,                     /* rightshift */
334          2,                     /* size (0 = byte, 1 = short, 2 = long) */
335          32,                    /* bitsize */
336          FALSE,                 /* pc_relative */
337          0,                     /* bitpos */
338          complain_overflow_bitfield, /* complain_on_overflow */
339          coff_mips_reloc,       /* special_function */
340          "rva32",               /* name */
341          TRUE,                  /* partial_inplace */
342          0xffffffff,            /* src_mask */
343          0xffffffff,            /* dst_mask */
344          FALSE),                /* pcrel_offset */
345   EMPTY_HOWTO (35),
346   EMPTY_HOWTO (36),
347   HOWTO (MIPS_R_PAIR,           /* type */
348          0,                     /* rightshift */
349          2,                     /* size (0 = byte, 1 = short, 2 = long) */
350          32,                    /* bitsize */
351          FALSE,                 /* pc_relative */
352          0,                     /* bitpos */
353          complain_overflow_bitfield, /* complain_on_overflow */
354          coff_mips_reloc,       /* special_function */
355          "PAIR",                /* name */
356          TRUE,                  /* partial_inplace */
357          0xffffffff,            /* src_mask */
358          0xffffffff,            /* dst_mask */
359          FALSE),                /* pcrel_offset */
360 };
361
362 /* Turn a howto into a reloc  nunmber */
363
364 #define SELECT_RELOC(x,howto) { x.r_type = howto->type; }
365 #define BADMAG(x) MIPSBADMAG(x)
366 #define MIPS 1                  /* Customize coffcode.h */
367
368 #define RTYPE2HOWTO(cache_ptr, dst) \
369             (cache_ptr)->howto = howto_table + (dst)->r_type;
370
371 /* Compute the addend of a reloc.  If the reloc is to a common symbol,
372    the object file contains the value of the common symbol.  By the
373    time this is called, the linker may be using a different symbol
374    from a different object file with a different value.  Therefore, we
375    hack wildly to locate the original symbol from this file so that we
376    can make the correct adjustment.  This macro sets coffsym to the
377    symbol from the original file, and uses it to set the addend value
378    correctly.  If this is not a common symbol, the usual addend
379    calculation is done, except that an additional tweak is needed for
380    PC relative relocs.
381    FIXME: This macro refers to symbols and asect; these are from the
382    calling function, not the macro arguments.  */
383
384 #define CALC_ADDEND(abfd, ptr, reloc, cache_ptr)                \
385   {                                                             \
386     coff_symbol_type *coffsym = (coff_symbol_type *) NULL;      \
387     if (ptr && bfd_asymbol_bfd (ptr) != abfd)                   \
388       coffsym = (obj_symbols (abfd)                             \
389                  + (cache_ptr->sym_ptr_ptr - symbols));         \
390     else if (ptr)                                               \
391       coffsym = coff_symbol_from (abfd, ptr);                   \
392     if (coffsym != (coff_symbol_type *) NULL                    \
393         && coffsym->native->u.syment.n_scnum == 0)              \
394       cache_ptr->addend = - coffsym->native->u.syment.n_value;  \
395     else if (ptr && bfd_asymbol_bfd (ptr) == abfd               \
396              && ptr->section != (asection *) NULL)              \
397       cache_ptr->addend = - (ptr->section->vma + ptr->value);   \
398     else                                                        \
399       cache_ptr->addend = 0;                                    \
400     if (ptr && howto_table[reloc.r_type].pc_relative)           \
401       cache_ptr->addend += asect->vma;                          \
402   }
403
404 /* Convert an rtype to howto for the COFF backend linker.  */
405
406 static reloc_howto_type *
407 coff_mips_rtype_to_howto (abfd, sec, rel, h, sym, addendp)
408      bfd *abfd ATTRIBUTE_UNUSED;
409      asection *sec;
410      struct internal_reloc *rel;
411      struct coff_link_hash_entry *h;
412      struct internal_syment *sym;
413      bfd_vma *addendp;
414 {
415
416   reloc_howto_type *howto;
417
418   howto = howto_table + rel->r_type;
419
420 #ifdef COFF_WITH_PE
421   *addendp = 0;
422 #endif
423
424   if (howto->pc_relative)
425     *addendp += sec->vma;
426
427   if (sym != NULL && sym->n_scnum == 0 && sym->n_value != 0)
428     {
429       /* This is a common symbol.  The section contents include the
430          size (sym->n_value) as an addend.  The relocate_section
431          function will be adding in the final value of the symbol.  We
432          need to subtract out the current size in order to get the
433          correct result.  */
434
435       BFD_ASSERT (h != NULL);
436
437 #ifndef COFF_WITH_PE
438       /* I think we *do* want to bypass this.  If we don't, I have
439          seen some data parameters get the wrong relocation address.
440          If I link two versions with and without this section bypassed
441          and then do a binary comparison, the addresses which are
442          different can be looked up in the map.  The case in which
443          this section has been bypassed has addresses which correspond
444          to values I can find in the map.  */
445       *addendp -= sym->n_value;
446 #endif
447     }
448
449 #ifndef COFF_WITH_PE
450   /* If the output symbol is common (in which case this must be a
451      relocatable link), we need to add in the final size of the
452      common symbol.  */
453   if (h != NULL && h->root.type == bfd_link_hash_common)
454     *addendp += h->root.u.c.size;
455 #endif
456
457 #ifdef COFF_WITH_PE
458   if (howto->pc_relative)
459     {
460       *addendp -= 4;
461
462       /* If the symbol is defined, then the generic code is going to
463          add back the symbol value in order to cancel out an
464          adjustment it made to the addend.  However, we set the addend
465          to 0 at the start of this function.  We need to adjust here,
466          to avoid the adjustment the generic code will make.  FIXME:
467          This is getting a bit hackish.  */
468       if (sym != NULL && sym->n_scnum != 0)
469         *addendp -= sym->n_value;
470     }
471
472   if (rel->r_type == MIPS_R_RVA)
473     {
474       *addendp -= pe_data(sec->output_section->owner)->pe_opthdr.ImageBase;
475     }
476 #endif
477
478   return howto;
479 }
480
481 #define coff_rtype_to_howto coff_mips_rtype_to_howto
482
483 #define coff_bfd_reloc_type_lookup coff_mips_reloc_type_lookup
484
485 /* Get the howto structure for a generic reloc type.  */
486
487 static reloc_howto_type *
488 coff_mips_reloc_type_lookup (abfd, code)
489      bfd *abfd ATTRIBUTE_UNUSED;
490      bfd_reloc_code_real_type code;
491 {
492   int mips_type;
493
494   switch (code)
495     {
496     case BFD_RELOC_16:
497       mips_type = MIPS_R_REFHALF;
498       break;
499     case BFD_RELOC_32:
500     case BFD_RELOC_CTOR:
501       mips_type = MIPS_R_REFWORD;
502       break;
503     case BFD_RELOC_MIPS_JMP:
504       mips_type = MIPS_R_JMPADDR;
505       break;
506     case BFD_RELOC_HI16_S:
507       mips_type = MIPS_R_REFHI;
508       break;
509     case BFD_RELOC_LO16:
510       mips_type = MIPS_R_REFLO;
511       break;
512     case BFD_RELOC_GPREL16:
513       mips_type = MIPS_R_GPREL;
514       break;
515     case BFD_RELOC_MIPS_LITERAL:
516       mips_type = MIPS_R_LITERAL;
517       break;
518     case BFD_RELOC_RVA:
519       mips_type = MIPS_R_RVA;
520       break;
521     default:
522       return (reloc_howto_type *) NULL;
523     }
524
525   return &howto_table[mips_type];
526 }
527
528 static void
529 mips_swap_reloc_in (abfd, src, dst)
530      bfd *abfd;
531      PTR src;
532      PTR dst;
533 {
534   static struct internal_reloc pair_prev;
535   RELOC *reloc_src = (RELOC *) src;
536   struct internal_reloc *reloc_dst = (struct internal_reloc *) dst;
537
538   reloc_dst->r_vaddr = H_GET_32 (abfd, reloc_src->r_vaddr);
539   reloc_dst->r_symndx = H_GET_S32 (abfd, reloc_src->r_symndx);
540   reloc_dst->r_type = H_GET_16 (abfd, reloc_src->r_type);
541   reloc_dst->r_size = 0;
542   reloc_dst->r_extern = 0;
543   reloc_dst->r_offset = 0;
544
545   switch (reloc_dst->r_type)
546   {
547   case MIPS_R_REFHI:
548     pair_prev = *reloc_dst;
549     break;
550   case MIPS_R_PAIR:
551     reloc_dst->r_offset = reloc_dst->r_symndx;
552     if (reloc_dst->r_offset & 0x8000)
553       reloc_dst->r_offset -= 0x10000;
554     /*printf ("dj: pair offset is %08x\n", reloc_dst->r_offset);*/
555     reloc_dst->r_symndx = pair_prev.r_symndx;
556     break;
557   }
558 }
559
560 static unsigned int
561 mips_swap_reloc_out (abfd, src, dst)
562      bfd       *abfd;
563      PTR        src;
564      PTR        dst;
565 {
566   static int prev_offset = 1;
567   static bfd_vma prev_addr = 0;
568   struct internal_reloc *reloc_src = (struct internal_reloc *)src;
569   struct external_reloc *reloc_dst = (struct external_reloc *)dst;
570
571   switch (reloc_src->r_type)
572     {
573     case MIPS_R_REFHI:
574       prev_addr = reloc_src->r_vaddr;
575       prev_offset = reloc_src->r_offset;
576       break;
577     case MIPS_R_REFLO:
578       if (reloc_src->r_vaddr == prev_addr)
579         {
580           /* FIXME: only slightly hackish.  If we see a REFLO pointing to
581              the same address as a REFHI, we assume this is the matching
582              PAIR reloc and output it accordingly.  The symndx is really
583              the low 16 bits of the addend */
584           H_PUT_32 (abfd, reloc_src->r_vaddr, reloc_dst->r_vaddr);
585           H_PUT_32 (abfd, reloc_src->r_symndx, reloc_dst->r_symndx);
586           H_PUT_16 (abfd, MIPS_R_PAIR, reloc_dst->r_type);
587           return RELSZ;
588         }
589       break;
590     }
591
592   H_PUT_32 (abfd, reloc_src->r_vaddr, reloc_dst->r_vaddr);
593   H_PUT_32 (abfd, reloc_src->r_symndx, reloc_dst->r_symndx);
594
595   H_PUT_16 (abfd, reloc_src->r_type, reloc_dst->r_type);
596   return RELSZ;
597 }
598
599 #define coff_swap_reloc_in mips_swap_reloc_in
600 #define coff_swap_reloc_out mips_swap_reloc_out
601 #define NO_COFF_RELOCS
602
603 static bfd_boolean
604 coff_pe_mips_relocate_section (output_bfd, info, input_bfd,
605                                input_section, contents, relocs, syms,
606                                sections)
607      bfd *output_bfd;
608      struct bfd_link_info *info;
609      bfd *input_bfd;
610      asection *input_section;
611      bfd_byte *contents;
612      struct internal_reloc *relocs;
613      struct internal_syment *syms;
614      asection **sections;
615 {
616   bfd_vma gp;
617   bfd_boolean gp_undefined;
618   size_t adjust;
619   struct internal_reloc *rel;
620   struct internal_reloc *rel_end;
621   unsigned int i;
622   bfd_boolean got_lo;
623
624   if (info->relocatable)
625   {
626     (*_bfd_error_handler)
627       (_("%B: `ld -r' not supported with PE MIPS objects\n"), input_bfd);
628     bfd_set_error (bfd_error_bad_value);
629     return FALSE;
630   }
631
632   BFD_ASSERT (input_bfd->xvec->byteorder
633               == output_bfd->xvec->byteorder);
634
635   gp = _bfd_get_gp_value (output_bfd);
636   if (gp == 0)
637     gp_undefined = TRUE;
638   else
639     gp_undefined = FALSE;
640
641   got_lo = FALSE;
642
643   adjust = 0;
644
645   rel = relocs;
646   rel_end = rel + input_section->reloc_count;
647   for (i = 0; rel < rel_end; rel++, i++)
648     {
649       long symndx;
650       struct coff_link_hash_entry *h;
651       struct internal_syment *sym;
652       bfd_vma addend = 0;
653       bfd_vma val, tmp, targ, src, low;
654       reloc_howto_type *howto;
655       unsigned char *mem = contents + rel->r_vaddr;
656
657       symndx = rel->r_symndx;
658
659       if (symndx == -1)
660         {
661           h = NULL;
662           sym = NULL;
663         }
664       else
665         {
666           h = obj_coff_sym_hashes (input_bfd)[symndx];
667           sym = syms + symndx;
668         }
669
670       /* COFF treats common symbols in one of two ways.  Either the
671          size of the symbol is included in the section contents, or it
672          is not.  We assume that the size is not included, and force
673          the rtype_to_howto function to adjust the addend as needed.  */
674
675       if (sym != NULL && sym->n_scnum != 0)
676         addend = - sym->n_value;
677       else
678         addend = 0;
679
680       howto = bfd_coff_rtype_to_howto (input_bfd, input_section, rel, h,
681                                        sym, &addend);
682       if (howto == NULL)
683         return FALSE;
684
685       /* If we are doing a relocatable link, then we can just ignore
686          a PC relative reloc that is pcrel_offset.  It will already
687          have the correct value.  If this is not a relocatable link,
688          then we should ignore the symbol value.  */
689       if (howto->pc_relative && howto->pcrel_offset)
690         {
691           if (info->relocatable)
692             continue;
693           if (sym != NULL && sym->n_scnum != 0)
694             addend += sym->n_value;
695         }
696
697       val = 0;
698
699       if (h == NULL)
700         {
701           asection *sec;
702
703           if (symndx == -1)
704             {
705               sec = bfd_abs_section_ptr;
706               val = 0;
707             }
708           else
709             {
710               sec = sections[symndx];
711               val = (sec->output_section->vma
712                      + sec->output_offset
713                      + sym->n_value);
714               if (! obj_pe (input_bfd))
715                 val -= sec->vma;
716             }
717         }
718       else
719         {
720           if (h->root.type == bfd_link_hash_defined
721               || h->root.type == bfd_link_hash_defweak)
722             {
723               asection *sec;
724
725               sec = h->root.u.def.section;
726               val = (h->root.u.def.value
727                      + sec->output_section->vma
728                      + sec->output_offset);
729               }
730
731           else if (! info->relocatable)
732             {
733               if (! ((*info->callbacks->undefined_symbol)
734                      (info, h->root.root.string, input_bfd, input_section,
735                       rel->r_vaddr - input_section->vma, TRUE)))
736                 return FALSE;
737             }
738         }
739
740       src = rel->r_vaddr + input_section->output_section->vma
741         + input_section->output_offset;
742
743       /* OK, at this point the following variables are set up:
744            src = VMA of the memory we're fixing up
745            mem = pointer to memory we're fixing up
746            val = VMA of what we need to refer to
747       */
748
749 #define UI(x) (*_bfd_error_handler) (_("%B: unimplemented %s\n"), \
750                                      input_bfd, x); \
751               bfd_set_error (bfd_error_bad_value);
752
753       switch (rel->r_type)
754         {
755         case MIPS_R_ABSOLUTE:
756           /* ignore these */
757           break;
758
759         case MIPS_R_REFHALF:
760           UI("refhalf");
761           break;
762
763         case MIPS_R_REFWORD:
764           tmp = bfd_get_32(input_bfd, mem);
765           /* printf ("refword: src=%08x targ=%08x+%08x\n", src, tmp, val); */
766           tmp += val;
767           bfd_put_32(input_bfd, tmp, mem);
768           break;
769
770         case MIPS_R_JMPADDR:
771           tmp = bfd_get_32(input_bfd, mem);
772           targ = val + (tmp&0x03ffffff)*4;
773           if ((src & 0xf0000000) != (targ & 0xf0000000))
774             {
775               (*_bfd_error_handler) (_("%B: jump too far away\n"), input_bfd);
776               bfd_set_error (bfd_error_bad_value);
777               return FALSE;
778             }
779           tmp &= 0xfc000000;
780           tmp |= (targ/4) & 0x3ffffff;
781           bfd_put_32(input_bfd, tmp, mem);
782           break;
783
784         case MIPS_R_REFHI:
785           tmp = bfd_get_32(input_bfd, mem);
786           switch (rel[1].r_type)
787             {
788             case MIPS_R_PAIR:
789               /* MS PE object */
790               targ = val + rel[1].r_offset + ((tmp & 0xffff) << 16);
791               break;
792             case MIPS_R_REFLO:
793               /* GNU COFF object */
794               low = bfd_get_32(input_bfd, contents + rel[1].r_vaddr);
795               low &= 0xffff;
796               if (low & 0x8000)
797                 low -= 0x10000;
798               targ = val + low + ((tmp & 0xffff) << 16);
799               break;
800             default:
801               (*_bfd_error_handler) (_("%B: bad pair/reflo after refhi\n"),
802                                      input_bfd);
803               bfd_set_error (bfd_error_bad_value);
804               return FALSE;
805             }
806           tmp &= 0xffff0000;
807           tmp |= (targ >> 16) & 0xffff;
808           bfd_put_32(input_bfd, tmp, mem);
809           break;
810
811         case MIPS_R_REFLO:
812           tmp = bfd_get_32(input_bfd, mem);
813           targ = val + (tmp & 0xffff);
814           /* printf ("refword: src=%08x targ=%08x\n", src, targ); */
815           tmp &= 0xffff0000;
816           tmp |= targ & 0xffff;
817           bfd_put_32(input_bfd, tmp, mem);
818           break;
819
820         case MIPS_R_GPREL:
821         case MIPS_R_LITERAL:
822           UI("gprel");
823           break;
824
825         case MIPS_R_SECTION:
826           UI("section");
827           break;
828
829         case MIPS_R_SECREL:
830           UI("secrel");
831           break;
832
833         case MIPS_R_SECRELLO:
834           UI("secrello");
835           break;
836
837         case MIPS_R_SECRELHI:
838           UI("secrelhi");
839           break;
840
841         case MIPS_R_RVA:
842           tmp = bfd_get_32 (input_bfd, mem);
843           /* printf ("rva: src=%08x targ=%08x+%08x\n", src, tmp, val); */
844           tmp += val
845             - pe_data (input_section->output_section->owner)->pe_opthdr.ImageBase;
846           bfd_put_32 (input_bfd, tmp, mem);
847           break;
848
849         case MIPS_R_PAIR:
850           /* ignore these */
851           break;
852         }
853     }
854
855   return TRUE;
856 }
857
858 #define coff_relocate_section coff_pe_mips_relocate_section
859
860 #ifdef TARGET_UNDERSCORE
861
862 /* If mips gcc uses underscores for symbol names, then it does not use
863    a leading dot for local labels, so if TARGET_UNDERSCORE is defined
864    we treat all symbols starting with L as local.  */
865
866 static bfd_boolean coff_mips_is_local_label_name
867    PARAMS ((bfd *, const char *));
868
869 static bfd_boolean
870 coff_mips_is_local_label_name (abfd, name)
871      bfd *abfd;
872      const char *name;
873 {
874   if (name[0] == 'L')
875     return TRUE;
876
877   return _bfd_coff_is_local_label_name (abfd, name);
878 }
879
880 #define coff_bfd_is_local_label_name coff_mips_is_local_label_name
881
882 #endif /* TARGET_UNDERSCORE */
883
884 #define COFF_NO_HACK_SCNHDR_SIZE
885
886 #include "coffcode.h"
887
888 const bfd_target
889 #ifdef TARGET_SYM
890   TARGET_SYM =
891 #else
892   mipslpe_vec =
893 #endif
894 {
895 #ifdef TARGET_NAME
896   TARGET_NAME,
897 #else
898   "pe-mips",                    /* name */
899 #endif
900   bfd_target_coff_flavour,
901   BFD_ENDIAN_LITTLE,            /* data byte order is little */
902   BFD_ENDIAN_LITTLE,            /* header byte order is little */
903
904   (HAS_RELOC | EXEC_P |         /* object flags */
905    HAS_LINENO | HAS_DEBUG |
906    HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED),
907
908 #ifndef COFF_WITH_PE
909   (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC /* section flags */
910    | SEC_CODE | SEC_DATA),
911 #else
912   (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC /* section flags */
913    | SEC_CODE | SEC_DATA
914    | SEC_LINK_ONCE | SEC_LINK_DUPLICATES),
915 #endif
916
917 #ifdef TARGET_UNDERSCORE
918   TARGET_UNDERSCORE,            /* leading underscore */
919 #else
920   0,                            /* leading underscore */
921 #endif
922   '/',                          /* ar_pad_char */
923   15,                           /* ar_max_namelen */
924
925   bfd_getl64, bfd_getl_signed_64, bfd_putl64,
926      bfd_getl32, bfd_getl_signed_32, bfd_putl32,
927      bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* data */
928   bfd_getl64, bfd_getl_signed_64, bfd_putl64,
929      bfd_getl32, bfd_getl_signed_32, bfd_putl32,
930      bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* hdrs */
931
932 /* Note that we allow an object file to be treated as a core file as well.  */
933     {_bfd_dummy_target, coff_object_p, /* bfd_check_format */
934        bfd_generic_archive_p, coff_object_p},
935     {bfd_false, coff_mkobject, _bfd_generic_mkarchive, /* bfd_set_format */
936        bfd_false},
937     {bfd_false, coff_write_object_contents, /* bfd_write_contents */
938        _bfd_write_archive_contents, bfd_false},
939
940      BFD_JUMP_TABLE_GENERIC (coff),
941      BFD_JUMP_TABLE_COPY (coff),
942      BFD_JUMP_TABLE_CORE (_bfd_nocore),
943      BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff),
944      BFD_JUMP_TABLE_SYMBOLS (coff),
945      BFD_JUMP_TABLE_RELOCS (coff),
946      BFD_JUMP_TABLE_WRITE (coff),
947      BFD_JUMP_TABLE_LINK (coff),
948      BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
949
950   NULL,
951
952   COFF_SWAP_TABLE
953 };