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