projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
* elf-m10300.c (mn10300_elf_relax_section): Allow for the
[deliverable/binutils-gdb.git] / bfd / elf-m10300.c
CommitLineData
252b5132 1/* Matsushita 10300 specific support for 32-bit ELF
66eb6687 2 Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
ab96bf03 3 2006, 2007 Free Software Foundation, Inc.
252b5132 4
0112cd26 5 This file is part of BFD, the Binary File Descriptor library.
252b5132 6
0112cd26
NC		 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
cd123cb7 9 the Free Software Foundation; either version 3 of the License, or
0112cd26 10 (at your option) any later version.
252b5132 11
0112cd26
NC		 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.
252b5132 16
0112cd26
NC		 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
cd123cb7
NC		 19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20 MA 02110-1301, USA. */
252b5132 21
252b5132 22#include "sysdep.h"
3db64b00 23#include "bfd.h"
252b5132
RH		 24#include "libbfd.h"
25#include "elf-bfd.h"
26#include "elf/mn10300.h"
603b7257 27#include "libiberty.h"
917583ad 28
03a12831
AO		 29/* The mn10300 linker needs to keep track of the number of relocs that
30 it decides to copy in check_relocs for each symbol. This is so
31 that it can discard PC relative relocs if it doesn't need them when
32 linking with -Bsymbolic. We store the information in a field
33 extending the regular ELF linker hash table. */
34
603b7257
NC		 35struct elf32_mn10300_link_hash_entry
36{
252b5132
RH		 37 /* The basic elf link hash table entry. */
38 struct elf_link_hash_entry root;
39
40 /* For function symbols, the number of times this function is
41 called directly (ie by name). */
42 unsigned int direct_calls;
43
44 /* For function symbols, the size of this function's stack
45 (if <= 255 bytes). We stuff this into "call" instructions
46 to this target when it's valid and profitable to do so.
47
48 This does not include stack allocated by movm! */
49 unsigned char stack_size;
50
51 /* For function symbols, arguments (if any) for movm instruction
52 in the prologue. We stuff this value into "call" instructions
53 to the target when it's valid and profitable to do so. */
54 unsigned char movm_args;
55
4cc11e76 56 /* For function symbols, the amount of stack space that would be allocated
252b5132
RH		 57 by the movm instruction. This is redundant with movm_args, but we
58 add it to the hash table to avoid computing it over and over. */
59 unsigned char movm_stack_size;
60
61/* When set, convert all "call" instructions to this target into "calls"
62 instructions. */
63#define MN10300_CONVERT_CALL_TO_CALLS 0x1
64
65/* Used to mark functions which have had redundant parts of their
66 prologue deleted. */
67#define MN10300_DELETED_PROLOGUE_BYTES 0x2
68 unsigned char flags;
eb13e63f
DD		 69
70 /* Calculated value. */
71 bfd_vma value;
252b5132
RH		 72};
73
74/* We derive a hash table from the main elf linker hash table so
75 we can store state variables and a secondary hash table without
76 resorting to global variables. */
603b7257
NC		 77struct elf32_mn10300_link_hash_table
78{
252b5132
RH		 79 /* The main hash table. */
80 struct elf_link_hash_table root;
81
82 /* A hash table for static functions. We could derive a new hash table
83 instead of using the full elf32_mn10300_link_hash_table if we wanted
84 to save some memory. */
85 struct elf32_mn10300_link_hash_table *static_hash_table;
86
87 /* Random linker state flags. */
88#define MN10300_HASH_ENTRIES_INITIALIZED 0x1
89 char flags;
90};
91
603b7257
NC		 92#ifndef streq
93#define streq(a, b) (strcmp ((a),(b)) == 0)
94#endif
95
252b5132
RH		 96/* For MN10300 linker hash table. */
97
98/* Get the MN10300 ELF linker hash table from a link_info structure. */
99
100#define elf32_mn10300_hash_table(p) \
101 ((struct elf32_mn10300_link_hash_table *) ((p)->hash))
102
103#define elf32_mn10300_link_hash_traverse(table, func, info) \
104 (elf_link_hash_traverse \
105 (&(table)->root, \
603b7257 106 (bfd_boolean (*) (struct elf_link_hash_entry *, void *)) (func), \
252b5132
RH		 107 (info)))
108
603b7257
NC		 109static reloc_howto_type elf_mn10300_howto_table[] =
110{
252b5132
RH		 111 /* Dummy relocation. Does nothing. */
112 HOWTO (R_MN10300_NONE,
113 0,
114 2,
115 16,
b34976b6 116 FALSE,
252b5132
RH		 117 0,
118 complain_overflow_bitfield,
119 bfd_elf_generic_reloc,
120 "R_MN10300_NONE",
b34976b6 121 FALSE,
252b5132
RH		 122 0,
123 0,
b34976b6 124 FALSE),
252b5132
RH		 125 /* Standard 32 bit reloc. */
126 HOWTO (R_MN10300_32,
127 0,
128 2,
129 32,
b34976b6 130 FALSE,
252b5132
RH		 131 0,
132 complain_overflow_bitfield,
133 bfd_elf_generic_reloc,
134 "R_MN10300_32",
b34976b6 135 FALSE,
252b5132
RH		 136 0xffffffff,
137 0xffffffff,
b34976b6 138 FALSE),
252b5132
RH		 139 /* Standard 16 bit reloc. */
140 HOWTO (R_MN10300_16,
141 0,
142 1,
143 16,
b34976b6 144 FALSE,
252b5132
RH		 145 0,
146 complain_overflow_bitfield,
147 bfd_elf_generic_reloc,
148 "R_MN10300_16",
b34976b6 149 FALSE,
252b5132
RH		 150 0xffff,
151 0xffff,
b34976b6 152 FALSE),
252b5132
RH		 153 /* Standard 8 bit reloc. */
154 HOWTO (R_MN10300_8,
155 0,
156 0,
157 8,
b34976b6 158 FALSE,
252b5132
RH		 159 0,
160 complain_overflow_bitfield,
161 bfd_elf_generic_reloc,
162 "R_MN10300_8",
b34976b6 163 FALSE,
252b5132
RH		 164 0xff,
165 0xff,
b34976b6 166 FALSE),
252b5132
RH		 167 /* Standard 32bit pc-relative reloc. */
168 HOWTO (R_MN10300_PCREL32,
169 0,
170 2,
171 32,
b34976b6 172 TRUE,
252b5132
RH		 173 0,
174 complain_overflow_bitfield,
175 bfd_elf_generic_reloc,
176 "R_MN10300_PCREL32",
b34976b6 177 FALSE,
252b5132
RH		 178 0xffffffff,
179 0xffffffff,
b34976b6 180 TRUE),
252b5132
RH		 181 /* Standard 16bit pc-relative reloc. */
182 HOWTO (R_MN10300_PCREL16,
183 0,
184 1,
185 16,
b34976b6 186 TRUE,
252b5132
RH		 187 0,
188 complain_overflow_bitfield,
189 bfd_elf_generic_reloc,
190 "R_MN10300_PCREL16",
b34976b6 191 FALSE,
252b5132
RH		 192 0xffff,
193 0xffff,
b34976b6 194 TRUE),
252b5132
RH		 195 /* Standard 8 pc-relative reloc. */
196 HOWTO (R_MN10300_PCREL8,
197 0,
198 0,
199 8,
b34976b6 200 TRUE,
252b5132
RH		 201 0,
202 complain_overflow_bitfield,
203 bfd_elf_generic_reloc,
204 "R_MN10300_PCREL8",
b34976b6 205 FALSE,
252b5132
RH		 206 0xff,
207 0xff,
b34976b6 208 TRUE),
252b5132 209
603b7257 210 /* GNU extension to record C++ vtable hierarchy. */
252b5132
RH		 211 HOWTO (R_MN10300_GNU_VTINHERIT, /* type */
212 0, /* rightshift */
213 0, /* size (0 = byte, 1 = short, 2 = long) */
214 0, /* bitsize */
b34976b6 215 FALSE, /* pc_relative */
252b5132
RH		 216 0, /* bitpos */
217 complain_overflow_dont, /* complain_on_overflow */
218 NULL, /* special_function */
219 "R_MN10300_GNU_VTINHERIT", /* name */
b34976b6 220 FALSE, /* partial_inplace */
252b5132
RH		 221 0, /* src_mask */
222 0, /* dst_mask */
b34976b6 223 FALSE), /* pcrel_offset */
252b5132
RH		 224
225 /* GNU extension to record C++ vtable member usage */
226 HOWTO (R_MN10300_GNU_VTENTRY, /* type */
227 0, /* rightshift */
228 0, /* size (0 = byte, 1 = short, 2 = long) */
229 0, /* bitsize */
b34976b6 230 FALSE, /* pc_relative */
252b5132
RH		 231 0, /* bitpos */
232 complain_overflow_dont, /* complain_on_overflow */
233 NULL, /* special_function */
234 "R_MN10300_GNU_VTENTRY", /* name */
b34976b6 235 FALSE, /* partial_inplace */
252b5132
RH		 236 0, /* src_mask */
237 0, /* dst_mask */
b34976b6 238 FALSE), /* pcrel_offset */
252b5132
RH		 239
240 /* Standard 24 bit reloc. */
241 HOWTO (R_MN10300_24,
242 0,
243 2,
244 24,
b34976b6 245 FALSE,
252b5132
RH		 246 0,
247 complain_overflow_bitfield,
248 bfd_elf_generic_reloc,
249 "R_MN10300_24",
b34976b6 250 FALSE,
252b5132
RH		 251 0xffffff,
252 0xffffff,
b34976b6 253 FALSE),
03a12831
AO		 254 HOWTO (R_MN10300_GOTPC32, /* type */
255 0, /* rightshift */
256 2, /* size (0 = byte, 1 = short, 2 = long) */
257 32, /* bitsize */
258 TRUE, /* pc_relative */
259 0, /* bitpos */
260 complain_overflow_bitfield, /* complain_on_overflow */
261 bfd_elf_generic_reloc, /* */
262 "R_MN10300_GOTPC32", /* name */
263 FALSE, /* partial_inplace */
264 0xffffffff, /* src_mask */
265 0xffffffff, /* dst_mask */
266 TRUE), /* pcrel_offset */
267
268 HOWTO (R_MN10300_GOTPC16, /* type */
269 0, /* rightshift */
270 1, /* size (0 = byte, 1 = short, 2 = long) */
271 16, /* bitsize */
272 TRUE, /* pc_relative */
273 0, /* bitpos */
274 complain_overflow_bitfield, /* complain_on_overflow */
275 bfd_elf_generic_reloc, /* */
276 "R_MN10300_GOTPC16", /* name */
277 FALSE, /* partial_inplace */
278 0xffff, /* src_mask */
279 0xffff, /* dst_mask */
280 TRUE), /* pcrel_offset */
281
282 HOWTO (R_MN10300_GOTOFF32, /* type */
283 0, /* rightshift */
284 2, /* size (0 = byte, 1 = short, 2 = long) */
285 32, /* bitsize */
286 FALSE, /* pc_relative */
287 0, /* bitpos */
288 complain_overflow_bitfield, /* complain_on_overflow */
289 bfd_elf_generic_reloc, /* */
290 "R_MN10300_GOTOFF32", /* name */
291 FALSE, /* partial_inplace */
292 0xffffffff, /* src_mask */
293 0xffffffff, /* dst_mask */
294 FALSE), /* pcrel_offset */
295
296 HOWTO (R_MN10300_GOTOFF24, /* type */
297 0, /* rightshift */
298 2, /* size (0 = byte, 1 = short, 2 = long) */
299 24, /* bitsize */
300 FALSE, /* pc_relative */
301 0, /* bitpos */
302 complain_overflow_bitfield, /* complain_on_overflow */
303 bfd_elf_generic_reloc, /* */
304 "R_MN10300_GOTOFF24", /* name */
305 FALSE, /* partial_inplace */
306 0xffffff, /* src_mask */
307 0xffffff, /* dst_mask */
308 FALSE), /* pcrel_offset */
309
310 HOWTO (R_MN10300_GOTOFF16, /* type */
311 0, /* rightshift */
312 1, /* size (0 = byte, 1 = short, 2 = long) */
313 16, /* bitsize */
314 FALSE, /* pc_relative */
315 0, /* bitpos */
316 complain_overflow_bitfield, /* complain_on_overflow */
317 bfd_elf_generic_reloc, /* */
318 "R_MN10300_GOTOFF16", /* name */
319 FALSE, /* partial_inplace */
320 0xffff, /* src_mask */
321 0xffff, /* dst_mask */
322 FALSE), /* pcrel_offset */
323
324 HOWTO (R_MN10300_PLT32, /* type */
325 0, /* rightshift */
326 2, /* size (0 = byte, 1 = short, 2 = long) */
327 32, /* bitsize */
328 TRUE, /* pc_relative */
329 0, /* bitpos */
330 complain_overflow_bitfield, /* complain_on_overflow */
331 bfd_elf_generic_reloc, /* */
332 "R_MN10300_PLT32", /* name */
333 FALSE, /* partial_inplace */
334 0xffffffff, /* src_mask */
335 0xffffffff, /* dst_mask */
336 TRUE), /* pcrel_offset */
337
338 HOWTO (R_MN10300_PLT16, /* type */
339 0, /* rightshift */
340 1, /* size (0 = byte, 1 = short, 2 = long) */
341 16, /* bitsize */
342 TRUE, /* pc_relative */
343 0, /* bitpos */
344 complain_overflow_bitfield, /* complain_on_overflow */
345 bfd_elf_generic_reloc, /* */
346 "R_MN10300_PLT16", /* name */
347 FALSE, /* partial_inplace */
348 0xffff, /* src_mask */
349 0xffff, /* dst_mask */
350 TRUE), /* pcrel_offset */
351
352 HOWTO (R_MN10300_GOT32, /* type */
353 0, /* rightshift */
354 2, /* size (0 = byte, 1 = short, 2 = long) */
355 32, /* bitsize */
356 FALSE, /* pc_relative */
357 0, /* bitpos */
358 complain_overflow_bitfield, /* complain_on_overflow */
359 bfd_elf_generic_reloc, /* */
360 "R_MN10300_GOT32", /* name */
361 FALSE, /* partial_inplace */
362 0xffffffff, /* src_mask */
363 0xffffffff, /* dst_mask */
364 FALSE), /* pcrel_offset */
365
366 HOWTO (R_MN10300_GOT24, /* type */
367 0, /* rightshift */
368 2, /* size (0 = byte, 1 = short, 2 = long) */
369 24, /* bitsize */
370 FALSE, /* pc_relative */
371 0, /* bitpos */
372 complain_overflow_bitfield, /* complain_on_overflow */
373 bfd_elf_generic_reloc, /* */
374 "R_MN10300_GOT24", /* name */
375 FALSE, /* partial_inplace */
376 0xffffffff, /* src_mask */
377 0xffffffff, /* dst_mask */
378 FALSE), /* pcrel_offset */
379
380 HOWTO (R_MN10300_GOT16, /* type */
381 0, /* rightshift */
382 1, /* size (0 = byte, 1 = short, 2 = long) */
383 16, /* bitsize */
384 FALSE, /* pc_relative */
385 0, /* bitpos */
386 complain_overflow_bitfield, /* complain_on_overflow */
387 bfd_elf_generic_reloc, /* */
388 "R_MN10300_GOT16", /* name */
389 FALSE, /* partial_inplace */
390 0xffffffff, /* src_mask */
391 0xffffffff, /* dst_mask */
392 FALSE), /* pcrel_offset */
393
394 HOWTO (R_MN10300_COPY, /* type */
395 0, /* rightshift */
396 2, /* size (0 = byte, 1 = short, 2 = long) */
397 32, /* bitsize */
398 FALSE, /* pc_relative */
399 0, /* bitpos */
400 complain_overflow_bitfield, /* complain_on_overflow */
401 bfd_elf_generic_reloc, /* */
402 "R_MN10300_COPY", /* name */
403 FALSE, /* partial_inplace */
404 0xffffffff, /* src_mask */
405 0xffffffff, /* dst_mask */
406 FALSE), /* pcrel_offset */
407
408 HOWTO (R_MN10300_GLOB_DAT, /* type */
409 0, /* rightshift */
410 2, /* size (0 = byte, 1 = short, 2 = long) */
411 32, /* bitsize */
412 FALSE, /* pc_relative */
413 0, /* bitpos */
414 complain_overflow_bitfield, /* complain_on_overflow */
415 bfd_elf_generic_reloc, /* */
416 "R_MN10300_GLOB_DAT", /* name */
417 FALSE, /* partial_inplace */
418 0xffffffff, /* src_mask */
419 0xffffffff, /* dst_mask */
420 FALSE), /* pcrel_offset */
421
422 HOWTO (R_MN10300_JMP_SLOT, /* type */
423 0, /* rightshift */
424 2, /* size (0 = byte, 1 = short, 2 = long) */
425 32, /* bitsize */
426 FALSE, /* pc_relative */
427 0, /* bitpos */
428 complain_overflow_bitfield, /* complain_on_overflow */
429 bfd_elf_generic_reloc, /* */
430 "R_MN10300_JMP_SLOT", /* name */
431 FALSE, /* partial_inplace */
432 0xffffffff, /* src_mask */
433 0xffffffff, /* dst_mask */
434 FALSE), /* pcrel_offset */
435
436 HOWTO (R_MN10300_RELATIVE, /* type */
437 0, /* rightshift */
438 2, /* size (0 = byte, 1 = short, 2 = long) */
439 32, /* bitsize */
440 FALSE, /* pc_relative */
441 0, /* bitpos */
442 complain_overflow_bitfield, /* complain_on_overflow */
443 bfd_elf_generic_reloc, /* */
444 "R_MN10300_RELATIVE", /* name */
445 FALSE, /* partial_inplace */
446 0xffffffff, /* src_mask */
447 0xffffffff, /* dst_mask */
448 FALSE), /* pcrel_offset */
bfff1642
NC		 449
450 EMPTY_HOWTO (24),
451 EMPTY_HOWTO (25),
452 EMPTY_HOWTO (26),
453 EMPTY_HOWTO (27),
454 EMPTY_HOWTO (28),
455 EMPTY_HOWTO (29),
456 EMPTY_HOWTO (30),
457 EMPTY_HOWTO (31),
458 EMPTY_HOWTO (32),
459
460 HOWTO (R_MN10300_SYM_DIFF, /* type */
461 0, /* rightshift */
462 2, /* size (0 = byte, 1 = short, 2 = long) */
463 32, /* bitsize */
464 FALSE, /* pc_relative */
465 0, /* bitpos */
466 complain_overflow_dont,/* complain_on_overflow */
467 NULL, /* special handler. */
468 "R_MN10300_SYM_DIFF", /* name */
469 FALSE, /* partial_inplace */
470 0xffffffff, /* src_mask */
471 0xffffffff, /* dst_mask */
569006e5
NC		 472 FALSE), /* pcrel_offset */
473
474 HOWTO (R_MN10300_ALIGN, /* type */
475 0, /* rightshift */
476 0, /* size (0 = byte, 1 = short, 2 = long) */
477 32, /* bitsize */
478 FALSE, /* pc_relative */
479 0, /* bitpos */
480 complain_overflow_dont,/* complain_on_overflow */
481 NULL, /* special handler. */
482 "R_MN10300_ALIGN", /* name */
483 FALSE, /* partial_inplace */
484 0, /* src_mask */
485 0, /* dst_mask */
bfff1642 486 FALSE) /* pcrel_offset */
252b5132
RH		 487};
488
603b7257
NC		 489struct mn10300_reloc_map
490{
252b5132
RH		 491 bfd_reloc_code_real_type bfd_reloc_val;
492 unsigned char elf_reloc_val;
493};
494
603b7257
NC		 495static const struct mn10300_reloc_map mn10300_reloc_map[] =
496{
252b5132
RH		 497 { BFD_RELOC_NONE, R_MN10300_NONE, },
498 { BFD_RELOC_32, R_MN10300_32, },
499 { BFD_RELOC_16, R_MN10300_16, },
500 { BFD_RELOC_8, R_MN10300_8, },
501 { BFD_RELOC_32_PCREL, R_MN10300_PCREL32, },
502 { BFD_RELOC_16_PCREL, R_MN10300_PCREL16, },
503 { BFD_RELOC_8_PCREL, R_MN10300_PCREL8, },
504 { BFD_RELOC_24, R_MN10300_24, },
505 { BFD_RELOC_VTABLE_INHERIT, R_MN10300_GNU_VTINHERIT },
506 { BFD_RELOC_VTABLE_ENTRY, R_MN10300_GNU_VTENTRY },
03a12831
AO		 507 { BFD_RELOC_32_GOT_PCREL, R_MN10300_GOTPC32 },
508 { BFD_RELOC_16_GOT_PCREL, R_MN10300_GOTPC16 },
509 { BFD_RELOC_32_GOTOFF, R_MN10300_GOTOFF32 },
510 { BFD_RELOC_MN10300_GOTOFF24, R_MN10300_GOTOFF24 },
511 { BFD_RELOC_16_GOTOFF, R_MN10300_GOTOFF16 },
512 { BFD_RELOC_32_PLT_PCREL, R_MN10300_PLT32 },
513 { BFD_RELOC_16_PLT_PCREL, R_MN10300_PLT16 },
514 { BFD_RELOC_MN10300_GOT32, R_MN10300_GOT32 },
515 { BFD_RELOC_MN10300_GOT24, R_MN10300_GOT24 },
516 { BFD_RELOC_MN10300_GOT16, R_MN10300_GOT16 },
517 { BFD_RELOC_MN10300_COPY, R_MN10300_COPY },
518 { BFD_RELOC_MN10300_GLOB_DAT, R_MN10300_GLOB_DAT },
519 { BFD_RELOC_MN10300_JMP_SLOT, R_MN10300_JMP_SLOT },
520 { BFD_RELOC_MN10300_RELATIVE, R_MN10300_RELATIVE },
569006e5
NC		 521 { BFD_RELOC_MN10300_SYM_DIFF, R_MN10300_SYM_DIFF },
522 { BFD_RELOC_MN10300_ALIGN, R_MN10300_ALIGN }
252b5132
RH		 523};
524
03a12831
AO		 525/* Create the GOT section. */
526
527static bfd_boolean
603b7257
NC		 528_bfd_mn10300_elf_create_got_section (bfd * abfd,
529 struct bfd_link_info * info)
03a12831
AO		 530{
531 flagword flags;
532 flagword pltflags;
533 asection * s;
534 struct elf_link_hash_entry * h;
9c5bfbb7 535 const struct elf_backend_data * bed = get_elf_backend_data (abfd);
03a12831
AO		 536 int ptralign;
537
538 /* This function may be called more than once. */
539 if (bfd_get_section_by_name (abfd, ".got") != NULL)
540 return TRUE;
541
542 switch (bed->s->arch_size)
543 {
544 case 32:
545 ptralign = 2;
546 break;
547
548 case 64:
549 ptralign = 3;
550 break;
551
552 default:
553 bfd_set_error (bfd_error_bad_value);
554 return FALSE;
555 }
556
557 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
558 | SEC_LINKER_CREATED);
559
560 pltflags = flags;
561 pltflags |= SEC_CODE;
562 if (bed->plt_not_loaded)
563 pltflags &= ~ (SEC_LOAD | SEC_HAS_CONTENTS);
564 if (bed->plt_readonly)
565 pltflags |= SEC_READONLY;
566
3496cb2a 567 s = bfd_make_section_with_flags (abfd, ".plt", pltflags);
03a12831 568 if (s == NULL
03a12831
AO		 569 || ! bfd_set_section_alignment (abfd, s, bed->plt_alignment))
570 return FALSE;
571
d98685ac
AM		 572 /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
573 .plt section. */
7325306f
RS		 574 if (bed->want_plt_sym)
575 {
576 h = _bfd_elf_define_linkage_sym (abfd, info, s,
577 "_PROCEDURE_LINKAGE_TABLE_");
578 elf_hash_table (info)->hplt = h;
579 if (h == NULL)
580 return FALSE;
581 }
03a12831 582
3496cb2a 583 s = bfd_make_section_with_flags (abfd, ".got", flags);
03a12831 584 if (s == NULL
03a12831
AO		 585 || ! bfd_set_section_alignment (abfd, s, ptralign))
586 return FALSE;
587
588 if (bed->want_got_plt)
589 {
3496cb2a 590 s = bfd_make_section_with_flags (abfd, ".got.plt", flags);
03a12831 591 if (s == NULL
03a12831
AO		 592 || ! bfd_set_section_alignment (abfd, s, ptralign))
593 return FALSE;
594 }
595
596 /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the .got
597 (or .got.plt) section. We don't do this in the linker script
598 because we don't want to define the symbol if we are not creating
599 a global offset table. */
d98685ac 600 h = _bfd_elf_define_linkage_sym (abfd, info, s, "_GLOBAL_OFFSET_TABLE_");
03a12831 601 elf_hash_table (info)->hgot = h;
d98685ac
AM		 602 if (h == NULL)
603 return FALSE;
03a12831
AO		 604
605 /* The first bit of the global offset table is the header. */
3b36f7e6 606 s->size += bed->got_header_size;
03a12831
AO		 607
608 return TRUE;
609}
610
252b5132 611static reloc_howto_type *
603b7257
NC		 612bfd_elf32_bfd_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
613 bfd_reloc_code_real_type code)
252b5132
RH		 614{
615 unsigned int i;
616
603b7257
NC		 617 for (i = ARRAY_SIZE (mn10300_reloc_map); i--;)
618 if (mn10300_reloc_map[i].bfd_reloc_val == code)
619 return &elf_mn10300_howto_table[mn10300_reloc_map[i].elf_reloc_val];
252b5132
RH		 620
621 return NULL;
622}
623
157090f7
AM		 624static reloc_howto_type *
625bfd_elf32_bfd_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
626 const char *r_name)
627{
628 unsigned int i;
629
603b7257 630 for (i = ARRAY_SIZE (elf_mn10300_howto_table); i--;)
157090f7
AM		 631 if (elf_mn10300_howto_table[i].name != NULL
632 && strcasecmp (elf_mn10300_howto_table[i].name, r_name) == 0)
603b7257 633 return elf_mn10300_howto_table + i;
157090f7
AM		 634
635 return NULL;
636}
637
252b5132
RH		 638/* Set the howto pointer for an MN10300 ELF reloc. */
639
640static void
603b7257
NC		 641mn10300_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED,
642 arelent *cache_ptr,
643 Elf_Internal_Rela *dst)
252b5132
RH		 644{
645 unsigned int r_type;
646
647 r_type = ELF32_R_TYPE (dst->r_info);
648 BFD_ASSERT (r_type < (unsigned int) R_MN10300_MAX);
603b7257 649 cache_ptr->howto = elf_mn10300_howto_table + r_type;
252b5132
RH		 650}
651
652/* Look through the relocs for a section during the first phase.
653 Since we don't do .gots or .plts, we just need to consider the
654 virtual table relocs for gc. */
655
b34976b6 656static bfd_boolean
603b7257
NC		 657mn10300_elf_check_relocs (bfd *abfd,
658 struct bfd_link_info *info,
659 asection *sec,
660 const Elf_Internal_Rela *relocs)
252b5132 661{
bfff1642 662 bfd_boolean sym_diff_reloc_seen;
252b5132 663 Elf_Internal_Shdr *symtab_hdr;
62d7f790 664 Elf_Internal_Sym * isymbuf = NULL;
5582a088 665 struct elf_link_hash_entry **sym_hashes;
252b5132
RH		 666 const Elf_Internal_Rela *rel;
667 const Elf_Internal_Rela *rel_end;
03a12831
AO		 668 bfd * dynobj;
669 bfd_vma * local_got_offsets;
670 asection * sgot;
671 asection * srelgot;
672 asection * sreloc;
62d7f790 673 bfd_boolean result = FALSE;
03a12831
AO		 674
675 sgot = NULL;
676 srelgot = NULL;
677 sreloc = NULL;
252b5132 678
1049f94e 679 if (info->relocatable)
b34976b6 680 return TRUE;
252b5132
RH		 681
682 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
62d7f790 683 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
252b5132 684 sym_hashes = elf_sym_hashes (abfd);
252b5132 685
03a12831
AO		 686 dynobj = elf_hash_table (info)->dynobj;
687 local_got_offsets = elf_local_got_offsets (abfd);
252b5132 688 rel_end = relocs + sec->reloc_count;
bfff1642 689 sym_diff_reloc_seen = FALSE;
603b7257 690
252b5132
RH		 691 for (rel = relocs; rel < rel_end; rel++)
692 {
693 struct elf_link_hash_entry *h;
694 unsigned long r_symndx;
62d7f790 695 unsigned int r_type;
252b5132
RH		 696
697 r_symndx = ELF32_R_SYM (rel->r_info);
698 if (r_symndx < symtab_hdr->sh_info)
699 h = NULL;
700 else
973a3492
L		 701 {
702 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
703 while (h->root.type == bfd_link_hash_indirect
704 || h->root.type == bfd_link_hash_warning)
705 h = (struct elf_link_hash_entry *) h->root.u.i.link;
706 }
252b5132 707
62d7f790
NC		 708 r_type = ELF32_R_TYPE (rel->r_info);
709
03a12831
AO		 710 /* Some relocs require a global offset table. */
711 if (dynobj == NULL)
712 {
62d7f790 713 switch (r_type)
03a12831
AO		 714 {
715 case R_MN10300_GOT32:
716 case R_MN10300_GOT24:
717 case R_MN10300_GOT16:
718 case R_MN10300_GOTOFF32:
719 case R_MN10300_GOTOFF24:
720 case R_MN10300_GOTOFF16:
721 case R_MN10300_GOTPC32:
722 case R_MN10300_GOTPC16:
723 elf_hash_table (info)->dynobj = dynobj = abfd;
724 if (! _bfd_mn10300_elf_create_got_section (dynobj, info))
62d7f790 725 goto fail;
03a12831
AO		 726 break;
727
728 default:
729 break;
730 }
731 }
732
62d7f790 733 switch (r_type)
252b5132
RH		 734 {
735 /* This relocation describes the C++ object vtable hierarchy.
736 Reconstruct it for later use during GC. */
737 case R_MN10300_GNU_VTINHERIT:
c152c796 738 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
62d7f790 739 goto fail;
252b5132
RH		 740 break;
741
742 /* This relocation describes which C++ vtable entries are actually
743 used. Record for later use during GC. */
744 case R_MN10300_GNU_VTENTRY:
d17e0c6e
JB		 745 BFD_ASSERT (h != NULL);
746 if (h != NULL
747 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
62d7f790 748 goto fail;
252b5132 749 break;
62d7f790 750
03a12831
AO		 751 case R_MN10300_GOT32:
752 case R_MN10300_GOT24:
753 case R_MN10300_GOT16:
754 /* This symbol requires a global offset table entry. */
755
756 if (sgot == NULL)
757 {
758 sgot = bfd_get_section_by_name (dynobj, ".got");
759 BFD_ASSERT (sgot != NULL);
760 }
761
762 if (srelgot == NULL
763 && (h != NULL || info->shared))
764 {
765 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
766 if (srelgot == NULL)
767 {
3496cb2a
L		 768 srelgot = bfd_make_section_with_flags (dynobj,
769 ".rela.got",
770 (SEC_ALLOC
771 | SEC_LOAD
772 | SEC_HAS_CONTENTS
773 | SEC_IN_MEMORY
774 | SEC_LINKER_CREATED
775 | SEC_READONLY));
03a12831 776 if (srelgot == NULL
03a12831 777 || ! bfd_set_section_alignment (dynobj, srelgot, 2))
62d7f790 778 goto fail;
03a12831
AO		 779 }
780 }
781
782 if (h != NULL)
783 {
784 if (h->got.offset != (bfd_vma) -1)
785 /* We have already allocated space in the .got. */
786 break;
787
eea6121a 788 h->got.offset = sgot->size;
03a12831
AO		 789
790 /* Make sure this symbol is output as a dynamic symbol. */
791 if (h->dynindx == -1)
792 {
c152c796 793 if (! bfd_elf_link_record_dynamic_symbol (info, h))
62d7f790 794 goto fail;
03a12831
AO		 795 }
796
eea6121a 797 srelgot->size += sizeof (Elf32_External_Rela);
03a12831
AO		 798 }
799 else
800 {
801 /* This is a global offset table entry for a local
3b36f7e6 802 symbol. */
03a12831
AO		 803 if (local_got_offsets == NULL)
804 {
805 size_t size;
806 unsigned int i;
807
808 size = symtab_hdr->sh_info * sizeof (bfd_vma);
603b7257 809 local_got_offsets = bfd_alloc (abfd, size);
03a12831
AO		 810
811 if (local_got_offsets == NULL)
62d7f790
NC		 812 goto fail;
813
03a12831
AO		 814 elf_local_got_offsets (abfd) = local_got_offsets;
815
816 for (i = 0; i < symtab_hdr->sh_info; i++)
817 local_got_offsets[i] = (bfd_vma) -1;
818 }
819
820 if (local_got_offsets[r_symndx] != (bfd_vma) -1)
821 /* We have already allocated space in the .got. */
822 break;
823
eea6121a 824 local_got_offsets[r_symndx] = sgot->size;
03a12831
AO		 825
826 if (info->shared)
827 /* If we are generating a shared object, we need to
828 output a R_MN10300_RELATIVE reloc so that the dynamic
829 linker can adjust this GOT entry. */
eea6121a 830 srelgot->size += sizeof (Elf32_External_Rela);
03a12831
AO		 831 }
832
eea6121a 833 sgot->size += 4;
03a12831
AO		 834 break;
835
836 case R_MN10300_PLT32:
837 case R_MN10300_PLT16:
838 /* This symbol requires a procedure linkage table entry. We
839 actually build the entry in adjust_dynamic_symbol,
840 because this might be a case of linking PIC code which is
841 never referenced by a dynamic object, in which case we
842 don't need to generate a procedure linkage table entry
843 after all. */
844
845 /* If this is a local symbol, we resolve it directly without
846 creating a procedure linkage table entry. */
847 if (h == NULL)
848 continue;
849
850 if (ELF_ST_VISIBILITY (h->other) == STV_INTERNAL
851 || ELF_ST_VISIBILITY (h->other) == STV_HIDDEN)
852 break;
853
f5385ebf 854 h->needs_plt = 1;
03a12831
AO		 855 break;
856
03a12831
AO		 857 case R_MN10300_24:
858 case R_MN10300_16:
859 case R_MN10300_8:
860 case R_MN10300_PCREL32:
861 case R_MN10300_PCREL16:
862 case R_MN10300_PCREL8:
863 if (h != NULL)
f5385ebf 864 h->non_got_ref = 1;
146ccdbb 865 break;
03a12831 866
bfff1642
NC		 867 case R_MN10300_SYM_DIFF:
868 sym_diff_reloc_seen = TRUE;
869 break;
870
146ccdbb
AO		 871 case R_MN10300_32:
872 if (h != NULL)
f5385ebf 873 h->non_got_ref = 1;
146ccdbb 874
bfff1642
NC		 875 /* If we are creating a shared library, then we
876 need to copy the reloc into the shared library. */
03a12831 877 if (info->shared
bfff1642
NC		 878 && (sec->flags & SEC_ALLOC) != 0
879 /* Do not generate a dynamic reloc for a
880 reloc associated with a SYM_DIFF operation. */
881 && ! sym_diff_reloc_seen)
03a12831 882 {
bfff1642 883 asection * sym_section = NULL;
03a12831 884
bfff1642
NC		 885 /* Find the section containing the
886 symbol involved in the relocation. */
887 if (h == NULL)
888 {
bfff1642
NC		 889 Elf_Internal_Sym * isym;
890
bfff1642
NC		 891 if (isymbuf == NULL)
892 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
893 symtab_hdr->sh_info, 0,
894 NULL, NULL, NULL);
895 if (isymbuf)
896 {
897 isym = isymbuf + r_symndx;
898 /* All we care about is whether this local symbol is absolute. */
899 if (isym->st_shndx == SHN_ABS)
900 sym_section = bfd_abs_section_ptr;
901 }
902 }
903 else
904 {
905 if (h->root.type == bfd_link_hash_defined
906 || h->root.type == bfd_link_hash_defweak)
907 sym_section = h->root.u.def.section;
908 }
03a12831 909
bfff1642
NC		 910 /* If the symbol is absolute then the relocation can
911 be resolved during linking and there is no need for
912 a dynamic reloc. */
913 if (sym_section != bfd_abs_section_ptr)
914 {
915 /* When creating a shared object, we must copy these
916 reloc types into the output file. We create a reloc
917 section in dynobj and make room for this reloc. */
03a12831
AO		 918 if (sreloc == NULL)
919 {
83bac4b0
NC		 920 sreloc = _bfd_elf_make_dynamic_reloc_section
921 (sec, dynobj, 2, abfd, /*rela?*/ TRUE);
bfff1642 922 if (sreloc == NULL)
83bac4b0 923 goto fail;
03a12831 924 }
03a12831 925
bfff1642
NC		 926 sreloc->size += sizeof (Elf32_External_Rela);
927 }
03a12831
AO		 928 }
929
930 break;
252b5132 931 }
bfff1642
NC		 932
933 if (ELF32_R_TYPE (rel->r_info) != R_MN10300_SYM_DIFF)
934 sym_diff_reloc_seen = FALSE;
252b5132
RH		 935 }
936
62d7f790
NC		 937 result = TRUE;
938 fail:
939 if (isymbuf != NULL)
940 free (isymbuf);
941
942 return result;
252b5132
RH		 943}
944
945/* Return the section that should be marked against GC for a given
946 relocation. */
947
948static asection *
07adf181
AM		 949mn10300_elf_gc_mark_hook (asection *sec,
950 struct bfd_link_info *info,
951 Elf_Internal_Rela *rel,
952 struct elf_link_hash_entry *h,
953 Elf_Internal_Sym *sym)
252b5132
RH		 954{
955 if (h != NULL)
07adf181
AM		 956 switch (ELF32_R_TYPE (rel->r_info))
957 {
958 case R_MN10300_GNU_VTINHERIT:
959 case R_MN10300_GNU_VTENTRY:
960 return NULL;
961 }
962
963 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
252b5132
RH		 964}
965
966/* Perform a relocation as part of a final link. */
603b7257 967
252b5132 968static bfd_reloc_status_type
603b7257
NC		 969mn10300_elf_final_link_relocate (reloc_howto_type *howto,
970 bfd *input_bfd,
971 bfd *output_bfd ATTRIBUTE_UNUSED,
972 asection *input_section,
973 bfd_byte *contents,
974 bfd_vma offset,
975 bfd_vma value,
976 bfd_vma addend,
977 struct elf_link_hash_entry * h,
978 unsigned long symndx,
979 struct bfd_link_info *info,
980 asection *sym_sec ATTRIBUTE_UNUSED,
981 int is_local ATTRIBUTE_UNUSED)
252b5132 982{
bfff1642
NC		 983 static asection * sym_diff_section;
984 static bfd_vma sym_diff_value;
985 bfd_boolean is_sym_diff_reloc;
252b5132 986 unsigned long r_type = howto->type;
603b7257 987 bfd_byte * hit_data = contents + offset;
03a12831
AO		 988 bfd * dynobj;
989 bfd_vma * local_got_offsets;
990 asection * sgot;
991 asection * splt;
992 asection * sreloc;
993
994 dynobj = elf_hash_table (info)->dynobj;
995 local_got_offsets = elf_local_got_offsets (input_bfd);
996
997 sgot = NULL;
998 splt = NULL;
999 sreloc = NULL;
252b5132 1000
146ccdbb
AO		 1001 switch (r_type)
1002 {
1003 case R_MN10300_24:
1004 case R_MN10300_16:
1005 case R_MN10300_8:
1006 case R_MN10300_PCREL8:
1007 case R_MN10300_PCREL16:
1008 case R_MN10300_PCREL32:
1009 case R_MN10300_GOTOFF32:
1010 case R_MN10300_GOTOFF24:
1011 case R_MN10300_GOTOFF16:
1012 if (info->shared
1013 && (input_section->flags & SEC_ALLOC) != 0
1014 && h != NULL
7e2294f9 1015 && ! SYMBOL_REFERENCES_LOCAL (info, h))
146ccdbb
AO		 1016 return bfd_reloc_dangerous;
1017 }
1018
bfff1642
NC		 1019 is_sym_diff_reloc = FALSE;
1020 if (sym_diff_section != NULL)
1021 {
1022 BFD_ASSERT (sym_diff_section == input_section);
1023
1024 switch (r_type)
1025 {
1026 case R_MN10300_32:
1027 case R_MN10300_24:
1028 case R_MN10300_16:
1029 case R_MN10300_8:
1030 value -= sym_diff_value;
b5f5fd96
NC		 1031 /* If we are computing a 32-bit value for the location lists
1032 and the result is 0 then we add one to the value. A zero
1033 value can result because of linker relaxation deleteing
1034 prologue instructions and using a value of 1 (for the begin
1035 and end offsets in the location list entry) results in a
1036 nul entry which does not prevent the following entries from
1037 being parsed. */
1038 if (r_type == R_MN10300_32
1039 && value == 0
1040 && strcmp (input_section->name, ".debug_loc") == 0)
1041 value = 1;
bfff1642
NC		 1042 sym_diff_section = NULL;
1043 is_sym_diff_reloc = TRUE;
1044 break;
1045
1046 default:
1047 sym_diff_section = NULL;
1048 break;
1049 }
1050 }
1051
252b5132
RH		 1052 switch (r_type)
1053 {
bfff1642
NC		 1054 case R_MN10300_SYM_DIFF:
1055 BFD_ASSERT (addend == 0);
1056 /* Cache the input section and value.
1057 The offset is unreliable, since relaxation may
1058 have reduced the following reloc's offset. */
1059 sym_diff_section = input_section;
1060 sym_diff_value = value;
1061 return bfd_reloc_ok;
1062
569006e5 1063 case R_MN10300_ALIGN:
252b5132
RH		 1064 case R_MN10300_NONE:
1065 return bfd_reloc_ok;
1066
1067 case R_MN10300_32:
03a12831 1068 if (info->shared
bfff1642
NC		 1069 /* Do not generate relocs when an R_MN10300_32 has been used
1070 with an R_MN10300_SYM_DIFF to compute a difference of two
1071 symbols. */
1072 && is_sym_diff_reloc == FALSE
1073 /* Also, do not generate a reloc when the symbol associated
1074 with the R_MN10300_32 reloc is absolute - there is no
1075 need for a run time computation in this case. */
1076 && sym_sec != bfd_abs_section_ptr
1077 /* If the section is not going to be allocated at load time
1078 then there is no need to generate relocs for it. */
03a12831
AO		 1079 && (input_section->flags & SEC_ALLOC) != 0)
1080 {
1081 Elf_Internal_Rela outrel;
1082 bfd_boolean skip, relocate;
1083
1084 /* When generating a shared object, these relocations are
1085 copied into the output file to be resolved at run
1086 time. */
1087 if (sreloc == NULL)
1088 {
83bac4b0
NC		 1089 sreloc = _bfd_elf_get_dynamic_reloc_section
1090 (input_bfd, input_section, /*rela?*/ TRUE);
1091 if (sreloc == NULL)
03a12831 1092 return FALSE;
03a12831
AO		 1093 }
1094
1095 skip = FALSE;
1096
eea6121a
AM		 1097 outrel.r_offset = _bfd_elf_section_offset (input_bfd, info,
1098 input_section, offset);
1099 if (outrel.r_offset == (bfd_vma) -1)
1100 skip = TRUE;
03a12831
AO		 1101
1102 outrel.r_offset += (input_section->output_section->vma
1103 + input_section->output_offset);
1104
1105 if (skip)
1106 {
1107 memset (&outrel, 0, sizeof outrel);
1108 relocate = FALSE;
1109 }
1110 else
1111 {
1112 /* h->dynindx may be -1 if this symbol was marked to
1113 become local. */
1114 if (h == NULL
7e2294f9 1115 || SYMBOL_REFERENCES_LOCAL (info, h))
03a12831
AO		 1116 {
1117 relocate = TRUE;
1118 outrel.r_info = ELF32_R_INFO (0, R_MN10300_RELATIVE);
1119 outrel.r_addend = value + addend;
1120 }
1121 else
1122 {
1123 BFD_ASSERT (h->dynindx != -1);
1124 relocate = FALSE;
1125 outrel.r_info = ELF32_R_INFO (h->dynindx, R_MN10300_32);
1126 outrel.r_addend = value + addend;
1127 }
1128 }
1129
1130 bfd_elf32_swap_reloca_out (output_bfd, &outrel,
560e09e9
NC		 1131 (bfd_byte *) (((Elf32_External_Rela *) sreloc->contents)
1132 + sreloc->reloc_count));
03a12831
AO		 1133 ++sreloc->reloc_count;
1134
1135 /* If this reloc is against an external symbol, we do
1136 not want to fiddle with the addend. Otherwise, we
1137 need to include the symbol value so that it becomes
1138 an addend for the dynamic reloc. */
1139 if (! relocate)
1140 return bfd_reloc_ok;
1141 }
252b5132
RH		 1142 value += addend;
1143 bfd_put_32 (input_bfd, value, hit_data);
1144 return bfd_reloc_ok;
1145
1146 case R_MN10300_24:
1147 value += addend;
1148
010ac81f 1149 if ((long) value > 0x7fffff || (long) value < -0x800000)
252b5132
RH		 1150 return bfd_reloc_overflow;
1151
1152 bfd_put_8 (input_bfd, value & 0xff, hit_data);
1153 bfd_put_8 (input_bfd, (value >> 8) & 0xff, hit_data + 1);
1154 bfd_put_8 (input_bfd, (value >> 16) & 0xff, hit_data + 2);
1155 return bfd_reloc_ok;
1156
1157 case R_MN10300_16:
1158 value += addend;
1159
010ac81f 1160 if ((long) value > 0x7fff || (long) value < -0x8000)
252b5132
RH		 1161 return bfd_reloc_overflow;
1162
1163 bfd_put_16 (input_bfd, value, hit_data);
1164 return bfd_reloc_ok;
1165
1166 case R_MN10300_8:
1167 value += addend;
1168
010ac81f 1169 if ((long) value > 0x7f || (long) value < -0x80)
252b5132
RH		 1170 return bfd_reloc_overflow;
1171
1172 bfd_put_8 (input_bfd, value, hit_data);
1173 return bfd_reloc_ok;
1174
1175 case R_MN10300_PCREL8:
1176 value -= (input_section->output_section->vma
1177 + input_section->output_offset);
1178 value -= offset;
1179 value += addend;
1180
605d18d4 1181 if ((long) value > 0x7f || (long) value < -0x80)
252b5132
RH		 1182 return bfd_reloc_overflow;
1183
1184 bfd_put_8 (input_bfd, value, hit_data);
1185 return bfd_reloc_ok;
1186
1187 case R_MN10300_PCREL16:
1188 value -= (input_section->output_section->vma
1189 + input_section->output_offset);
1190 value -= offset;
1191 value += addend;
1192
605d18d4 1193 if ((long) value > 0x7fff || (long) value < -0x8000)
252b5132
RH		 1194 return bfd_reloc_overflow;
1195
1196 bfd_put_16 (input_bfd, value, hit_data);
1197 return bfd_reloc_ok;
1198
1199 case R_MN10300_PCREL32:
1200 value -= (input_section->output_section->vma
1201 + input_section->output_offset);
1202 value -= offset;
1203 value += addend;
1204
1205 bfd_put_32 (input_bfd, value, hit_data);
1206 return bfd_reloc_ok;
1207
1208 case R_MN10300_GNU_VTINHERIT:
1209 case R_MN10300_GNU_VTENTRY:
1210 return bfd_reloc_ok;
1211
03a12831
AO		 1212 case R_MN10300_GOTPC32:
1213 /* Use global offset table as symbol value. */
03a12831
AO		 1214 value = bfd_get_section_by_name (dynobj,
1215 ".got")->output_section->vma;
1216 value -= (input_section->output_section->vma
1217 + input_section->output_offset);
1218 value -= offset;
1219 value += addend;
1220
1221 bfd_put_32 (input_bfd, value, hit_data);
1222 return bfd_reloc_ok;
3b36f7e6 1223
03a12831
AO		 1224 case R_MN10300_GOTPC16:
1225 /* Use global offset table as symbol value. */
03a12831
AO		 1226 value = bfd_get_section_by_name (dynobj,
1227 ".got")->output_section->vma;
1228 value -= (input_section->output_section->vma
1229 + input_section->output_offset);
1230 value -= offset;
1231 value += addend;
1232
605d18d4 1233 if ((long) value > 0x7fff || (long) value < -0x8000)
03a12831
AO		 1234 return bfd_reloc_overflow;
1235
1236 bfd_put_16 (input_bfd, value, hit_data);
1237 return bfd_reloc_ok;
1238
1239 case R_MN10300_GOTOFF32:
1240 value -= bfd_get_section_by_name (dynobj,
1241 ".got")->output_section->vma;
1242 value += addend;
3b36f7e6 1243
03a12831
AO		 1244 bfd_put_32 (input_bfd, value, hit_data);
1245 return bfd_reloc_ok;
1246
1247 case R_MN10300_GOTOFF24:
1248 value -= bfd_get_section_by_name (dynobj,
1249 ".got")->output_section->vma;
1250 value += addend;
3b36f7e6 1251
03a12831
AO		 1252 if ((long) value > 0x7fffff || (long) value < -0x800000)
1253 return bfd_reloc_overflow;
1254
1255 bfd_put_8 (input_bfd, value, hit_data);
1256 bfd_put_8 (input_bfd, (value >> 8) & 0xff, hit_data + 1);
1257 bfd_put_8 (input_bfd, (value >> 16) & 0xff, hit_data + 2);
1258 return bfd_reloc_ok;
1259
1260 case R_MN10300_GOTOFF16:
1261 value -= bfd_get_section_by_name (dynobj,
1262 ".got")->output_section->vma;
1263 value += addend;
3b36f7e6 1264
605d18d4 1265 if ((long) value > 0x7fff || (long) value < -0x8000)
03a12831
AO		 1266 return bfd_reloc_overflow;
1267
1268 bfd_put_16 (input_bfd, value, hit_data);
1269 return bfd_reloc_ok;
1270
1271 case R_MN10300_PLT32:
1272 if (h != NULL
1273 && ELF_ST_VISIBILITY (h->other) != STV_INTERNAL
1274 && ELF_ST_VISIBILITY (h->other) != STV_HIDDEN
1275 && h->plt.offset != (bfd_vma) -1)
1276 {
1277 asection * splt;
1278
1279 splt = bfd_get_section_by_name (dynobj, ".plt");
3b36f7e6 1280
03a12831
AO		 1281 value = (splt->output_section->vma
1282 + splt->output_offset
1283 + h->plt.offset) - value;
1284 }
1285
1286 value -= (input_section->output_section->vma
1287 + input_section->output_offset);
1288 value -= offset;
1289 value += addend;
1290
1291 bfd_put_32 (input_bfd, value, hit_data);
1292 return bfd_reloc_ok;
1293
1294 case R_MN10300_PLT16:
1295 if (h != NULL
1296 && ELF_ST_VISIBILITY (h->other) != STV_INTERNAL
1297 && ELF_ST_VISIBILITY (h->other) != STV_HIDDEN
1298 && h->plt.offset != (bfd_vma) -1)
1299 {
1300 asection * splt;
1301
1302 splt = bfd_get_section_by_name (dynobj, ".plt");
3b36f7e6 1303
03a12831
AO		 1304 value = (splt->output_section->vma
1305 + splt->output_offset
1306 + h->plt.offset) - value;
1307 }
1308
1309 value -= (input_section->output_section->vma
1310 + input_section->output_offset);
1311 value -= offset;
1312 value += addend;
1313
605d18d4 1314 if ((long) value > 0x7fff || (long) value < -0x8000)
03a12831
AO		 1315 return bfd_reloc_overflow;
1316
1317 bfd_put_16 (input_bfd, value, hit_data);
1318 return bfd_reloc_ok;
1319
1320 case R_MN10300_GOT32:
1321 case R_MN10300_GOT24:
1322 case R_MN10300_GOT16:
1323 {
1324 asection * sgot;
1325
1326 sgot = bfd_get_section_by_name (dynobj, ".got");
3b36f7e6 1327
03a12831
AO		 1328 if (h != NULL)
1329 {
1330 bfd_vma off;
1331
1332 off = h->got.offset;
1333 BFD_ASSERT (off != (bfd_vma) -1);
1334
1335 if (! elf_hash_table (info)->dynamic_sections_created
7e2294f9 1336 || SYMBOL_REFERENCES_LOCAL (info, h))
03a12831
AO		 1337 /* This is actually a static link, or it is a
1338 -Bsymbolic link and the symbol is defined
1339 locally, or the symbol was forced to be local
1340 because of a version file. We must initialize
1341 this entry in the global offset table.
1342
1343 When doing a dynamic link, we create a .rela.got
1344 relocation entry to initialize the value. This
1345 is done in the finish_dynamic_symbol routine. */
1346 bfd_put_32 (output_bfd, value,
1347 sgot->contents + off);
1348
1349 value = sgot->output_offset + off;
1350 }
1351 else
1352 {
1353 bfd_vma off;
1354
1355 off = elf_local_got_offsets (input_bfd)[symndx];
1356
1357 bfd_put_32 (output_bfd, value, sgot->contents + off);
1358
1359 if (info->shared)
1360 {
1361 asection * srelgot;
1362 Elf_Internal_Rela outrel;
1363
1364 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
1365 BFD_ASSERT (srelgot != NULL);
1366
1367 outrel.r_offset = (sgot->output_section->vma
1368 + sgot->output_offset
1369 + off);
1370 outrel.r_info = ELF32_R_INFO (0, R_MN10300_RELATIVE);
1371 outrel.r_addend = value;
1372 bfd_elf32_swap_reloca_out (output_bfd, &outrel,
560e09e9
NC		 1373 (bfd_byte *) (((Elf32_External_Rela *)
1374 srelgot->contents)
1375 + srelgot->reloc_count));
03a12831
AO		 1376 ++ srelgot->reloc_count;
1377 }
1378
1379 value = sgot->output_offset + off;
1380 }
1381 }
1382
1383 value += addend;
1384
1385 if (r_type == R_MN10300_GOT32)
1386 {
1387 bfd_put_32 (input_bfd, value, hit_data);
1388 return bfd_reloc_ok;
1389 }
1390 else if (r_type == R_MN10300_GOT24)
1391 {
1392 if ((long) value > 0x7fffff || (long) value < -0x800000)
1393 return bfd_reloc_overflow;
1394
1395 bfd_put_8 (input_bfd, value & 0xff, hit_data);
1396 bfd_put_8 (input_bfd, (value >> 8) & 0xff, hit_data + 1);
1397 bfd_put_8 (input_bfd, (value >> 16) & 0xff, hit_data + 2);
1398 return bfd_reloc_ok;
1399 }
1400 else if (r_type == R_MN10300_GOT16)
1401 {
605d18d4 1402 if ((long) value > 0x7fff || (long) value < -0x8000)
03a12831
AO		 1403 return bfd_reloc_overflow;
1404
1405 bfd_put_16 (input_bfd, value, hit_data);
1406 return bfd_reloc_ok;
1407 }
1408 /* Fall through. */
3b36f7e6 1409
252b5132
RH		 1410 default:
1411 return bfd_reloc_notsupported;
1412 }
1413}
252b5132
RH		 1414\f
1415/* Relocate an MN10300 ELF section. */
603b7257 1416
b34976b6 1417static bfd_boolean
603b7257
NC		 1418mn10300_elf_relocate_section (bfd *output_bfd,
1419 struct bfd_link_info *info,
1420 bfd *input_bfd,
1421 asection *input_section,
1422 bfd_byte *contents,
1423 Elf_Internal_Rela *relocs,
1424 Elf_Internal_Sym *local_syms,
1425 asection **local_sections)
252b5132
RH		 1426{
1427 Elf_Internal_Shdr *symtab_hdr;
b2a8e766 1428 struct elf_link_hash_entry **sym_hashes;
252b5132
RH		 1429 Elf_Internal_Rela *rel, *relend;
1430
1431 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
b2a8e766 1432 sym_hashes = elf_sym_hashes (input_bfd);
252b5132
RH		 1433
1434 rel = relocs;
1435 relend = relocs + input_section->reloc_count;
1436 for (; rel < relend; rel++)
1437 {
1438 int r_type;
1439 reloc_howto_type *howto;
1440 unsigned long r_symndx;
1441 Elf_Internal_Sym *sym;
1442 asection *sec;
1443 struct elf32_mn10300_link_hash_entry *h;
1444 bfd_vma relocation;
1445 bfd_reloc_status_type r;
1446
1447 r_symndx = ELF32_R_SYM (rel->r_info);
1448 r_type = ELF32_R_TYPE (rel->r_info);
1449 howto = elf_mn10300_howto_table + r_type;
1450
1451 /* Just skip the vtable gc relocs. */
1452 if (r_type == R_MN10300_GNU_VTINHERIT
1453 || r_type == R_MN10300_GNU_VTENTRY)
1454 continue;
1455
252b5132
RH		 1456 h = NULL;
1457 sym = NULL;
1458 sec = NULL;
1459 if (r_symndx < symtab_hdr->sh_info)
1460 {
1461 sym = local_syms + r_symndx;
1462 sec = local_sections[r_symndx];
8517fae7 1463 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
252b5132
RH		 1464 }
1465 else
1466 {
560e09e9
NC		 1467 bfd_boolean unresolved_reloc;
1468 bfd_boolean warned;
1469 struct elf_link_hash_entry *hh;
1470
b2a8e766
AM		 1471 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
1472 r_symndx, symtab_hdr, sym_hashes,
1473 hh, sec, relocation,
1474 unresolved_reloc, warned);
560e09e9
NC		 1475
1476 h = (struct elf32_mn10300_link_hash_entry *) hh;
1477
1478 if ((h->root.root.type == bfd_link_hash_defined
252b5132 1479 || h->root.root.type == bfd_link_hash_defweak)
560e09e9 1480 && ( r_type == R_MN10300_GOTPC32
03a12831
AO		 1481 || r_type == R_MN10300_GOTPC16
1482 || (( r_type == R_MN10300_PLT32
1483 || r_type == R_MN10300_PLT16)
1484 && ELF_ST_VISIBILITY (h->root.other) != STV_INTERNAL
1485 && ELF_ST_VISIBILITY (h->root.other) != STV_HIDDEN
1486 && h->root.plt.offset != (bfd_vma) -1)
1487 || (( r_type == R_MN10300_GOT32
1488 || r_type == R_MN10300_GOT24
1489 || r_type == R_MN10300_GOT16)
1490 && elf_hash_table (info)->dynamic_sections_created
7e2294f9 1491 && !SYMBOL_REFERENCES_LOCAL (info, hh))
146ccdbb 1492 || (r_type == R_MN10300_32
bfff1642
NC		 1493 /* _32 relocs in executables force _COPY relocs,
1494 such that the address of the symbol ends up
1495 being local. */
1496 && !info->executable
7e2294f9 1497 && !SYMBOL_REFERENCES_LOCAL (info, hh)
03a12831
AO		 1498 && ((input_section->flags & SEC_ALLOC) != 0
1499 /* DWARF will emit R_MN10300_32 relocations
1500 in its sections against symbols defined
1501 externally in shared libraries. We can't
1502 do anything with them here. */
1503 || ((input_section->flags & SEC_DEBUGGING) != 0
f5385ebf 1504 && h->root.def_dynamic)))))
560e09e9
NC		 1505 /* In these cases, we don't need the relocation
1506 value. We check specially because in some
1507 obscure cases sec->output_section will be NULL. */
03a12831 1508 relocation = 0;
560e09e9 1509
ab96bf03 1510 else if (!info->relocatable && unresolved_reloc)
560e09e9 1511 (*_bfd_error_handler)
843fe662
L		 1512 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
1513 input_bfd,
1514 input_section,
1515 (long) rel->r_offset,
1516 howto->name,
1517 h->root.root.root.string);
252b5132
RH		 1518 }
1519
ab96bf03
AM		 1520 if (sec != NULL && elf_discarded_section (sec))
1521 {
1522 /* For relocs against symbols from removed linkonce sections,
1523 or sections discarded by a linker script, we just want the
1524 section contents zeroed. Avoid any special processing. */
1525 _bfd_clear_contents (howto, input_bfd, contents + rel->r_offset);
1526 rel->r_info = 0;
1527 rel->r_addend = 0;
1528 continue;
1529 }
1530
1531 if (info->relocatable)
1532 continue;
1533
252b5132
RH		 1534 r = mn10300_elf_final_link_relocate (howto, input_bfd, output_bfd,
1535 input_section,
1536 contents, rel->r_offset,
1537 relocation, rel->r_addend,
603b7257 1538 (struct elf_link_hash_entry *) h,
03a12831 1539 r_symndx,
252b5132
RH		 1540 info, sec, h == NULL);
1541
1542 if (r != bfd_reloc_ok)
1543 {
1544 const char *name;
603b7257 1545 const char *msg = NULL;
252b5132
RH		 1546
1547 if (h != NULL)
1548 name = h->root.root.root.string;
1549 else
1550 {
1551 name = (bfd_elf_string_from_elf_section
1552 (input_bfd, symtab_hdr->sh_link, sym->st_name));
1553 if (name == NULL || *name == '\0')
1554 name = bfd_section_name (input_bfd, sec);
1555 }
1556
1557 switch (r)
1558 {
1559 case bfd_reloc_overflow:
1560 if (! ((*info->callbacks->reloc_overflow)
dfeffb9f
L		 1561 (info, (h ? &h->root.root : NULL), name,
1562 howto->name, (bfd_vma) 0, input_bfd,
1563 input_section, rel->r_offset)))
b34976b6 1564 return FALSE;
252b5132
RH		 1565 break;
1566
1567 case bfd_reloc_undefined:
1568 if (! ((*info->callbacks->undefined_symbol)
1569 (info, name, input_bfd, input_section,
b34976b6
AM		 1570 rel->r_offset, TRUE)))
1571 return FALSE;
252b5132
RH		 1572 break;
1573
1574 case bfd_reloc_outofrange:
1575 msg = _("internal error: out of range error");
1576 goto common_error;
1577
1578 case bfd_reloc_notsupported:
1579 msg = _("internal error: unsupported relocation error");
1580 goto common_error;
1581
1582 case bfd_reloc_dangerous:
c9b57b7e
DD		 1583 if (r_type == R_MN10300_PCREL32)
1584 msg = _("error: inappropriate relocation type for shared"
1585 " library (did you forget -fpic?)");
1586 else
1587 msg = _("internal error: suspicious relocation type used"
1588 " in shared library");
252b5132
RH		 1589 goto common_error;
1590
1591 default:
1592 msg = _("internal error: unknown error");
603b7257 1593 /* Fall through. */
252b5132
RH		 1594
1595 common_error:
1596 if (!((*info->callbacks->warning)
1597 (info, msg, name, input_bfd, input_section,
1598 rel->r_offset)))
b34976b6 1599 return FALSE;
252b5132
RH		 1600 break;
1601 }
1602 }
1603 }
1604
b34976b6 1605 return TRUE;
252b5132
RH		 1606}
1607
1608/* Finish initializing one hash table entry. */
603b7257 1609
b34976b6 1610static bfd_boolean
603b7257
NC		 1611elf32_mn10300_finish_hash_table_entry (struct bfd_hash_entry *gen_entry,
1612 void * in_args)
252b5132
RH		 1613{
1614 struct elf32_mn10300_link_hash_entry *entry;
603b7257 1615 struct bfd_link_info *link_info = (struct bfd_link_info *) in_args;
252b5132
RH		 1616 unsigned int byte_count = 0;
1617
010ac81f 1618 entry = (struct elf32_mn10300_link_hash_entry *) gen_entry;
252b5132 1619
e92d460e
AM		 1620 if (entry->root.root.type == bfd_link_hash_warning)
1621 entry = (struct elf32_mn10300_link_hash_entry *) entry->root.root.u.i.link;
1622
252b5132
RH		 1623 /* If we already know we want to convert "call" to "calls" for calls
1624 to this symbol, then return now. */
1625 if (entry->flags == MN10300_CONVERT_CALL_TO_CALLS)
b34976b6 1626 return TRUE;
252b5132
RH		 1627
1628 /* If there are no named calls to this symbol, or there's nothing we
1055df0f
AO		 1629 can move from the function itself into the "call" instruction,
1630 then note that all "call" instructions should be converted into
1631 "calls" instructions and return. If a symbol is available for
1632 dynamic symbol resolution (overridable or overriding), avoid
1633 custom calling conventions. */
252b5132 1634 if (entry->direct_calls == 0
1055df0f
AO		 1635 || (entry->stack_size == 0 && entry->movm_args == 0)
1636 || (elf_hash_table (link_info)->dynamic_sections_created
1637 && ELF_ST_VISIBILITY (entry->root.other) != STV_INTERNAL
1638 && ELF_ST_VISIBILITY (entry->root.other) != STV_HIDDEN))
252b5132
RH		 1639 {
1640 /* Make a note that we should convert "call" instructions to "calls"
1641 instructions for calls to this symbol. */
1642 entry->flags |= MN10300_CONVERT_CALL_TO_CALLS;
b34976b6 1643 return TRUE;
252b5132
RH		 1644 }
1645
1646 /* We may be able to move some instructions from the function itself into
1647 the "call" instruction. Count how many bytes we might be able to
1648 eliminate in the function itself. */
1649
1650 /* A movm instruction is two bytes. */
1651 if (entry->movm_args)
1652 byte_count += 2;
1653
1654 /* Count the insn to allocate stack space too. */
1a101a42
AM		 1655 if (entry->stack_size > 0)
1656 {
1657 if (entry->stack_size <= 128)
1658 byte_count += 3;
1659 else
1660 byte_count += 4;
1661 }
252b5132
RH		 1662
1663 /* If using "call" will result in larger code, then turn all
4cc11e76 1664 the associated "call" instructions into "calls" instructions. */
252b5132
RH		 1665 if (byte_count < entry->direct_calls)
1666 entry->flags |= MN10300_CONVERT_CALL_TO_CALLS;
1667
1668 /* This routine never fails. */
b34976b6 1669 return TRUE;
252b5132
RH		 1670}
1671
eb13e63f 1672/* Used to count hash table entries. */
603b7257 1673
eb13e63f
DD		 1674static bfd_boolean
1675elf32_mn10300_count_hash_table_entries (struct bfd_hash_entry *gen_entry ATTRIBUTE_UNUSED,
603b7257 1676 void * in_args)
eb13e63f 1677{
bfff1642 1678 int *count = (int *) in_args;
eb13e63f
DD		 1679
1680 (*count) ++;
1681 return TRUE;
1682}
1683
1684/* Used to enumerate hash table entries into a linear array. */
603b7257 1685
eb13e63f
DD		 1686static bfd_boolean
1687elf32_mn10300_list_hash_table_entries (struct bfd_hash_entry *gen_entry,
603b7257 1688 void * in_args)
eb13e63f
DD		 1689{
1690 struct bfd_hash_entry ***ptr = (struct bfd_hash_entry ***) in_args;
1691
1692 **ptr = gen_entry;
1693 (*ptr) ++;
1694 return TRUE;
1695}
1696
1697/* Used to sort the array created by the above. */
603b7257 1698
eb13e63f
DD		 1699static int
1700sort_by_value (const void *va, const void *vb)
1701{
1702 struct elf32_mn10300_link_hash_entry *a
bfff1642 1703 = *(struct elf32_mn10300_link_hash_entry **) va;
eb13e63f 1704 struct elf32_mn10300_link_hash_entry *b
bfff1642 1705 = *(struct elf32_mn10300_link_hash_entry **) vb;
eb13e63f
DD		 1706
1707 return a->value - b->value;
1708}
1709
603b7257
NC		 1710/* Compute the stack size and movm arguments for the function
1711 referred to by HASH at address ADDR in section with
1712 contents CONTENTS, store the information in the hash table. */
1713
1714static void
1715compute_function_info (bfd *abfd,
1716 struct elf32_mn10300_link_hash_entry *hash,
1717 bfd_vma addr,
1718 unsigned char *contents)
1719{
1720 unsigned char byte1, byte2;
1721 /* We only care about a very small subset of the possible prologue
1722 sequences here. Basically we look for:
1723
1724 movm [d2,d3,a2,a3],sp (optional)
1725 add <size>,sp (optional, and only for sizes which fit in an unsigned
1726 8 bit number)
1727
1728 If we find anything else, we quit. */
1729
1730 /* Look for movm [regs],sp. */
1731 byte1 = bfd_get_8 (abfd, contents + addr);
1732 byte2 = bfd_get_8 (abfd, contents + addr + 1);
1733
1734 if (byte1 == 0xcf)
1735 {
1736 hash->movm_args = byte2;
1737 addr += 2;
1738 byte1 = bfd_get_8 (abfd, contents + addr);
1739 byte2 = bfd_get_8 (abfd, contents + addr + 1);
1740 }
1741
1742 /* Now figure out how much stack space will be allocated by the movm
1743 instruction. We need this kept separate from the function's normal
1744 stack space. */
1745 if (hash->movm_args)
1746 {
1747 /* Space for d2. */
1748 if (hash->movm_args & 0x80)
1749 hash->movm_stack_size += 4;
1750
1751 /* Space for d3. */
1752 if (hash->movm_args & 0x40)
1753 hash->movm_stack_size += 4;
1754
1755 /* Space for a2. */
1756 if (hash->movm_args & 0x20)
1757 hash->movm_stack_size += 4;
1758
1759 /* Space for a3. */
1760 if (hash->movm_args & 0x10)
1761 hash->movm_stack_size += 4;
1762
1763 /* "other" space. d0, d1, a0, a1, mdr, lir, lar, 4 byte pad. */
1764 if (hash->movm_args & 0x08)
1765 hash->movm_stack_size += 8 * 4;
1766
1767 if (bfd_get_mach (abfd) == bfd_mach_am33
1768 || bfd_get_mach (abfd) == bfd_mach_am33_2)
1769 {
1770 /* "exother" space. e0, e1, mdrq, mcrh, mcrl, mcvf */
1771 if (hash->movm_args & 0x1)
1772 hash->movm_stack_size += 6 * 4;
1773
1774 /* exreg1 space. e4, e5, e6, e7 */
1775 if (hash->movm_args & 0x2)
1776 hash->movm_stack_size += 4 * 4;
1777
1778 /* exreg0 space. e2, e3 */
1779 if (hash->movm_args & 0x4)
1780 hash->movm_stack_size += 2 * 4;
1781 }
1782 }
1783
1784 /* Now look for the two stack adjustment variants. */
1785 if (byte1 == 0xf8 && byte2 == 0xfe)
1786 {
1787 int temp = bfd_get_8 (abfd, contents + addr + 2);
1788 temp = ((temp & 0xff) ^ (~0x7f)) + 0x80;
1789
1790 hash->stack_size = -temp;
1791 }
1792 else if (byte1 == 0xfa && byte2 == 0xfe)
1793 {
1794 int temp = bfd_get_16 (abfd, contents + addr + 2);
1795 temp = ((temp & 0xffff) ^ (~0x7fff)) + 0x8000;
1796 temp = -temp;
1797
1798 if (temp < 255)
1799 hash->stack_size = temp;
1800 }
1801
1802 /* If the total stack to be allocated by the call instruction is more
1803 than 255 bytes, then we can't remove the stack adjustment by using
1804 "call" (we might still be able to remove the "movm" instruction. */
1805 if (hash->stack_size + hash->movm_stack_size > 255)
1806 hash->stack_size = 0;
1807}
1808
1809/* Delete some bytes from a section while relaxing. */
1810
1811static bfd_boolean
1812mn10300_elf_relax_delete_bytes (bfd *abfd,
1813 asection *sec,
1814 bfd_vma addr,
1815 int count)
1816{
1817 Elf_Internal_Shdr *symtab_hdr;
1818 unsigned int sec_shndx;
1819 bfd_byte *contents;
1820 Elf_Internal_Rela *irel, *irelend;
1821 Elf_Internal_Rela *irelalign;
1822 bfd_vma toaddr;
1823 Elf_Internal_Sym *isym, *isymend;
1824 struct elf_link_hash_entry **sym_hashes;
1825 struct elf_link_hash_entry **end_hashes;
1826 unsigned int symcount;
1827
1828 sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
1829
1830 contents = elf_section_data (sec)->this_hdr.contents;
1831
603b7257
NC		 1832 irelalign = NULL;
1833 toaddr = sec->size;
1834
1835 irel = elf_section_data (sec)->relocs;
1836 irelend = irel + sec->reloc_count;
1837
cf4a529b
NC		 1838 if (sec->reloc_count > 0)
1839 {
1840 /* If there is an align reloc at the end of the section ignore it.
1841 GAS creates these relocs for reasons of its own, and they just
1842 serve to keep the section artifically inflated. */
1843 if (ELF32_R_TYPE ((irelend - 1)->r_info) == (int) R_MN10300_ALIGN)
1844 --irelend;
569006e5 1845
cf4a529b 1846 /* The deletion must stop at the next ALIGN reloc for an aligment
b5f5fd96
NC		 1847 power larger than, or not a multiple of, the number of bytes we
1848 are deleting. */
cf4a529b 1849 for (; irel < irelend; irel++)
b5f5fd96
NC		 1850 {
1851 int alignment = 1 << irel->r_addend;
1852
1853 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_ALIGN
1854 && irel->r_offset > addr
1855 && irel->r_offset < toaddr
1856 && (count < alignment
1857 || alignment % count != 0))
1858 {
1859 irelalign = irel;
1860 toaddr = irel->r_offset;
1861 break;
1862 }
1863 }
cf4a529b 1864 }
569006e5 1865
603b7257
NC		 1866 /* Actually delete the bytes. */
1867 memmove (contents + addr, contents + addr + count,
1868 (size_t) (toaddr - addr - count));
569006e5
NC		 1869
1870 /* Adjust the section's size if we are shrinking it, or else
1871 pad the bytes between the end of the shrunken region and
1872 the start of the next region with NOP codes. */
1873 if (irelalign == NULL)
1874 {
1875 sec->size -= count;
1876 /* Include symbols at the end of the section, but
1877 not at the end of a sub-region of the section. */
1878 toaddr ++;
1879 }
1880 else
1881 {
1882 int i;
1883
1884#define NOP_OPCODE 0xcb
1885
1886 for (i = 0; i < count; i ++)
1887 bfd_put_8 (abfd, (bfd_vma) NOP_OPCODE, contents + toaddr - count + i);
1888 }
603b7257
NC		 1889
1890 /* Adjust all the relocs. */
1891 for (irel = elf_section_data (sec)->relocs; irel < irelend; irel++)
1892 {
1893 /* Get the new reloc address. */
1894 if ((irel->r_offset > addr
b5f5fd96
NC		 1895 && irel->r_offset < toaddr)
1896 || (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_ALIGN
1897 && irel->r_offset == toaddr))
603b7257
NC		 1898 irel->r_offset -= count;
1899 }
1900
b5f5fd96
NC		 1901 /* Adjust the local symbols in the section, reducing their value
1902 by the number of bytes deleted. Note - symbols within the deleted
1903 region are moved to the address of the start of the region, which
1904 actually means that they will address the byte beyond the end of
1905 the region once the deletion has been completed. */
603b7257
NC		 1906 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1907 isym = (Elf_Internal_Sym *) symtab_hdr->contents;
1908 for (isymend = isym + symtab_hdr->sh_info; isym < isymend; isym++)
1909 {
1910 if (isym->st_shndx == sec_shndx
1911 && isym->st_value > addr
569006e5 1912 && isym->st_value < toaddr)
b5f5fd96
NC		 1913 {
1914 if (isym->st_value < addr + count)
1915 isym->st_value = addr;
1916 else
1917 isym->st_value -= count;
1918 }
bfff1642
NC		 1919 /* Adjust the function symbol's size as well. */
1920 else if (isym->st_shndx == sec_shndx
1921 && ELF_ST_TYPE (isym->st_info) == STT_FUNC
1922 && isym->st_value + isym->st_size > addr
569006e5 1923 && isym->st_value + isym->st_size < toaddr)
bfff1642 1924 isym->st_size -= count;
603b7257
NC		 1925 }
1926
1927 /* Now adjust the global symbols defined in this section. */
1928 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
1929 - symtab_hdr->sh_info);
1930 sym_hashes = elf_sym_hashes (abfd);
1931 end_hashes = sym_hashes + symcount;
1932 for (; sym_hashes < end_hashes; sym_hashes++)
1933 {
1934 struct elf_link_hash_entry *sym_hash = *sym_hashes;
1935
1936 if ((sym_hash->root.type == bfd_link_hash_defined
1937 || sym_hash->root.type == bfd_link_hash_defweak)
1938 && sym_hash->root.u.def.section == sec
1939 && sym_hash->root.u.def.value > addr
569006e5 1940 && sym_hash->root.u.def.value < toaddr)
b5f5fd96
NC		 1941 {
1942 if (sym_hash->root.u.def.value < addr + count)
1943 sym_hash->root.u.def.value = addr;
1944 else
1945 sym_hash->root.u.def.value -= count;
1946 }
bfff1642
NC		 1947 /* Adjust the function symbol's size as well. */
1948 else if (sym_hash->root.type == bfd_link_hash_defined
1949 && sym_hash->root.u.def.section == sec
1950 && sym_hash->type == STT_FUNC
1951 && sym_hash->root.u.def.value + sym_hash->size > addr
569006e5 1952 && sym_hash->root.u.def.value + sym_hash->size < toaddr)
bfff1642 1953 sym_hash->size -= count;
603b7257
NC		 1954 }
1955
b5f5fd96
NC		 1956 /* See if we can move the ALIGN reloc forward.
1957 We have adjusted r_offset for it already. */
1958 if (irelalign != NULL)
1959 {
1960 bfd_vma alignto, alignaddr;
1961
1962 if ((int) irelalign->r_addend > 0)
1963 {
1964 /* This is the old address. */
1965 alignto = BFD_ALIGN (toaddr, 1 << irelalign->r_addend);
1966 /* This is where the align points to now. */
1967 alignaddr = BFD_ALIGN (irelalign->r_offset,
1968 1 << irelalign->r_addend);
1969 if (alignaddr < alignto)
1970 /* Tail recursion. */
1971 return mn10300_elf_relax_delete_bytes (abfd, sec, alignaddr,
1972 (int) (alignto - alignaddr));
1973 }
1974 }
1975
603b7257
NC		 1976 return TRUE;
1977}
1978
1979/* Return TRUE if a symbol exists at the given address, else return
1980 FALSE. */
1981
1982static bfd_boolean
1983mn10300_elf_symbol_address_p (bfd *abfd,
1984 asection *sec,
1985 Elf_Internal_Sym *isym,
1986 bfd_vma addr)
1987{
1988 Elf_Internal_Shdr *symtab_hdr;
1989 unsigned int sec_shndx;
1990 Elf_Internal_Sym *isymend;
1991 struct elf_link_hash_entry **sym_hashes;
1992 struct elf_link_hash_entry **end_hashes;
1993 unsigned int symcount;
1994
1995 sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
1996
1997 /* Examine all the symbols. */
1998 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1999 for (isymend = isym + symtab_hdr->sh_info; isym < isymend; isym++)
2000 if (isym->st_shndx == sec_shndx
2001 && isym->st_value == addr)
2002 return TRUE;
2003
2004 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
2005 - symtab_hdr->sh_info);
2006 sym_hashes = elf_sym_hashes (abfd);
2007 end_hashes = sym_hashes + symcount;
2008 for (; sym_hashes < end_hashes; sym_hashes++)
2009 {
2010 struct elf_link_hash_entry *sym_hash = *sym_hashes;
2011
2012 if ((sym_hash->root.type == bfd_link_hash_defined
2013 || sym_hash->root.type == bfd_link_hash_defweak)
2014 && sym_hash->root.u.def.section == sec
2015 && sym_hash->root.u.def.value == addr)
2016 return TRUE;
2017 }
2018
2019 return FALSE;
2020}
eb13e63f 2021
252b5132
RH		 2022/* This function handles relaxing for the mn10300.
2023
4cc11e76 2024 There are quite a few relaxing opportunities available on the mn10300:
252b5132
RH		 2025
2026 * calls:32 -> calls:16 2 bytes
2027 * call:32 -> call:16 2 bytes
2028
2029 * call:32 -> calls:32 1 byte
2030 * call:16 -> calls:16 1 byte
2031 * These are done anytime using "calls" would result
2032 in smaller code, or when necessary to preserve the
2033 meaning of the program.
2034
2035 * call:32 varies
2036 * call:16
2037 * In some circumstances we can move instructions
2038 from a function prologue into a "call" instruction.
2039 This is only done if the resulting code is no larger
2040 than the original code.
2041
252b5132
RH		 2042 * jmp:32 -> jmp:16 2 bytes
2043 * jmp:16 -> bra:8 1 byte
2044
2045 * If the previous instruction is a conditional branch
2046 around the jump/bra, we may be able to reverse its condition
2047 and change its target to the jump's target. The jump/bra
2048 can then be deleted. 2 bytes
2049
2050 * mov abs32 -> mov abs16 1 or 2 bytes
2051
2052 * Most instructions which accept imm32 can relax to imm16 1 or 2 bytes
2053 - Most instructions which accept imm16 can relax to imm8 1 or 2 bytes
2054
2055 * Most instructions which accept d32 can relax to d16 1 or 2 bytes
2056 - Most instructions which accept d16 can relax to d8 1 or 2 bytes
2057
2058 We don't handle imm16->imm8 or d16->d8 as they're very rare
2059 and somewhat more difficult to support. */
2060
b34976b6 2061static bfd_boolean
603b7257
NC		 2062mn10300_elf_relax_section (bfd *abfd,
2063 asection *sec,
2064 struct bfd_link_info *link_info,
2065 bfd_boolean *again)
252b5132
RH		 2066{
2067 Elf_Internal_Shdr *symtab_hdr;
2068 Elf_Internal_Rela *internal_relocs = NULL;
252b5132
RH		 2069 Elf_Internal_Rela *irel, *irelend;
2070 bfd_byte *contents = NULL;
6cdc0ccc 2071 Elf_Internal_Sym *isymbuf = NULL;
252b5132 2072 struct elf32_mn10300_link_hash_table *hash_table;
6cdc0ccc 2073 asection *section = sec;
fc91707c 2074 bfd_vma align_gap_adjustment;
252b5132 2075
c8a1f254
NS		 2076 if (link_info->relocatable)
2077 (*link_info->callbacks->einfo)
2078 (_("%P%F: --relax and -r may not be used together\n"));
2079
252b5132 2080 /* Assume nothing changes. */
b34976b6 2081 *again = FALSE;
252b5132
RH		 2082
2083 /* We need a pointer to the mn10300 specific hash table. */
2084 hash_table = elf32_mn10300_hash_table (link_info);
2085
2086 /* Initialize fields in each hash table entry the first time through. */
2087 if ((hash_table->flags & MN10300_HASH_ENTRIES_INITIALIZED) == 0)
2088 {
2089 bfd *input_bfd;
2090
2091 /* Iterate over all the input bfds. */
2092 for (input_bfd = link_info->input_bfds;
2093 input_bfd != NULL;
2094 input_bfd = input_bfd->link_next)
2095 {
252b5132
RH		 2096 /* We're going to need all the symbols for each bfd. */
2097 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
6cdc0ccc 2098 if (symtab_hdr->sh_info != 0)
9ad5cbcf 2099 {
6cdc0ccc
AM		 2100 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
2101 if (isymbuf == NULL)
2102 isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
2103 symtab_hdr->sh_info, 0,
2104 NULL, NULL, NULL);
2105 if (isymbuf == NULL)
010ac81f
KH		 2106 goto error_return;
2107 }
252b5132
RH		 2108
2109 /* Iterate over each section in this bfd. */
2110 for (section = input_bfd->sections;
2111 section != NULL;
2112 section = section->next)
2113 {
2114 struct elf32_mn10300_link_hash_entry *hash;
2115 Elf_Internal_Sym *sym;
86033394 2116 asection *sym_sec = NULL;
252b5132
RH		 2117 const char *sym_name;
2118 char *new_name;
252b5132 2119
e948afaf 2120 /* If there's nothing to do in this section, skip it. */
eb13e63f
DD		 2121 if (! ((section->flags & SEC_RELOC) != 0
2122 && section->reloc_count != 0))
2123 continue;
2124 if ((section->flags & SEC_ALLOC) == 0)
e948afaf
AO		 2125 continue;
2126
252b5132
RH		 2127 /* Get cached copy of section contents if it exists. */
2128 if (elf_section_data (section)->this_hdr.contents != NULL)
2129 contents = elf_section_data (section)->this_hdr.contents;
eea6121a 2130 else if (section->size != 0)
252b5132
RH		 2131 {
2132 /* Go get them off disk. */
eea6121a
AM		 2133 if (!bfd_malloc_and_get_section (input_bfd, section,
2134 &contents))
252b5132
RH		 2135 goto error_return;
2136 }
2137 else
6cdc0ccc 2138 contents = NULL;
252b5132
RH		 2139
2140 /* If there aren't any relocs, then there's nothing to do. */
2141 if ((section->flags & SEC_RELOC) != 0
2142 && section->reloc_count != 0)
2143 {
252b5132 2144 /* Get a copy of the native relocations. */
603b7257
NC		 2145 internal_relocs = _bfd_elf_link_read_relocs (input_bfd, section,
2146 NULL, NULL,
2147 link_info->keep_memory);
252b5132
RH		 2148 if (internal_relocs == NULL)
2149 goto error_return;
252b5132
RH		 2150
2151 /* Now examine each relocation. */
2152 irel = internal_relocs;
2153 irelend = irel + section->reloc_count;
2154 for (; irel < irelend; irel++)
2155 {
2156 long r_type;
2157 unsigned long r_index;
2158 unsigned char code;
2159
2160 r_type = ELF32_R_TYPE (irel->r_info);
2161 r_index = ELF32_R_SYM (irel->r_info);
2162
010ac81f 2163 if (r_type < 0 || r_type >= (int) R_MN10300_MAX)
252b5132
RH		 2164 goto error_return;
2165
2166 /* We need the name and hash table entry of the target
2167 symbol! */
2168 hash = NULL;
2169 sym = NULL;
2170 sym_sec = NULL;
2171
2172 if (r_index < symtab_hdr->sh_info)
2173 {
2174 /* A local symbol. */
6cdc0ccc 2175 Elf_Internal_Sym *isym;
dc810e39
AM		 2176 struct elf_link_hash_table *elftab;
2177 bfd_size_type amt;
252b5132 2178
6cdc0ccc
AM		 2179 isym = isymbuf + r_index;
2180 if (isym->st_shndx == SHN_UNDEF)
252b5132 2181 sym_sec = bfd_und_section_ptr;
6cdc0ccc 2182 else if (isym->st_shndx == SHN_ABS)
252b5132 2183 sym_sec = bfd_abs_section_ptr;
6cdc0ccc 2184 else if (isym->st_shndx == SHN_COMMON)
252b5132 2185 sym_sec = bfd_com_section_ptr;
9ad5cbcf
AM		 2186 else
2187 sym_sec
2188 = bfd_section_from_elf_index (input_bfd,
6cdc0ccc 2189 isym->st_shndx);
a7c10850 2190
9ad5cbcf
AM		 2191 sym_name
2192 = bfd_elf_string_from_elf_section (input_bfd,
2193 (symtab_hdr
2194 ->sh_link),
6cdc0ccc 2195 isym->st_name);
252b5132
RH		 2196
2197 /* If it isn't a function, then we don't care
2198 about it. */
6cdc0ccc 2199 if (ELF_ST_TYPE (isym->st_info) != STT_FUNC)
252b5132
RH		 2200 continue;
2201
2202 /* Tack on an ID so we can uniquely identify this
2203 local symbol in the global hash table. */
dc810e39
AM		 2204 amt = strlen (sym_name) + 10;
2205 new_name = bfd_malloc (amt);
bfff1642 2206 if (new_name == NULL)
252b5132
RH		 2207 goto error_return;
2208
f60ca5e3 2209 sprintf (new_name, "%s_%08x", sym_name, sym_sec->id);
252b5132
RH		 2210 sym_name = new_name;
2211
dc810e39
AM		 2212 elftab = &hash_table->static_hash_table->root;
2213 hash = ((struct elf32_mn10300_link_hash_entry *)
2214 elf_link_hash_lookup (elftab, sym_name,
b34976b6 2215 TRUE, TRUE, FALSE));
252b5132
RH		 2216 free (new_name);
2217 }
2218 else
2219 {
2220 r_index -= symtab_hdr->sh_info;
2221 hash = (struct elf32_mn10300_link_hash_entry *)
2222 elf_sym_hashes (input_bfd)[r_index];
2223 }
2224
eb13e63f
DD		 2225 sym_name = hash->root.root.root.string;
2226 if ((section->flags & SEC_CODE) != 0)
2227 {
2228 /* If this is not a "call" instruction, then we
2229 should convert "call" instructions to "calls"
2230 instructions. */
2231 code = bfd_get_8 (input_bfd,
2232 contents + irel->r_offset - 1);
2233 if (code != 0xdd && code != 0xcd)
2234 hash->flags |= MN10300_CONVERT_CALL_TO_CALLS;
2235 }
252b5132 2236
6cdc0ccc
AM		 2237 /* If this is a jump/call, then bump the
2238 direct_calls counter. Else force "call" to
2239 "calls" conversions. */
252b5132 2240 if (r_type == R_MN10300_PCREL32
03a12831
AO		 2241 || r_type == R_MN10300_PLT32
2242 || r_type == R_MN10300_PLT16
252b5132
RH		 2243 || r_type == R_MN10300_PCREL16)
2244 hash->direct_calls++;
2245 else
2246 hash->flags |= MN10300_CONVERT_CALL_TO_CALLS;
2247 }
2248 }
2249
2250 /* Now look at the actual contents to get the stack size,
2251 and a list of what registers were saved in the prologue
2252 (ie movm_args). */
2253 if ((section->flags & SEC_CODE) != 0)
2254 {
6cdc0ccc 2255 Elf_Internal_Sym *isym, *isymend;
9ad5cbcf 2256 unsigned int sec_shndx;
6cdc0ccc
AM		 2257 struct elf_link_hash_entry **hashes;
2258 struct elf_link_hash_entry **end_hashes;
2259 unsigned int symcount;
252b5132 2260
9ad5cbcf
AM		 2261 sec_shndx = _bfd_elf_section_from_bfd_section (input_bfd,
2262 section);
252b5132 2263
1055df0f
AO		 2264 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
2265 - symtab_hdr->sh_info);
2266 hashes = elf_sym_hashes (input_bfd);
2267 end_hashes = hashes + symcount;
2268
252b5132
RH		 2269 /* Look at each function defined in this section and
2270 update info for that function. */
6cdc0ccc
AM		 2271 isymend = isymbuf + symtab_hdr->sh_info;
2272 for (isym = isymbuf; isym < isymend; isym++)
252b5132 2273 {
6cdc0ccc
AM		 2274 if (isym->st_shndx == sec_shndx
2275 && ELF_ST_TYPE (isym->st_info) == STT_FUNC)
252b5132 2276 {
dc810e39
AM		 2277 struct elf_link_hash_table *elftab;
2278 bfd_size_type amt;
1055df0f
AO		 2279 struct elf_link_hash_entry **lhashes = hashes;
2280
2281 /* Skip a local symbol if it aliases a
2282 global one. */
2283 for (; lhashes < end_hashes; lhashes++)
2284 {
2285 hash = (struct elf32_mn10300_link_hash_entry *) *lhashes;
2286 if ((hash->root.root.type == bfd_link_hash_defined
2287 || hash->root.root.type == bfd_link_hash_defweak)
2288 && hash->root.root.u.def.section == section
2289 && hash->root.type == STT_FUNC
2290 && hash->root.root.u.def.value == isym->st_value)
2291 break;
2292 }
2293 if (lhashes != end_hashes)
2294 continue;
dc810e39 2295
6cdc0ccc 2296 if (isym->st_shndx == SHN_UNDEF)
252b5132 2297 sym_sec = bfd_und_section_ptr;
6cdc0ccc 2298 else if (isym->st_shndx == SHN_ABS)
252b5132 2299 sym_sec = bfd_abs_section_ptr;
6cdc0ccc 2300 else if (isym->st_shndx == SHN_COMMON)
252b5132 2301 sym_sec = bfd_com_section_ptr;
9ad5cbcf
AM		 2302 else
2303 sym_sec
2304 = bfd_section_from_elf_index (input_bfd,
6cdc0ccc 2305 isym->st_shndx);
252b5132 2306
dc810e39
AM		 2307 sym_name = (bfd_elf_string_from_elf_section
2308 (input_bfd, symtab_hdr->sh_link,
6cdc0ccc 2309 isym->st_name));
252b5132
RH		 2310
2311 /* Tack on an ID so we can uniquely identify this
2312 local symbol in the global hash table. */
dc810e39
AM		 2313 amt = strlen (sym_name) + 10;
2314 new_name = bfd_malloc (amt);
bfff1642 2315 if (new_name == NULL)
252b5132
RH		 2316 goto error_return;
2317
f60ca5e3 2318 sprintf (new_name, "%s_%08x", sym_name, sym_sec->id);
252b5132
RH		 2319 sym_name = new_name;
2320
dc810e39
AM		 2321 elftab = &hash_table->static_hash_table->root;
2322 hash = ((struct elf32_mn10300_link_hash_entry *)
2323 elf_link_hash_lookup (elftab, sym_name,
b34976b6 2324 TRUE, TRUE, FALSE));
252b5132
RH		 2325 free (new_name);
2326 compute_function_info (input_bfd, hash,
6cdc0ccc 2327 isym->st_value, contents);
eb13e63f 2328 hash->value = isym->st_value;
252b5132
RH		 2329 }
2330 }
2331
6cdc0ccc 2332 for (; hashes < end_hashes; hashes++)
252b5132 2333 {
6cdc0ccc 2334 hash = (struct elf32_mn10300_link_hash_entry *) *hashes;
9ad5cbcf
AM		 2335 if ((hash->root.root.type == bfd_link_hash_defined
2336 || hash->root.root.type == bfd_link_hash_defweak)
2337 && hash->root.root.u.def.section == section
9bb351fd 2338 && hash->root.type == STT_FUNC)
252b5132
RH		 2339 compute_function_info (input_bfd, hash,
2340 (hash)->root.root.u.def.value,
2341 contents);
2342 }
2343 }
2344
2345 /* Cache or free any memory we allocated for the relocs. */
6cdc0ccc
AM		 2346 if (internal_relocs != NULL
2347 && elf_section_data (section)->relocs != internal_relocs)
2348 free (internal_relocs);
2349 internal_relocs = NULL;
252b5132
RH		 2350
2351 /* Cache or free any memory we allocated for the contents. */
6cdc0ccc
AM		 2352 if (contents != NULL
2353 && elf_section_data (section)->this_hdr.contents != contents)
252b5132
RH		 2354 {
2355 if (! link_info->keep_memory)
6cdc0ccc 2356 free (contents);
252b5132
RH		 2357 else
2358 {
2359 /* Cache the section contents for elf_link_input_bfd. */
2360 elf_section_data (section)->this_hdr.contents = contents;
2361 }
252b5132 2362 }
6cdc0ccc 2363 contents = NULL;
9ad5cbcf
AM		 2364 }
2365
252b5132 2366 /* Cache or free any memory we allocated for the symbols. */
6cdc0ccc
AM		 2367 if (isymbuf != NULL
2368 && symtab_hdr->contents != (unsigned char *) isymbuf)
252b5132
RH		 2369 {
2370 if (! link_info->keep_memory)
6cdc0ccc 2371 free (isymbuf);
252b5132
RH		 2372 else
2373 {
2374 /* Cache the symbols for elf_link_input_bfd. */
6cdc0ccc 2375 symtab_hdr->contents = (unsigned char *) isymbuf;
252b5132 2376 }
252b5132 2377 }
6cdc0ccc 2378 isymbuf = NULL;
252b5132
RH		 2379 }
2380
2381 /* Now iterate on each symbol in the hash table and perform
2382 the final initialization steps on each. */
2383 elf32_mn10300_link_hash_traverse (hash_table,
2384 elf32_mn10300_finish_hash_table_entry,
1055df0f 2385 link_info);
252b5132
RH		 2386 elf32_mn10300_link_hash_traverse (hash_table->static_hash_table,
2387 elf32_mn10300_finish_hash_table_entry,
1055df0f 2388 link_info);
252b5132 2389
eb13e63f
DD		 2390 {
2391 /* This section of code collects all our local symbols, sorts
2392 them by value, and looks for multiple symbols referring to
2393 the same address. For those symbols, the flags are merged.
2394 At this point, the only flag that can be set is
2395 MN10300_CONVERT_CALL_TO_CALLS, so we simply OR the flags
2396 together. */
2397 int static_count = 0, i;
2398 struct elf32_mn10300_link_hash_entry **entries;
2399 struct elf32_mn10300_link_hash_entry **ptr;
2400
2401 elf32_mn10300_link_hash_traverse (hash_table->static_hash_table,
2402 elf32_mn10300_count_hash_table_entries,
2403 &static_count);
2404
603b7257 2405 entries = bfd_malloc (static_count * sizeof (* ptr));
eb13e63f
DD		 2406
2407 ptr = entries;
2408 elf32_mn10300_link_hash_traverse (hash_table->static_hash_table,
2409 elf32_mn10300_list_hash_table_entries,
603b7257 2410 & ptr);
eb13e63f 2411
603b7257 2412 qsort (entries, static_count, sizeof (entries[0]), sort_by_value);
eb13e63f 2413
603b7257 2414 for (i = 0; i < static_count - 1; i++)
eb13e63f
DD		 2415 if (entries[i]->value && entries[i]->value == entries[i+1]->value)
2416 {
2417 int v = entries[i]->flags;
2418 int j;
603b7257
NC		 2419
2420 for (j = i + 1; j < static_count && entries[j]->value == entries[i]->value; j++)
eb13e63f 2421 v |= entries[j]->flags;
603b7257
NC		 2422
2423 for (j = i; j < static_count && entries[j]->value == entries[i]->value; j++)
eb13e63f 2424 entries[j]->flags = v;
603b7257
NC		 2425
2426 i = j - 1;
eb13e63f
DD		 2427 }
2428 }
2429
252b5132
RH		 2430 /* All entries in the hash table are fully initialized. */
2431 hash_table->flags |= MN10300_HASH_ENTRIES_INITIALIZED;
2432
2433 /* Now that everything has been initialized, go through each
2434 code section and delete any prologue insns which will be
2435 redundant because their operations will be performed by
2436 a "call" instruction. */
2437 for (input_bfd = link_info->input_bfds;
2438 input_bfd != NULL;
2439 input_bfd = input_bfd->link_next)
2440 {
9ad5cbcf 2441 /* We're going to need all the local symbols for each bfd. */
252b5132 2442 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
6cdc0ccc 2443 if (symtab_hdr->sh_info != 0)
9ad5cbcf 2444 {
6cdc0ccc
AM		 2445 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
2446 if (isymbuf == NULL)
2447 isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
2448 symtab_hdr->sh_info, 0,
2449 NULL, NULL, NULL);
2450 if (isymbuf == NULL)
9ad5cbcf 2451 goto error_return;
010ac81f 2452 }
252b5132
RH		 2453
2454 /* Walk over each section in this bfd. */
2455 for (section = input_bfd->sections;
2456 section != NULL;
2457 section = section->next)
2458 {
9ad5cbcf 2459 unsigned int sec_shndx;
6cdc0ccc
AM		 2460 Elf_Internal_Sym *isym, *isymend;
2461 struct elf_link_hash_entry **hashes;
2462 struct elf_link_hash_entry **end_hashes;
2463 unsigned int symcount;
252b5132
RH		 2464
2465 /* Skip non-code sections and empty sections. */
eea6121a 2466 if ((section->flags & SEC_CODE) == 0 || section->size == 0)
252b5132
RH		 2467 continue;
2468
2469 if (section->reloc_count != 0)
2470 {
010ac81f 2471 /* Get a copy of the native relocations. */
603b7257
NC		 2472 internal_relocs = _bfd_elf_link_read_relocs (input_bfd, section,
2473 NULL, NULL,
2474 link_info->keep_memory);
010ac81f
KH		 2475 if (internal_relocs == NULL)
2476 goto error_return;
252b5132
RH		 2477 }
2478
2479 /* Get cached copy of section contents if it exists. */
2480 if (elf_section_data (section)->this_hdr.contents != NULL)
2481 contents = elf_section_data (section)->this_hdr.contents;
2482 else
2483 {
2484 /* Go get them off disk. */
eea6121a
AM		 2485 if (!bfd_malloc_and_get_section (input_bfd, section,
2486 &contents))
252b5132
RH		 2487 goto error_return;
2488 }
2489
9ad5cbcf
AM		 2490 sec_shndx = _bfd_elf_section_from_bfd_section (input_bfd,
2491 section);
252b5132
RH		 2492
2493 /* Now look for any function in this section which needs
2494 insns deleted from its prologue. */
6cdc0ccc
AM		 2495 isymend = isymbuf + symtab_hdr->sh_info;
2496 for (isym = isymbuf; isym < isymend; isym++)
252b5132 2497 {
252b5132 2498 struct elf32_mn10300_link_hash_entry *sym_hash;
86033394 2499 asection *sym_sec = NULL;
252b5132 2500 const char *sym_name;
252b5132 2501 char *new_name;
dc810e39
AM		 2502 struct elf_link_hash_table *elftab;
2503 bfd_size_type amt;
252b5132 2504
6cdc0ccc 2505 if (isym->st_shndx != sec_shndx)
252b5132
RH		 2506 continue;
2507
6cdc0ccc 2508 if (isym->st_shndx == SHN_UNDEF)
252b5132 2509 sym_sec = bfd_und_section_ptr;
6cdc0ccc 2510 else if (isym->st_shndx == SHN_ABS)
252b5132 2511 sym_sec = bfd_abs_section_ptr;
6cdc0ccc 2512 else if (isym->st_shndx == SHN_COMMON)
252b5132 2513 sym_sec = bfd_com_section_ptr;
86033394 2514 else
9ad5cbcf 2515 sym_sec
6cdc0ccc 2516 = bfd_section_from_elf_index (input_bfd, isym->st_shndx);
a7c10850 2517
9ad5cbcf
AM		 2518 sym_name
2519 = bfd_elf_string_from_elf_section (input_bfd,
2520 symtab_hdr->sh_link,
6cdc0ccc 2521 isym->st_name);
252b5132
RH		 2522
2523 /* Tack on an ID so we can uniquely identify this
2524 local symbol in the global hash table. */
dc810e39
AM		 2525 amt = strlen (sym_name) + 10;
2526 new_name = bfd_malloc (amt);
bfff1642 2527 if (new_name == NULL)
252b5132 2528 goto error_return;
f60ca5e3 2529 sprintf (new_name, "%s_%08x", sym_name, sym_sec->id);
252b5132
RH		 2530 sym_name = new_name;
2531
603b7257
NC		 2532 elftab = & hash_table->static_hash_table->root;
2533 sym_hash = (struct elf32_mn10300_link_hash_entry *)
2534 elf_link_hash_lookup (elftab, sym_name,
2535 FALSE, FALSE, FALSE);
252b5132
RH		 2536
2537 free (new_name);
2538 if (sym_hash == NULL)
2539 continue;
2540
9ad5cbcf
AM		 2541 if (! (sym_hash->flags & MN10300_CONVERT_CALL_TO_CALLS)
2542 && ! (sym_hash->flags & MN10300_DELETED_PROLOGUE_BYTES))
252b5132
RH		 2543 {
2544 int bytes = 0;
2545
2546 /* Note that we've changed things. */
2547 elf_section_data (section)->relocs = internal_relocs;
252b5132 2548 elf_section_data (section)->this_hdr.contents = contents;
6cdc0ccc 2549 symtab_hdr->contents = (unsigned char *) isymbuf;
252b5132
RH		 2550
2551 /* Count how many bytes we're going to delete. */
2552 if (sym_hash->movm_args)
2553 bytes += 2;
2554
1a101a42
AM		 2555 if (sym_hash->stack_size > 0)
2556 {
2557 if (sym_hash->stack_size <= 128)
2558 bytes += 3;
2559 else
2560 bytes += 4;
2561 }
252b5132
RH		 2562
2563 /* Note that we've deleted prologue bytes for this
2564 function. */
2565 sym_hash->flags |= MN10300_DELETED_PROLOGUE_BYTES;
2566
2567 /* Actually delete the bytes. */
2568 if (!mn10300_elf_relax_delete_bytes (input_bfd,
2569 section,
6cdc0ccc 2570 isym->st_value,
252b5132
RH		 2571 bytes))
2572 goto error_return;
2573
2574 /* Something changed. Not strictly necessary, but
2575 may lead to more relaxing opportunities. */
b34976b6 2576 *again = TRUE;
252b5132
RH		 2577 }
2578 }
2579
2580 /* Look for any global functions in this section which
2581 need insns deleted from their prologues. */
6cdc0ccc 2582 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
9ad5cbcf 2583 - symtab_hdr->sh_info);
709e685d 2584 hashes = elf_sym_hashes (input_bfd);
6cdc0ccc
AM		 2585 end_hashes = hashes + symcount;
2586 for (; hashes < end_hashes; hashes++)
252b5132 2587 {
252b5132
RH		 2588 struct elf32_mn10300_link_hash_entry *sym_hash;
2589
6cdc0ccc 2590 sym_hash = (struct elf32_mn10300_link_hash_entry *) *hashes;
9ad5cbcf
AM		 2591 if ((sym_hash->root.root.type == bfd_link_hash_defined
2592 || sym_hash->root.root.type == bfd_link_hash_defweak)
2593 && sym_hash->root.root.u.def.section == section
2594 && ! (sym_hash->flags & MN10300_CONVERT_CALL_TO_CALLS)
2595 && ! (sym_hash->flags & MN10300_DELETED_PROLOGUE_BYTES))
252b5132
RH		 2596 {
2597 int bytes = 0;
9ad5cbcf 2598 bfd_vma symval;
252b5132
RH		 2599
2600 /* Note that we've changed things. */
2601 elf_section_data (section)->relocs = internal_relocs;
252b5132 2602 elf_section_data (section)->this_hdr.contents = contents;
6cdc0ccc 2603 symtab_hdr->contents = (unsigned char *) isymbuf;
252b5132
RH		 2604
2605 /* Count how many bytes we're going to delete. */
2606 if (sym_hash->movm_args)
2607 bytes += 2;
2608
1a101a42
AM		 2609 if (sym_hash->stack_size > 0)
2610 {
2611 if (sym_hash->stack_size <= 128)
2612 bytes += 3;
2613 else
2614 bytes += 4;
2615 }
252b5132
RH		 2616
2617 /* Note that we've deleted prologue bytes for this
2618 function. */
2619 sym_hash->flags |= MN10300_DELETED_PROLOGUE_BYTES;
2620
2621 /* Actually delete the bytes. */
9ad5cbcf 2622 symval = sym_hash->root.root.u.def.value;
252b5132
RH		 2623 if (!mn10300_elf_relax_delete_bytes (input_bfd,
2624 section,
9ad5cbcf 2625 symval,
252b5132
RH		 2626 bytes))
2627 goto error_return;
2628
2629 /* Something changed. Not strictly necessary, but
2630 may lead to more relaxing opportunities. */
b34976b6 2631 *again = TRUE;
252b5132
RH		 2632 }
2633 }
2634
2635 /* Cache or free any memory we allocated for the relocs. */
6cdc0ccc
AM		 2636 if (internal_relocs != NULL
2637 && elf_section_data (section)->relocs != internal_relocs)
2638 free (internal_relocs);
2639 internal_relocs = NULL;
252b5132
RH		 2640
2641 /* Cache or free any memory we allocated for the contents. */
6cdc0ccc
AM		 2642 if (contents != NULL
2643 && elf_section_data (section)->this_hdr.contents != contents)
252b5132
RH		 2644 {
2645 if (! link_info->keep_memory)
6cdc0ccc 2646 free (contents);
252b5132 2647 else
603b7257
NC		 2648 /* Cache the section contents for elf_link_input_bfd. */
2649 elf_section_data (section)->this_hdr.contents = contents;
252b5132 2650 }
6cdc0ccc 2651 contents = NULL;
9ad5cbcf
AM		 2652 }
2653
252b5132 2654 /* Cache or free any memory we allocated for the symbols. */
6cdc0ccc
AM		 2655 if (isymbuf != NULL
2656 && symtab_hdr->contents != (unsigned char *) isymbuf)
252b5132
RH		 2657 {
2658 if (! link_info->keep_memory)
6cdc0ccc
AM		 2659 free (isymbuf);
2660 else
603b7257
NC		 2661 /* Cache the symbols for elf_link_input_bfd. */
2662 symtab_hdr->contents = (unsigned char *) isymbuf;
252b5132 2663 }
6cdc0ccc 2664 isymbuf = NULL;
252b5132
RH		 2665 }
2666 }
2667
252b5132
RH		 2668 /* (Re)initialize for the basic instruction shortening/relaxing pass. */
2669 contents = NULL;
252b5132 2670 internal_relocs = NULL;
6cdc0ccc
AM		 2671 isymbuf = NULL;
2672 /* For error_return. */
2673 section = sec;
252b5132 2674
1049f94e 2675 /* We don't have to do anything for a relocatable link, if
252b5132
RH		 2676 this section does not have relocs, or if this is not a
2677 code section. */
1049f94e 2678 if (link_info->relocatable
252b5132
RH		 2679 || (sec->flags & SEC_RELOC) == 0
2680 || sec->reloc_count == 0
2681 || (sec->flags & SEC_CODE) == 0)
b34976b6 2682 return TRUE;
252b5132 2683
252b5132
RH		 2684 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2685
2686 /* Get a copy of the native relocations. */
603b7257
NC		 2687 internal_relocs = _bfd_elf_link_read_relocs (abfd, sec, NULL, NULL,
2688 link_info->keep_memory);
252b5132
RH		 2689 if (internal_relocs == NULL)
2690 goto error_return;
252b5132 2691
fc91707c
NC		 2692 /* Scan for worst case alignment gap changes. Note that this logic
2693 is not ideal; what we should do is run this scan for every
2694 opcode/address range and adjust accordingly, but that's
2695 expensive. Worst case is that for an alignment of N bytes, we
2696 move by 2*N-N-1 bytes, assuming we have aligns of 1, 2, 4, 8, etc
2697 all before it. Plus, this still doesn't cover cross-section
2698 jumps with section alignment. */
2699 irelend = internal_relocs + sec->reloc_count;
2700 align_gap_adjustment = 0;
2701 for (irel = internal_relocs; irel < irelend; irel++)
2702 {
2703 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_ALIGN)
2704 {
2705 bfd_vma adj = 1 << irel->r_addend;
2706 bfd_vma aend = irel->r_offset;
2707
2708 aend = BFD_ALIGN (aend, 1 << irel->r_addend);
e23f1610 2709 adj = 2 * adj - adj - 1;
fc91707c
NC		 2710
2711 /* Record the biggest adjustmnet. Skip any alignment at the
2712 end of our section. */
2713 if (align_gap_adjustment < adj
2714 && aend < sec->output_section->vma + sec->output_offset + sec->size)
2715 align_gap_adjustment = adj;
2716 }
2717 }
2718
252b5132
RH		 2719 /* Walk through them looking for relaxing opportunities. */
2720 irelend = internal_relocs + sec->reloc_count;
2721 for (irel = internal_relocs; irel < irelend; irel++)
2722 {
2723 bfd_vma symval;
605d18d4
DD		 2724 bfd_signed_vma jump_offset;
2725 asection *sym_sec = NULL;
252b5132
RH		 2726 struct elf32_mn10300_link_hash_entry *h = NULL;
2727
2728 /* If this isn't something that can be relaxed, then ignore
2729 this reloc. */
2730 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_NONE
2731 || ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_8
2732 || ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_MAX)
2733 continue;
2734
2735 /* Get the section contents if we haven't done so already. */
2736 if (contents == NULL)
2737 {
2738 /* Get cached copy if it exists. */
2739 if (elf_section_data (sec)->this_hdr.contents != NULL)
2740 contents = elf_section_data (sec)->this_hdr.contents;
2741 else
2742 {
2743 /* Go get them off disk. */
eea6121a 2744 if (!bfd_malloc_and_get_section (abfd, sec, &contents))
252b5132
RH		 2745 goto error_return;
2746 }
2747 }
2748
b34976b6 2749 /* Read this BFD's symbols if we haven't done so already. */
6cdc0ccc 2750 if (isymbuf == NULL && symtab_hdr->sh_info != 0)
252b5132 2751 {
6cdc0ccc
AM		 2752 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
2753 if (isymbuf == NULL)
2754 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
2755 symtab_hdr->sh_info, 0,
2756 NULL, NULL, NULL);
2757 if (isymbuf == NULL)
2758 goto error_return;
252b5132
RH		 2759 }
2760
2761 /* Get the value of the symbol referred to by the reloc. */
2762 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
2763 {
6cdc0ccc 2764 Elf_Internal_Sym *isym;
252b5132
RH		 2765 const char *sym_name;
2766 char *new_name;
2767
2768 /* A local symbol. */
6cdc0ccc
AM		 2769 isym = isymbuf + ELF32_R_SYM (irel->r_info);
2770 if (isym->st_shndx == SHN_UNDEF)
252b5132 2771 sym_sec = bfd_und_section_ptr;
6cdc0ccc 2772 else if (isym->st_shndx == SHN_ABS)
252b5132 2773 sym_sec = bfd_abs_section_ptr;
6cdc0ccc 2774 else if (isym->st_shndx == SHN_COMMON)
252b5132 2775 sym_sec = bfd_com_section_ptr;
86033394 2776 else
6cdc0ccc 2777 sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
a7c10850 2778
252b5132
RH		 2779 sym_name = bfd_elf_string_from_elf_section (abfd,
2780 symtab_hdr->sh_link,
6cdc0ccc 2781 isym->st_name);
252b5132 2782
dd90f1b2 2783 if ((sym_sec->flags & SEC_MERGE)
dd90f1b2
DD		 2784 && sym_sec->sec_info_type == ELF_INFO_TYPE_MERGE)
2785 {
2709f570
NC		 2786 symval = isym->st_value;
2787
2788 /* GAS may reduce relocations against symbols in SEC_MERGE
2789 sections to a relocation against the section symbol when
2790 the original addend was zero. When the reloc is against
2791 a section symbol we should include the addend in the
2792 offset passed to _bfd_merged_section_offset, since the
2793 location of interest is the original symbol. On the
2794 other hand, an access to "sym+addend" where "sym" is not
2795 a section symbol should not include the addend; Such an
2796 access is presumed to be an offset from "sym"; The
2797 location of interest is just "sym". */
2798 if (ELF_ST_TYPE (isym->st_info) == STT_SECTION)
2799 symval += irel->r_addend;
2800
281153f3
NC		 2801 symval = _bfd_merged_section_offset (abfd, & sym_sec,
2802 elf_section_data (sym_sec)->sec_info,
2803 symval);
2709f570
NC		 2804
2805 if (ELF_ST_TYPE (isym->st_info) != STT_SECTION)
2806 symval += irel->r_addend;
2807
2808 symval += sym_sec->output_section->vma
2809 + sym_sec->output_offset - irel->r_addend;
dd90f1b2
DD		 2810 }
2811 else
bfff1642
NC		 2812 symval = (isym->st_value
2813 + sym_sec->output_section->vma
2814 + sym_sec->output_offset);
603b7257 2815
252b5132
RH		 2816 /* Tack on an ID so we can uniquely identify this
2817 local symbol in the global hash table. */
dc810e39 2818 new_name = bfd_malloc ((bfd_size_type) strlen (sym_name) + 10);
bfff1642 2819 if (new_name == NULL)
252b5132 2820 goto error_return;
f60ca5e3 2821 sprintf (new_name, "%s_%08x", sym_name, sym_sec->id);
252b5132
RH		 2822 sym_name = new_name;
2823
2824 h = (struct elf32_mn10300_link_hash_entry *)
2825 elf_link_hash_lookup (&hash_table->static_hash_table->root,
b34976b6 2826 sym_name, FALSE, FALSE, FALSE);
252b5132
RH		 2827 free (new_name);
2828 }
2829 else
2830 {
2831 unsigned long indx;
2832
2833 /* An external symbol. */
2834 indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
2835 h = (struct elf32_mn10300_link_hash_entry *)
2836 (elf_sym_hashes (abfd)[indx]);
2837 BFD_ASSERT (h != NULL);
2838 if (h->root.root.type != bfd_link_hash_defined
2839 && h->root.root.type != bfd_link_hash_defweak)
603b7257
NC		 2840 /* This appears to be a reference to an undefined
2841 symbol. Just ignore it--it will be caught by the
2842 regular reloc processing. */
2843 continue;
252b5132 2844
bfff1642
NC		 2845 /* Check for a reference to a discarded symbol and ignore it. */
2846 if (h->root.root.u.def.section->output_section == NULL)
2847 continue;
2848
605d18d4
DD		 2849 sym_sec = h->root.root.u.def.section->output_section;
2850
252b5132
RH		 2851 symval = (h->root.root.u.def.value
2852 + h->root.root.u.def.section->output_section->vma
2853 + h->root.root.u.def.section->output_offset);
2854 }
2855
2856 /* For simplicity of coding, we are going to modify the section
2857 contents, the section relocs, and the BFD symbol table. We
2858 must tell the rest of the code not to free up this
2859 information. It would be possible to instead create a table
2860 of changes which have to be made, as is done in coff-mips.c;
2861 that would be more work, but would require less memory when
2862 the linker is run. */
2863
2864 /* Try to turn a 32bit pc-relative branch/call into a 16bit pc-relative
2865 branch/call, also deal with "call" -> "calls" conversions and
2866 insertion of prologue data into "call" instructions. */
03a12831
AO		 2867 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_PCREL32
2868 || ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_PLT32)
252b5132
RH		 2869 {
2870 bfd_vma value = symval;
2871
03a12831
AO		 2872 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_PLT32
2873 && h != NULL
2874 && ELF_ST_VISIBILITY (h->root.other) != STV_INTERNAL
2875 && ELF_ST_VISIBILITY (h->root.other) != STV_HIDDEN
2876 && h->root.plt.offset != (bfd_vma) -1)
2877 {
2878 asection * splt;
2879
2880 splt = bfd_get_section_by_name (elf_hash_table (link_info)
2881 ->dynobj, ".plt");
3b36f7e6 2882
03a12831
AO		 2883 value = ((splt->output_section->vma
2884 + splt->output_offset
2885 + h->root.plt.offset)
2886 - (sec->output_section->vma
2887 + sec->output_offset
2888 + irel->r_offset));
2889 }
2890
252b5132
RH		 2891 /* If we've got a "call" instruction that needs to be turned
2892 into a "calls" instruction, do so now. It saves a byte. */
2893 if (h && (h->flags & MN10300_CONVERT_CALL_TO_CALLS))
2894 {
2895 unsigned char code;
2896
2897 /* Get the opcode. */
2898 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
2899
2900 /* Make sure we're working with a "call" instruction! */
2901 if (code == 0xdd)
2902 {
2903 /* Note that we've changed the relocs, section contents,
2904 etc. */
2905 elf_section_data (sec)->relocs = internal_relocs;
252b5132 2906 elf_section_data (sec)->this_hdr.contents = contents;
6cdc0ccc 2907 symtab_hdr->contents = (unsigned char *) isymbuf;
252b5132
RH		 2908
2909 /* Fix the opcode. */
2910 bfd_put_8 (abfd, 0xfc, contents + irel->r_offset - 1);
2911 bfd_put_8 (abfd, 0xff, contents + irel->r_offset);
2912
2913 /* Fix irel->r_offset and irel->r_addend. */
2914 irel->r_offset += 1;
2915 irel->r_addend += 1;
2916
2917 /* Delete one byte of data. */
2918 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
2919 irel->r_offset + 3, 1))
2920 goto error_return;
2921
2922 /* That will change things, so, we should relax again.
2923 Note that this is not required, and it may be slow. */
b34976b6 2924 *again = TRUE;
252b5132
RH		 2925 }
2926 }
2927 else if (h)
2928 {
2929 /* We've got a "call" instruction which needs some data
2930 from target function filled in. */
2931 unsigned char code;
2932
2933 /* Get the opcode. */
2934 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
2935
2936 /* Insert data from the target function into the "call"
2937 instruction if needed. */
2938 if (code == 0xdd)
2939 {
2940 bfd_put_8 (abfd, h->movm_args, contents + irel->r_offset + 4);
2941 bfd_put_8 (abfd, h->stack_size + h->movm_stack_size,
2942 contents + irel->r_offset + 5);
2943 }
2944 }
2945
2946 /* Deal with pc-relative gunk. */
2947 value -= (sec->output_section->vma + sec->output_offset);
2948 value -= irel->r_offset;
2949 value += irel->r_addend;
2950
2951 /* See if the value will fit in 16 bits, note the high value is
2952 0x7fff + 2 as the target will be two bytes closer if we are
605d18d4
DD		 2953 able to relax, if it's in the same section. */
2954 if (sec->output_section == sym_sec->output_section)
2955 jump_offset = 0x8001;
2956 else
2957 jump_offset = 0x7fff;
2958
fc91707c
NC		 2959 /* Account for jumps across alignment boundaries using
2960 align_gap_adjustment. */
605d18d4 2961 if ((bfd_signed_vma) value < jump_offset - (bfd_signed_vma) align_gap_adjustment
fc91707c 2962 && ((bfd_signed_vma) value > -0x8000 + (bfd_signed_vma) align_gap_adjustment))
252b5132
RH		 2963 {
2964 unsigned char code;
2965
2966 /* Get the opcode. */
2967 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
2968
2969 if (code != 0xdc && code != 0xdd && code != 0xff)
2970 continue;
2971
2972 /* Note that we've changed the relocs, section contents, etc. */
2973 elf_section_data (sec)->relocs = internal_relocs;
252b5132 2974 elf_section_data (sec)->this_hdr.contents = contents;
6cdc0ccc 2975 symtab_hdr->contents = (unsigned char *) isymbuf;
252b5132
RH		 2976
2977 /* Fix the opcode. */
2978 if (code == 0xdc)
2979 bfd_put_8 (abfd, 0xcc, contents + irel->r_offset - 1);
2980 else if (code == 0xdd)
2981 bfd_put_8 (abfd, 0xcd, contents + irel->r_offset - 1);
2982 else if (code == 0xff)
2983 bfd_put_8 (abfd, 0xfa, contents + irel->r_offset - 2);
2984
2985 /* Fix the relocation's type. */
2986 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
03a12831
AO		 2987 (ELF32_R_TYPE (irel->r_info)
2988 == (int) R_MN10300_PLT32)
2989 ? R_MN10300_PLT16 :
252b5132
RH		 2990 R_MN10300_PCREL16);
2991
2992 /* Delete two bytes of data. */
2993 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
2994 irel->r_offset + 1, 2))
2995 goto error_return;
2996
2997 /* That will change things, so, we should relax again.
2998 Note that this is not required, and it may be slow. */
b34976b6 2999 *again = TRUE;
252b5132
RH		 3000 }
3001 }
3002
3003 /* Try to turn a 16bit pc-relative branch into a 8bit pc-relative
3004 branch. */
3005 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_PCREL16)
3006 {
3007 bfd_vma value = symval;
3008
3009 /* If we've got a "call" instruction that needs to be turned
3010 into a "calls" instruction, do so now. It saves a byte. */
3011 if (h && (h->flags & MN10300_CONVERT_CALL_TO_CALLS))
3012 {
3013 unsigned char code;
3014
3015 /* Get the opcode. */
3016 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
3017
3018 /* Make sure we're working with a "call" instruction! */
3019 if (code == 0xcd)
3020 {
3021 /* Note that we've changed the relocs, section contents,
3022 etc. */
3023 elf_section_data (sec)->relocs = internal_relocs;
252b5132 3024 elf_section_data (sec)->this_hdr.contents = contents;
6cdc0ccc 3025 symtab_hdr->contents = (unsigned char *) isymbuf;
252b5132
RH		 3026
3027 /* Fix the opcode. */
3028 bfd_put_8 (abfd, 0xfa, contents + irel->r_offset - 1);
3029 bfd_put_8 (abfd, 0xff, contents + irel->r_offset);
3030
3031 /* Fix irel->r_offset and irel->r_addend. */
3032 irel->r_offset += 1;
3033 irel->r_addend += 1;
3034
3035 /* Delete one byte of data. */
3036 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
3037 irel->r_offset + 1, 1))
3038 goto error_return;
3039
3040 /* That will change things, so, we should relax again.
3041 Note that this is not required, and it may be slow. */
b34976b6 3042 *again = TRUE;
252b5132
RH		 3043 }
3044 }
3045 else if (h)
3046 {
3047 unsigned char code;
3048
3049 /* Get the opcode. */
3050 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
3051
3052 /* Insert data from the target function into the "call"
3053 instruction if needed. */
3054 if (code == 0xcd)
3055 {
3056 bfd_put_8 (abfd, h->movm_args, contents + irel->r_offset + 2);
3057 bfd_put_8 (abfd, h->stack_size + h->movm_stack_size,
3058 contents + irel->r_offset + 3);
3059 }
3060 }
3061
3062 /* Deal with pc-relative gunk. */
3063 value -= (sec->output_section->vma + sec->output_offset);
3064 value -= irel->r_offset;
3065 value += irel->r_addend;
3066
3067 /* See if the value will fit in 8 bits, note the high value is
3068 0x7f + 1 as the target will be one bytes closer if we are
3069 able to relax. */
010ac81f 3070 if ((long) value < 0x80 && (long) value > -0x80)
252b5132
RH		 3071 {
3072 unsigned char code;
3073
3074 /* Get the opcode. */
3075 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
3076
3077 if (code != 0xcc)
3078 continue;
3079
3080 /* Note that we've changed the relocs, section contents, etc. */
3081 elf_section_data (sec)->relocs = internal_relocs;
252b5132 3082 elf_section_data (sec)->this_hdr.contents = contents;
6cdc0ccc 3083 symtab_hdr->contents = (unsigned char *) isymbuf;
252b5132
RH		 3084
3085 /* Fix the opcode. */
3086 bfd_put_8 (abfd, 0xca, contents + irel->r_offset - 1);
3087
3088 /* Fix the relocation's type. */
3089 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
3090 R_MN10300_PCREL8);
3091
3092 /* Delete one byte of data. */
3093 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
3094 irel->r_offset + 1, 1))
3095 goto error_return;
3096
3097 /* That will change things, so, we should relax again.
3098 Note that this is not required, and it may be slow. */
b34976b6 3099 *again = TRUE;
252b5132
RH		 3100 }
3101 }
3102
3103 /* Try to eliminate an unconditional 8 bit pc-relative branch
3104 which immediately follows a conditional 8 bit pc-relative
3105 branch around the unconditional branch.
3106
3107 original: new:
3108 bCC lab1 bCC' lab2
3109 bra lab2
3110 lab1: lab1:
3111
252b5132
RH		 3112 This happens when the bCC can't reach lab2 at assembly time,
3113 but due to other relaxations it can reach at link time. */
3114 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_PCREL8)
3115 {
3116 Elf_Internal_Rela *nrel;
3117 bfd_vma value = symval;
3118 unsigned char code;
3119
3120 /* Deal with pc-relative gunk. */
3121 value -= (sec->output_section->vma + sec->output_offset);
3122 value -= irel->r_offset;
3123 value += irel->r_addend;
3124
3125 /* Do nothing if this reloc is the last byte in the section. */
eea6121a 3126 if (irel->r_offset == sec->size)
252b5132
RH		 3127 continue;
3128
3129 /* See if the next instruction is an unconditional pc-relative
3130 branch, more often than not this test will fail, so we
3131 test it first to speed things up. */
3132 code = bfd_get_8 (abfd, contents + irel->r_offset + 1);
3133 if (code != 0xca)
3134 continue;
3135
3136 /* Also make sure the next relocation applies to the next
3137 instruction and that it's a pc-relative 8 bit branch. */
3138 nrel = irel + 1;
3139 if (nrel == irelend
3140 || irel->r_offset + 2 != nrel->r_offset
3141 || ELF32_R_TYPE (nrel->r_info) != (int) R_MN10300_PCREL8)
3142 continue;
3143
3144 /* Make sure our destination immediately follows the
3145 unconditional branch. */
3146 if (symval != (sec->output_section->vma + sec->output_offset
3147 + irel->r_offset + 3))
3148 continue;
3149
3150 /* Now make sure we are a conditional branch. This may not
3151 be necessary, but why take the chance.
3152
3153 Note these checks assume that R_MN10300_PCREL8 relocs
3154 only occur on bCC and bCCx insns. If they occured
3155 elsewhere, we'd need to know the start of this insn
3156 for this check to be accurate. */
3157 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
3158 if (code != 0xc0 && code != 0xc1 && code != 0xc2
3159 && code != 0xc3 && code != 0xc4 && code != 0xc5
3160 && code != 0xc6 && code != 0xc7 && code != 0xc8
3161 && code != 0xc9 && code != 0xe8 && code != 0xe9
3162 && code != 0xea && code != 0xeb)
3163 continue;
3164
3165 /* We also have to be sure there is no symbol/label
3166 at the unconditional branch. */
6cdc0ccc
AM		 3167 if (mn10300_elf_symbol_address_p (abfd, sec, isymbuf,
3168 irel->r_offset + 1))
252b5132
RH		 3169 continue;
3170
3171 /* Note that we've changed the relocs, section contents, etc. */
3172 elf_section_data (sec)->relocs = internal_relocs;
252b5132 3173 elf_section_data (sec)->this_hdr.contents = contents;
6cdc0ccc 3174 symtab_hdr->contents = (unsigned char *) isymbuf;
252b5132
RH		 3175
3176 /* Reverse the condition of the first branch. */
3177 switch (code)
3178 {
010ac81f
KH		 3179 case 0xc8:
3180 code = 0xc9;
3181 break;
3182 case 0xc9:
3183 code = 0xc8;
3184 break;
3185 case 0xc0:
3186 code = 0xc2;
3187 break;
3188 case 0xc2:
3189 code = 0xc0;
3190 break;
3191 case 0xc3:
3192 code = 0xc1;
3193 break;
3194 case 0xc1:
3195 code = 0xc3;
3196 break;
3197 case 0xc4:
3198 code = 0xc6;
3199 break;
3200 case 0xc6:
3201 code = 0xc4;
3202 break;
3203 case 0xc7:
3204 code = 0xc5;
3205 break;
3206 case 0xc5:
3207 code = 0xc7;
3208 break;
3209 case 0xe8:
3210 code = 0xe9;
3211 break;
3212 case 0x9d:
3213 code = 0xe8;
3214 break;
3215 case 0xea:
3216 code = 0xeb;
3217 break;
3218 case 0xeb:
3219 code = 0xea;
3220 break;
252b5132
RH		 3221 }
3222 bfd_put_8 (abfd, code, contents + irel->r_offset - 1);
3223
3224 /* Set the reloc type and symbol for the first branch
3225 from the second branch. */
3226 irel->r_info = nrel->r_info;
3227
3228 /* Make the reloc for the second branch a null reloc. */
3229 nrel->r_info = ELF32_R_INFO (ELF32_R_SYM (nrel->r_info),
3230 R_MN10300_NONE);
3231
3232 /* Delete two bytes of data. */
3233 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
3234 irel->r_offset + 1, 2))
3235 goto error_return;
3236
3237 /* That will change things, so, we should relax again.
3238 Note that this is not required, and it may be slow. */
b34976b6 3239 *again = TRUE;
252b5132
RH		 3240 }
3241
31f8dc8f
JL		 3242 /* Try to turn a 24 immediate, displacement or absolute address
3243 into a 8 immediate, displacement or absolute address. */
3244 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_24)
3245 {
3246 bfd_vma value = symval;
3247 value += irel->r_addend;
3248
3249 /* See if the value will fit in 8 bits. */
010ac81f 3250 if ((long) value < 0x7f && (long) value > -0x80)
31f8dc8f
JL		 3251 {
3252 unsigned char code;
3253
3254 /* AM33 insns which have 24 operands are 6 bytes long and
3255 will have 0xfd as the first byte. */
3256
3257 /* Get the first opcode. */
3258 code = bfd_get_8 (abfd, contents + irel->r_offset - 3);
3259
3260 if (code == 0xfd)
3261 {
010ac81f
KH		 3262 /* Get the second opcode. */
3263 code = bfd_get_8 (abfd, contents + irel->r_offset - 2);
31f8dc8f
JL		 3264
3265 /* We can not relax 0x6b, 0x7b, 0x8b, 0x9b as no 24bit
3266 equivalent instructions exists. */
3b36f7e6 3267 if (code != 0x6b && code != 0x7b
31f8dc8f
JL		 3268 && code != 0x8b && code != 0x9b
3269 && ((code & 0x0f) == 0x09 || (code & 0x0f) == 0x08
3270 || (code & 0x0f) == 0x0a || (code & 0x0f) == 0x0b
3271 || (code & 0x0f) == 0x0e))
3272 {
3273 /* Not safe if the high bit is on as relaxing may
3b36f7e6
AM		 3274 move the value out of high mem and thus not fit
3275 in a signed 8bit value. This is currently over
3276 conservative. */
31f8dc8f
JL		 3277 if ((value & 0x80) == 0)
3278 {
3279 /* Note that we've changed the relocation contents,
3280 etc. */
3281 elf_section_data (sec)->relocs = internal_relocs;
31f8dc8f 3282 elf_section_data (sec)->this_hdr.contents = contents;
6cdc0ccc 3283 symtab_hdr->contents = (unsigned char *) isymbuf;
31f8dc8f
JL		 3284
3285 /* Fix the opcode. */
3286 bfd_put_8 (abfd, 0xfb, contents + irel->r_offset - 3);
3287 bfd_put_8 (abfd, code, contents + irel->r_offset - 2);
3288
3289 /* Fix the relocation's type. */
010ac81f
KH		 3290 irel->r_info =
3291 ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
3292 R_MN10300_8);
31f8dc8f
JL		 3293
3294 /* Delete two bytes of data. */
3295 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
3296 irel->r_offset + 1, 2))
3297 goto error_return;
3298
3299 /* That will change things, so, we should relax
3300 again. Note that this is not required, and it
010ac81f 3301 may be slow. */
b34976b6 3302 *again = TRUE;
31f8dc8f
JL		 3303 break;
3304 }
3305 }
31f8dc8f
JL		 3306 }
3307 }
3308 }
252b5132
RH		 3309
3310 /* Try to turn a 32bit immediate, displacement or absolute address
3311 into a 16bit immediate, displacement or absolute address. */
03a12831
AO		 3312 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_32
3313 || ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_GOT32
eb13e63f 3314 || ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_GOTOFF32)
252b5132
RH		 3315 {
3316 bfd_vma value = symval;
03a12831
AO		 3317
3318 if (ELF32_R_TYPE (irel->r_info) != (int) R_MN10300_32)
3319 {
3320 asection * sgot;
3321
3322 sgot = bfd_get_section_by_name (elf_hash_table (link_info)
3323 ->dynobj, ".got");
3324
3325 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_GOT32)
3326 {
3327 value = sgot->output_offset;
3328
3329 if (h)
3330 value += h->root.got.offset;
3331 else
3332 value += (elf_local_got_offsets
3333 (abfd)[ELF32_R_SYM (irel->r_info)]);
3334 }
3335 else if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_GOTOFF32)
3336 value -= sgot->output_section->vma;
3337 else if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_GOTPC32)
3338 value = (sgot->output_section->vma
3339 - (sec->output_section->vma
3340 + sec->output_offset
3341 + irel->r_offset));
3342 else
3343 abort ();
3344 }
3345
252b5132
RH		 3346 value += irel->r_addend;
3347
31f8dc8f
JL		 3348 /* See if the value will fit in 24 bits.
3349 We allow any 16bit match here. We prune those we can't
3350 handle below. */
010ac81f 3351 if ((long) value < 0x7fffff && (long) value > -0x800000)
31f8dc8f
JL		 3352 {
3353 unsigned char code;
3354
3355 /* AM33 insns which have 32bit operands are 7 bytes long and
3356 will have 0xfe as the first byte. */
3357
3358 /* Get the first opcode. */
3359 code = bfd_get_8 (abfd, contents + irel->r_offset - 3);
3360
3361 if (code == 0xfe)
3362 {
3b36f7e6
AM		 3363 /* Get the second opcode. */
3364 code = bfd_get_8 (abfd, contents + irel->r_offset - 2);
31f8dc8f
JL		 3365
3366 /* All the am33 32 -> 24 relaxing possibilities. */
3367 /* We can not relax 0x6b, 0x7b, 0x8b, 0x9b as no 24bit
3368 equivalent instructions exists. */
010ac81f 3369 if (code != 0x6b && code != 0x7b
31f8dc8f 3370 && code != 0x8b && code != 0x9b
03a12831
AO		 3371 && (ELF32_R_TYPE (irel->r_info)
3372 != (int) R_MN10300_GOTPC32)
31f8dc8f
JL		 3373 && ((code & 0x0f) == 0x09 || (code & 0x0f) == 0x08
3374 || (code & 0x0f) == 0x0a || (code & 0x0f) == 0x0b
3375 || (code & 0x0f) == 0x0e))
3376 {
3377 /* Not safe if the high bit is on as relaxing may
3b36f7e6
AM		 3378 move the value out of high mem and thus not fit
3379 in a signed 16bit value. This is currently over
3380 conservative. */
31f8dc8f
JL		 3381 if ((value & 0x8000) == 0)
3382 {
3383 /* Note that we've changed the relocation contents,
3384 etc. */
3385 elf_section_data (sec)->relocs = internal_relocs;
31f8dc8f 3386 elf_section_data (sec)->this_hdr.contents = contents;
6cdc0ccc 3387 symtab_hdr->contents = (unsigned char *) isymbuf;
31f8dc8f
JL		 3388
3389 /* Fix the opcode. */
3390 bfd_put_8 (abfd, 0xfd, contents + irel->r_offset - 3);
3391 bfd_put_8 (abfd, code, contents + irel->r_offset - 2);
3392
3393 /* Fix the relocation's type. */
010ac81f
KH		 3394 irel->r_info =
3395 ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
03a12831
AO		 3396 (ELF32_R_TYPE (irel->r_info)
3397 == (int) R_MN10300_GOTOFF32)
3398 ? R_MN10300_GOTOFF24
3399 : (ELF32_R_TYPE (irel->r_info)
3400 == (int) R_MN10300_GOT32)
3401 ? R_MN10300_GOT24 :
010ac81f 3402 R_MN10300_24);
31f8dc8f
JL		 3403
3404 /* Delete one byte of data. */
3405 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
3406 irel->r_offset + 3, 1))
3407 goto error_return;
3408
3409 /* That will change things, so, we should relax
3410 again. Note that this is not required, and it
010ac81f 3411 may be slow. */
b34976b6 3412 *again = TRUE;
31f8dc8f
JL		 3413 break;
3414 }
3415 }
31f8dc8f
JL		 3416 }
3417 }
252b5132
RH		 3418
3419 /* See if the value will fit in 16 bits.
3420 We allow any 16bit match here. We prune those we can't
3421 handle below. */
010ac81f 3422 if ((long) value < 0x7fff && (long) value > -0x8000)
252b5132
RH		 3423 {
3424 unsigned char code;
3425
3426 /* Most insns which have 32bit operands are 6 bytes long;
3427 exceptions are pcrel insns and bit insns.
3428
3429 We handle pcrel insns above. We don't bother trying
3430 to handle the bit insns here.
3431
3432 The first byte of the remaining insns will be 0xfc. */
3433
3434 /* Get the first opcode. */
3435 code = bfd_get_8 (abfd, contents + irel->r_offset - 2);
3436
3437 if (code != 0xfc)
3438 continue;
3439
3440 /* Get the second opcode. */
3441 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
3442
3443 if ((code & 0xf0) < 0x80)
3444 switch (code & 0xf0)
3445 {
3446 /* mov (d32,am),dn -> mov (d32,am),dn
3447 mov dm,(d32,am) -> mov dn,(d32,am)
3448 mov (d32,am),an -> mov (d32,am),an
3449 mov dm,(d32,am) -> mov dn,(d32,am)
3450 movbu (d32,am),dn -> movbu (d32,am),dn
3451 movbu dm,(d32,am) -> movbu dn,(d32,am)
3452 movhu (d32,am),dn -> movhu (d32,am),dn
3453 movhu dm,(d32,am) -> movhu dn,(d32,am) */
3454 case 0x00:
3455 case 0x10:
3456 case 0x20:
3457 case 0x30:
3458 case 0x40:
3459 case 0x50:
3460 case 0x60:
3461 case 0x70:
3462 /* Not safe if the high bit is on as relaxing may
3463 move the value out of high mem and thus not fit
3464 in a signed 16bit value. */
3465 if (code == 0xcc
3466 && (value & 0x8000))
3467 continue;
3468
3469 /* Note that we've changed the relocation contents, etc. */
3470 elf_section_data (sec)->relocs = internal_relocs;
252b5132 3471 elf_section_data (sec)->this_hdr.contents = contents;
6cdc0ccc 3472 symtab_hdr->contents = (unsigned char *) isymbuf;
252b5132
RH		 3473
3474 /* Fix the opcode. */
3475 bfd_put_8 (abfd, 0xfa, contents + irel->r_offset - 2);
3476 bfd_put_8 (abfd, code, contents + irel->r_offset - 1);
3477
3478 /* Fix the relocation's type. */
3479 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
03a12831
AO		 3480 (ELF32_R_TYPE (irel->r_info)
3481 == (int) R_MN10300_GOTOFF32)
3482 ? R_MN10300_GOTOFF16
3483 : (ELF32_R_TYPE (irel->r_info)
3484 == (int) R_MN10300_GOT32)
3485 ? R_MN10300_GOT16
3486 : (ELF32_R_TYPE (irel->r_info)
3487 == (int) R_MN10300_GOTPC32)
3488 ? R_MN10300_GOTPC16 :
252b5132
RH		 3489 R_MN10300_16);
3490
3491 /* Delete two bytes of data. */
3492 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
3493 irel->r_offset + 2, 2))
3494 goto error_return;
3495
3496 /* That will change things, so, we should relax again.
3497 Note that this is not required, and it may be slow. */
b34976b6 3498 *again = TRUE;
252b5132
RH		 3499 break;
3500 }
3501 else if ((code & 0xf0) == 0x80
3502 || (code & 0xf0) == 0x90)
3503 switch (code & 0xf3)
3504 {
3505 /* mov dn,(abs32) -> mov dn,(abs16)
3506 movbu dn,(abs32) -> movbu dn,(abs16)
3507 movhu dn,(abs32) -> movhu dn,(abs16) */
3508 case 0x81:
3509 case 0x82:
3510 case 0x83:
3511 /* Note that we've changed the relocation contents, etc. */
3512 elf_section_data (sec)->relocs = internal_relocs;
252b5132 3513 elf_section_data (sec)->this_hdr.contents = contents;
6cdc0ccc 3514 symtab_hdr->contents = (unsigned char *) isymbuf;
252b5132
RH		 3515
3516 if ((code & 0xf3) == 0x81)
3517 code = 0x01 + (code & 0x0c);
3518 else if ((code & 0xf3) == 0x82)
3519 code = 0x02 + (code & 0x0c);
3520 else if ((code & 0xf3) == 0x83)
3521 code = 0x03 + (code & 0x0c);
3522 else
3523 abort ();
3524
3525 /* Fix the opcode. */
3526 bfd_put_8 (abfd, code, contents + irel->r_offset - 2);
3527
3528 /* Fix the relocation's type. */
3529 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
03a12831
AO		 3530 (ELF32_R_TYPE (irel->r_info)
3531 == (int) R_MN10300_GOTOFF32)
3532 ? R_MN10300_GOTOFF16
3533 : (ELF32_R_TYPE (irel->r_info)
3534 == (int) R_MN10300_GOT32)
3535 ? R_MN10300_GOT16
3536 : (ELF32_R_TYPE (irel->r_info)
3537 == (int) R_MN10300_GOTPC32)
3538 ? R_MN10300_GOTPC16 :
252b5132
RH		 3539 R_MN10300_16);
3540
3541 /* The opcode got shorter too, so we have to fix the
3542 addend and offset too! */
3543 irel->r_offset -= 1;
3544
3545 /* Delete three bytes of data. */
3546 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
3547 irel->r_offset + 1, 3))
3548 goto error_return;
3549
3550 /* That will change things, so, we should relax again.
3551 Note that this is not required, and it may be slow. */
b34976b6 3552 *again = TRUE;
252b5132
RH		 3553 break;
3554
3555 /* mov am,(abs32) -> mov am,(abs16)
3556 mov am,(d32,sp) -> mov am,(d16,sp)
3557 mov dm,(d32,sp) -> mov dm,(d32,sp)
3558 movbu dm,(d32,sp) -> movbu dm,(d32,sp)
3559 movhu dm,(d32,sp) -> movhu dm,(d32,sp) */
3560 case 0x80:
3561 case 0x90:
3562 case 0x91:
3563 case 0x92:
3564 case 0x93:
2a0fa943
AO		 3565 /* sp-based offsets are zero-extended. */
3566 if (code >= 0x90 && code <= 0x93
bfff1642 3567 && (long) value < 0)
2a0fa943
AO		 3568 continue;
3569
252b5132
RH		 3570 /* Note that we've changed the relocation contents, etc. */
3571 elf_section_data (sec)->relocs = internal_relocs;
252b5132 3572 elf_section_data (sec)->this_hdr.contents = contents;
6cdc0ccc 3573 symtab_hdr->contents = (unsigned char *) isymbuf;
252b5132
RH		 3574
3575 /* Fix the opcode. */
3576 bfd_put_8 (abfd, 0xfa, contents + irel->r_offset - 2);
3577 bfd_put_8 (abfd, code, contents + irel->r_offset - 1);
3578
3579 /* Fix the relocation's type. */
3580 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
03a12831
AO		 3581 (ELF32_R_TYPE (irel->r_info)
3582 == (int) R_MN10300_GOTOFF32)
3583 ? R_MN10300_GOTOFF16
3584 : (ELF32_R_TYPE (irel->r_info)
3585 == (int) R_MN10300_GOT32)
3586 ? R_MN10300_GOT16
3587 : (ELF32_R_TYPE (irel->r_info)
3588 == (int) R_MN10300_GOTPC32)
3589 ? R_MN10300_GOTPC16 :
252b5132
RH		 3590 R_MN10300_16);
3591
3592 /* Delete two bytes of data. */
3593 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
3594 irel->r_offset + 2, 2))
3595 goto error_return;
3596
3597 /* That will change things, so, we should relax again.
3598 Note that this is not required, and it may be slow. */
b34976b6 3599 *again = TRUE;
252b5132
RH		 3600 break;
3601 }
3602 else if ((code & 0xf0) < 0xf0)
3603 switch (code & 0xfc)
3604 {
3605 /* mov imm32,dn -> mov imm16,dn
3606 mov imm32,an -> mov imm16,an
3607 mov (abs32),dn -> mov (abs16),dn
3608 movbu (abs32),dn -> movbu (abs16),dn
3609 movhu (abs32),dn -> movhu (abs16),dn */
3610 case 0xcc:
3611 case 0xdc:
3612 case 0xa4:
3613 case 0xa8:
3614 case 0xac:
3615 /* Not safe if the high bit is on as relaxing may
3616 move the value out of high mem and thus not fit
3617 in a signed 16bit value. */
3618 if (code == 0xcc
3619 && (value & 0x8000))
3620 continue;
3621
2a0fa943
AO		 3622 /* mov imm16, an zero-extends the immediate. */
3623 if (code == 0xdc
bfff1642 3624 && (long) value < 0)
2a0fa943
AO		 3625 continue;
3626
252b5132
RH		 3627 /* Note that we've changed the relocation contents, etc. */
3628 elf_section_data (sec)->relocs = internal_relocs;
252b5132 3629 elf_section_data (sec)->this_hdr.contents = contents;
6cdc0ccc 3630 symtab_hdr->contents = (unsigned char *) isymbuf;
252b5132
RH		 3631
3632 if ((code & 0xfc) == 0xcc)
3633 code = 0x2c + (code & 0x03);
3634 else if ((code & 0xfc) == 0xdc)
3635 code = 0x24 + (code & 0x03);
3636 else if ((code & 0xfc) == 0xa4)
3637 code = 0x30 + (code & 0x03);
3638 else if ((code & 0xfc) == 0xa8)
3639 code = 0x34 + (code & 0x03);
3640 else if ((code & 0xfc) == 0xac)
3641 code = 0x38 + (code & 0x03);
3642 else
3643 abort ();
3644
3645 /* Fix the opcode. */
3646 bfd_put_8 (abfd, code, contents + irel->r_offset - 2);
3647
3648 /* Fix the relocation's type. */
3649 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
03a12831
AO		 3650 (ELF32_R_TYPE (irel->r_info)
3651 == (int) R_MN10300_GOTOFF32)
3652 ? R_MN10300_GOTOFF16
3653 : (ELF32_R_TYPE (irel->r_info)
3654 == (int) R_MN10300_GOT32)
3655 ? R_MN10300_GOT16
3656 : (ELF32_R_TYPE (irel->r_info)
3657 == (int) R_MN10300_GOTPC32)
3658 ? R_MN10300_GOTPC16 :
252b5132
RH		 3659 R_MN10300_16);
3660
3661 /* The opcode got shorter too, so we have to fix the
3662 addend and offset too! */
3663 irel->r_offset -= 1;
3664
3665 /* Delete three bytes of data. */
3666 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
3667 irel->r_offset + 1, 3))
3668 goto error_return;
3669
3670 /* That will change things, so, we should relax again.
3671 Note that this is not required, and it may be slow. */
b34976b6 3672 *again = TRUE;
252b5132
RH		 3673 break;
3674
3675 /* mov (abs32),an -> mov (abs16),an
2a0fa943
AO		 3676 mov (d32,sp),an -> mov (d16,sp),an
3677 mov (d32,sp),dn -> mov (d16,sp),dn
3678 movbu (d32,sp),dn -> movbu (d16,sp),dn
3679 movhu (d32,sp),dn -> movhu (d16,sp),dn
252b5132
RH		 3680 add imm32,dn -> add imm16,dn
3681 cmp imm32,dn -> cmp imm16,dn
3682 add imm32,an -> add imm16,an
3683 cmp imm32,an -> cmp imm16,an
2a0fa943
AO		 3684 and imm32,dn -> and imm16,dn
3685 or imm32,dn -> or imm16,dn
3686 xor imm32,dn -> xor imm16,dn
3687 btst imm32,dn -> btst imm16,dn */
252b5132
RH		 3688
3689 case 0xa0:
3690 case 0xb0:
3691 case 0xb1:
3692 case 0xb2:
3693 case 0xb3:
3694 case 0xc0:
3695 case 0xc8:
3696
3697 case 0xd0:
3698 case 0xd8:
3699 case 0xe0:
3700 case 0xe1:
3701 case 0xe2:
3702 case 0xe3:
2a0fa943
AO		 3703 /* cmp imm16, an zero-extends the immediate. */
3704 if (code == 0xdc
bfff1642 3705 && (long) value < 0)
2a0fa943
AO		 3706 continue;
3707
3708 /* So do sp-based offsets. */
3709 if (code >= 0xb0 && code <= 0xb3
bfff1642 3710 && (long) value < 0)
2a0fa943
AO		 3711 continue;
3712
252b5132
RH		 3713 /* Note that we've changed the relocation contents, etc. */
3714 elf_section_data (sec)->relocs = internal_relocs;
252b5132 3715 elf_section_data (sec)->this_hdr.contents = contents;
6cdc0ccc 3716 symtab_hdr->contents = (unsigned char *) isymbuf;
252b5132
RH		 3717
3718 /* Fix the opcode. */
3719 bfd_put_8 (abfd, 0xfa, contents + irel->r_offset - 2);
3720 bfd_put_8 (abfd, code, contents + irel->r_offset - 1);
3721
3722 /* Fix the relocation's type. */
3723 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
03a12831
AO		 3724 (ELF32_R_TYPE (irel->r_info)
3725 == (int) R_MN10300_GOTOFF32)
3726 ? R_MN10300_GOTOFF16
3727 : (ELF32_R_TYPE (irel->r_info)
3728 == (int) R_MN10300_GOT32)
3729 ? R_MN10300_GOT16
3730 : (ELF32_R_TYPE (irel->r_info)
3731 == (int) R_MN10300_GOTPC32)
3732 ? R_MN10300_GOTPC16 :
252b5132
RH		 3733 R_MN10300_16);
3734
3735 /* Delete two bytes of data. */
3736 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
3737 irel->r_offset + 2, 2))
3738 goto error_return;
3739
3740 /* That will change things, so, we should relax again.
3741 Note that this is not required, and it may be slow. */
b34976b6 3742 *again = TRUE;
252b5132
RH		 3743 break;
3744 }
3745 else if (code == 0xfe)
3746 {
3747 /* add imm32,sp -> add imm16,sp */
3748
3749 /* Note that we've changed the relocation contents, etc. */
3750 elf_section_data (sec)->relocs = internal_relocs;
252b5132 3751 elf_section_data (sec)->this_hdr.contents = contents;
6cdc0ccc 3752 symtab_hdr->contents = (unsigned char *) isymbuf;
252b5132
RH		 3753
3754 /* Fix the opcode. */
3755 bfd_put_8 (abfd, 0xfa, contents + irel->r_offset - 2);
3756 bfd_put_8 (abfd, 0xfe, contents + irel->r_offset - 1);
3757
3758 /* Fix the relocation's type. */
3759 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
03a12831
AO		 3760 (ELF32_R_TYPE (irel->r_info)
3761 == (int) R_MN10300_GOT32)
3762 ? R_MN10300_GOT16
3763 : (ELF32_R_TYPE (irel->r_info)
3764 == (int) R_MN10300_GOTOFF32)
3765 ? R_MN10300_GOTOFF16
3766 : (ELF32_R_TYPE (irel->r_info)
3767 == (int) R_MN10300_GOTPC32)
3768 ? R_MN10300_GOTPC16 :
010ac81f 3769 R_MN10300_16);
252b5132
RH		 3770
3771 /* Delete two bytes of data. */
3772 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
3773 irel->r_offset + 2, 2))
3774 goto error_return;
3775
3776 /* That will change things, so, we should relax again.
3777 Note that this is not required, and it may be slow. */
b34976b6 3778 *again = TRUE;
252b5132
RH		 3779 break;
3780 }
3781 }
3782 }
3783 }
3784
6cdc0ccc
AM		 3785 if (isymbuf != NULL
3786 && symtab_hdr->contents != (unsigned char *) isymbuf)
252b5132
RH		 3787 {
3788 if (! link_info->keep_memory)
6cdc0ccc 3789 free (isymbuf);
252b5132
RH		 3790 else
3791 {
6cdc0ccc
AM		 3792 /* Cache the symbols for elf_link_input_bfd. */
3793 symtab_hdr->contents = (unsigned char *) isymbuf;
252b5132 3794 }
9ad5cbcf
AM		 3795 }
3796
6cdc0ccc
AM		 3797 if (contents != NULL
3798 && elf_section_data (sec)->this_hdr.contents != contents)
252b5132
RH		 3799 {
3800 if (! link_info->keep_memory)
6cdc0ccc
AM		 3801 free (contents);
3802 else
252b5132 3803 {
6cdc0ccc
AM		 3804 /* Cache the section contents for elf_link_input_bfd. */
3805 elf_section_data (sec)->this_hdr.contents = contents;
252b5132 3806 }
252b5132
RH		 3807 }
3808
6cdc0ccc
AM		 3809 if (internal_relocs != NULL
3810 && elf_section_data (sec)->relocs != internal_relocs)
3811 free (internal_relocs);
3812
b34976b6 3813 return TRUE;
252b5132
RH		 3814
3815 error_return:
6cdc0ccc
AM		 3816 if (isymbuf != NULL
3817 && symtab_hdr->contents != (unsigned char *) isymbuf)
3818 free (isymbuf);
3819 if (contents != NULL
3820 && elf_section_data (section)->this_hdr.contents != contents)
3821 free (contents);
3822 if (internal_relocs != NULL
3823 && elf_section_data (section)->relocs != internal_relocs)
3824 free (internal_relocs);
9ad5cbcf 3825
b34976b6 3826 return FALSE;
252b5132
RH		 3827}
3828
252b5132
RH		 3829/* This is a version of bfd_generic_get_relocated_section_contents
3830 which uses mn10300_elf_relocate_section. */
3831
3832static bfd_byte *
603b7257
NC		 3833mn10300_elf_get_relocated_section_contents (bfd *output_bfd,
3834 struct bfd_link_info *link_info,
3835 struct bfd_link_order *link_order,
3836 bfd_byte *data,
3837 bfd_boolean relocatable,
3838 asymbol **symbols)
252b5132
RH		 3839{
3840 Elf_Internal_Shdr *symtab_hdr;
3841 asection *input_section = link_order->u.indirect.section;
3842 bfd *input_bfd = input_section->owner;
3843 asection **sections = NULL;
3844 Elf_Internal_Rela *internal_relocs = NULL;
6cdc0ccc 3845 Elf_Internal_Sym *isymbuf = NULL;
252b5132
RH		 3846
3847 /* We only need to handle the case of relaxing, or of having a
3848 particular set of section contents, specially. */
1049f94e 3849 if (relocatable
252b5132
RH		 3850 || elf_section_data (input_section)->this_hdr.contents == NULL)
3851 return bfd_generic_get_relocated_section_contents (output_bfd, link_info,
3852 link_order, data,
1049f94e 3853 relocatable,
252b5132
RH		 3854 symbols);
3855
3856 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
3857
3858 memcpy (data, elf_section_data (input_section)->this_hdr.contents,
eea6121a 3859 (size_t) input_section->size);
252b5132
RH		 3860
3861 if ((input_section->flags & SEC_RELOC) != 0
3862 && input_section->reloc_count > 0)
3863 {
252b5132 3864 asection **secpp;
6cdc0ccc 3865 Elf_Internal_Sym *isym, *isymend;
9ad5cbcf 3866 bfd_size_type amt;
252b5132 3867
603b7257
NC		 3868 internal_relocs = _bfd_elf_link_read_relocs (input_bfd, input_section,
3869 NULL, NULL, FALSE);
252b5132
RH		 3870 if (internal_relocs == NULL)
3871 goto error_return;
3872
6cdc0ccc
AM		 3873 if (symtab_hdr->sh_info != 0)
3874 {
3875 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
3876 if (isymbuf == NULL)
3877 isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
3878 symtab_hdr->sh_info, 0,
3879 NULL, NULL, NULL);
3880 if (isymbuf == NULL)
3881 goto error_return;
3882 }
252b5132 3883
9ad5cbcf
AM		 3884 amt = symtab_hdr->sh_info;
3885 amt *= sizeof (asection *);
603b7257 3886 sections = bfd_malloc (amt);
9ad5cbcf 3887 if (sections == NULL && amt != 0)
252b5132
RH		 3888 goto error_return;
3889
6cdc0ccc
AM		 3890 isymend = isymbuf + symtab_hdr->sh_info;
3891 for (isym = isymbuf, secpp = sections; isym < isymend; ++isym, ++secpp)
252b5132
RH		 3892 {
3893 asection *isec;
3894
6cdc0ccc 3895 if (isym->st_shndx == SHN_UNDEF)
252b5132 3896 isec = bfd_und_section_ptr;
6cdc0ccc 3897 else if (isym->st_shndx == SHN_ABS)
252b5132 3898 isec = bfd_abs_section_ptr;
6cdc0ccc 3899 else if (isym->st_shndx == SHN_COMMON)
252b5132
RH		 3900 isec = bfd_com_section_ptr;
3901 else
6cdc0ccc 3902 isec = bfd_section_from_elf_index (input_bfd, isym->st_shndx);
252b5132
RH		 3903
3904 *secpp = isec;
3905 }
3906
3907 if (! mn10300_elf_relocate_section (output_bfd, link_info, input_bfd,
603b7257
NC		 3908 input_section, data, internal_relocs,
3909 isymbuf, sections))
252b5132
RH		 3910 goto error_return;
3911
3912 if (sections != NULL)
3913 free (sections);
6cdc0ccc
AM		 3914 if (isymbuf != NULL && symtab_hdr->contents != (unsigned char *) isymbuf)
3915 free (isymbuf);
252b5132
RH		 3916 if (internal_relocs != elf_section_data (input_section)->relocs)
3917 free (internal_relocs);
252b5132
RH		 3918 }
3919
3920 return data;
3921
3922 error_return:
6cdc0ccc
AM		 3923 if (sections != NULL)
3924 free (sections);
3925 if (isymbuf != NULL && symtab_hdr->contents != (unsigned char *) isymbuf)
3926 free (isymbuf);
252b5132
RH		 3927 if (internal_relocs != NULL
3928 && internal_relocs != elf_section_data (input_section)->relocs)
3929 free (internal_relocs);
252b5132
RH		 3930 return NULL;
3931}
3932
3933/* Assorted hash table functions. */
3934
3935/* Initialize an entry in the link hash table. */
3936
3937/* Create an entry in an MN10300 ELF linker hash table. */
3938
3939static struct bfd_hash_entry *
603b7257
NC		 3940elf32_mn10300_link_hash_newfunc (struct bfd_hash_entry *entry,
3941 struct bfd_hash_table *table,
3942 const char *string)
252b5132
RH		 3943{
3944 struct elf32_mn10300_link_hash_entry *ret =
3945 (struct elf32_mn10300_link_hash_entry *) entry;
3946
3947 /* Allocate the structure if it has not already been allocated by a
3948 subclass. */
603b7257
NC		 3949 if (ret == NULL)
3950 ret = (struct elf32_mn10300_link_hash_entry *)
3951 bfd_hash_allocate (table, sizeof (* ret));
3952 if (ret == NULL)
252b5132
RH		 3953 return (struct bfd_hash_entry *) ret;
3954
3955 /* Call the allocation method of the superclass. */
603b7257 3956 ret = (struct elf32_mn10300_link_hash_entry *)
252b5132 3957 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
603b7257
NC		 3958 table, string);
3959 if (ret != NULL)
252b5132
RH		 3960 {
3961 ret->direct_calls = 0;
3962 ret->stack_size = 0;
5354b572 3963 ret->movm_args = 0;
252b5132
RH		 3964 ret->movm_stack_size = 0;
3965 ret->flags = 0;
eb13e63f 3966 ret->value = 0;
252b5132
RH		 3967 }
3968
3969 return (struct bfd_hash_entry *) ret;
3970}
3971
3972/* Create an mn10300 ELF linker hash table. */
3973
3974static struct bfd_link_hash_table *
603b7257 3975elf32_mn10300_link_hash_table_create (bfd *abfd)
252b5132
RH		 3976{
3977 struct elf32_mn10300_link_hash_table *ret;
603b7257 3978 bfd_size_type amt = sizeof (* ret);
252b5132 3979
603b7257
NC		 3980 ret = bfd_malloc (amt);
3981 if (ret == NULL)
252b5132
RH		 3982 return NULL;
3983
66eb6687
AM		 3984 if (!_bfd_elf_link_hash_table_init (&ret->root, abfd,
3985 elf32_mn10300_link_hash_newfunc,
3986 sizeof (struct elf32_mn10300_link_hash_entry)))
252b5132 3987 {
e2d34d7d 3988 free (ret);
252b5132
RH		 3989 return NULL;
3990 }
3991
3992 ret->flags = 0;
dc810e39 3993 amt = sizeof (struct elf_link_hash_table);
603b7257 3994 ret->static_hash_table = bfd_malloc (amt);
252b5132
RH		 3995 if (ret->static_hash_table == NULL)
3996 {
e2d34d7d 3997 free (ret);
252b5132
RH		 3998 return NULL;
3999 }
4000
66eb6687
AM		 4001 if (!_bfd_elf_link_hash_table_init (&ret->static_hash_table->root, abfd,
4002 elf32_mn10300_link_hash_newfunc,
4003 sizeof (struct elf32_mn10300_link_hash_entry)))
252b5132 4004 {
e2d34d7d
DJ		 4005 free (ret->static_hash_table);
4006 free (ret);
252b5132
RH		 4007 return NULL;
4008 }
603b7257 4009 return & ret->root.root;
252b5132
RH		 4010}
4011
e2d34d7d
DJ		 4012/* Free an mn10300 ELF linker hash table. */
4013
4014static void
603b7257 4015elf32_mn10300_link_hash_table_free (struct bfd_link_hash_table *hash)
e2d34d7d
DJ		 4016{
4017 struct elf32_mn10300_link_hash_table *ret
4018 = (struct elf32_mn10300_link_hash_table *) hash;
4019
4020 _bfd_generic_link_hash_table_free
4021 ((struct bfd_link_hash_table *) ret->static_hash_table);
4022 _bfd_generic_link_hash_table_free
4023 ((struct bfd_link_hash_table *) ret);
4024}
4025
dc810e39 4026static unsigned long
603b7257 4027elf_mn10300_mach (flagword flags)
252b5132
RH		 4028{
4029 switch (flags & EF_MN10300_MACH)
4030 {
010ac81f
KH		 4031 case E_MN10300_MACH_MN10300:
4032 default:
4033 return bfd_mach_mn10300;
252b5132 4034
010ac81f
KH		 4035 case E_MN10300_MACH_AM33:
4036 return bfd_mach_am33;
b08fa4d3
AO		 4037
4038 case E_MN10300_MACH_AM33_2:
4039 return bfd_mach_am33_2;
252b5132
RH		 4040 }
4041}
4042
4043/* The final processing done just before writing out a MN10300 ELF object
4044 file. This gets the MN10300 architecture right based on the machine
4045 number. */
4046
603b7257
NC		 4047static void
4048_bfd_mn10300_elf_final_write_processing (bfd *abfd,
4049 bfd_boolean linker ATTRIBUTE_UNUSED)
252b5132
RH		 4050{
4051 unsigned long val;
252b5132
RH		 4052
4053 switch (bfd_get_mach (abfd))
4054 {
010ac81f
KH		 4055 default:
4056 case bfd_mach_mn10300:
4057 val = E_MN10300_MACH_MN10300;
4058 break;
4059
4060 case bfd_mach_am33:
4061 val = E_MN10300_MACH_AM33;
4062 break;
b08fa4d3
AO		 4063
4064 case bfd_mach_am33_2:
4065 val = E_MN10300_MACH_AM33_2;
4066 break;
252b5132
RH		 4067 }
4068
4069 elf_elfheader (abfd)->e_flags &= ~ (EF_MN10300_MACH);
4070 elf_elfheader (abfd)->e_flags |= val;
4071}
4072
603b7257
NC		 4073static bfd_boolean
4074_bfd_mn10300_elf_object_p (bfd *abfd)
252b5132
RH		 4075{
4076 bfd_default_set_arch_mach (abfd, bfd_arch_mn10300,
010ac81f 4077 elf_mn10300_mach (elf_elfheader (abfd)->e_flags));
b34976b6 4078 return TRUE;
252b5132
RH		 4079}
4080
4081/* Merge backend specific data from an object file to the output
4082 object file when linking. */
4083
603b7257
NC		 4084static bfd_boolean
4085_bfd_mn10300_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
252b5132
RH		 4086{
4087 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
4088 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
b34976b6 4089 return TRUE;
252b5132
RH		 4090
4091 if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
4092 && bfd_get_mach (obfd) < bfd_get_mach (ibfd))
4093 {
4094 if (! bfd_set_arch_mach (obfd, bfd_get_arch (ibfd),
3b36f7e6
AM		 4095 bfd_get_mach (ibfd)))
4096 return FALSE;
252b5132
RH		 4097 }
4098
b34976b6 4099 return TRUE;
252b5132
RH		 4100}
4101
603b7257
NC		 4102#define PLT0_ENTRY_SIZE 15
4103#define PLT_ENTRY_SIZE 20
4104#define PIC_PLT_ENTRY_SIZE 24
03a12831
AO		 4105
4106static const bfd_byte elf_mn10300_plt0_entry[PLT0_ENTRY_SIZE] =
4107{
4108 0xfc, 0xa0, 0, 0, 0, 0, /* mov (.got+8),a0 */
4109 0xfe, 0xe, 0x10, 0, 0, 0, 0, /* mov (.got+4),r1 */
4110 0xf0, 0xf4, /* jmp (a0) */
4111};
4112
4113static const bfd_byte elf_mn10300_plt_entry[PLT_ENTRY_SIZE] =
4114{
4115 0xfc, 0xa0, 0, 0, 0, 0, /* mov (nameN@GOT + .got),a0 */
4116 0xf0, 0xf4, /* jmp (a0) */
4117 0xfe, 8, 0, 0, 0, 0, 0, /* mov reloc-table-address,r0 */
4118 0xdc, 0, 0, 0, 0, /* jmp .plt0 */
4119};
4120
4121static const bfd_byte elf_mn10300_pic_plt_entry[PIC_PLT_ENTRY_SIZE] =
4122{
4123 0xfc, 0x22, 0, 0, 0, 0, /* mov (nameN@GOT,a2),a0 */
4124 0xf0, 0xf4, /* jmp (a0) */
4125 0xfe, 8, 0, 0, 0, 0, 0, /* mov reloc-table-address,r0 */
4126 0xf8, 0x22, 8, /* mov (8,a2),a0 */
4127 0xfb, 0xa, 0x1a, 4, /* mov (4,a2),r1 */
4128 0xf0, 0xf4, /* jmp (a0) */
4129};
4130
4131/* Return size of the first PLT entry. */
4132#define elf_mn10300_sizeof_plt0(info) \
4133 (info->shared ? PIC_PLT_ENTRY_SIZE : PLT0_ENTRY_SIZE)
4134
4135/* Return size of a PLT entry. */
4136#define elf_mn10300_sizeof_plt(info) \
4137 (info->shared ? PIC_PLT_ENTRY_SIZE : PLT_ENTRY_SIZE)
4138
4139/* Return offset of the PLT0 address in an absolute PLT entry. */
4140#define elf_mn10300_plt_plt0_offset(info) 16
4141
4142/* Return offset of the linker in PLT0 entry. */
4143#define elf_mn10300_plt0_linker_offset(info) 2
4144
4145/* Return offset of the GOT id in PLT0 entry. */
4146#define elf_mn10300_plt0_gotid_offset(info) 9
4147
603b7257 4148/* Return offset of the temporary in PLT entry. */
03a12831
AO		 4149#define elf_mn10300_plt_temp_offset(info) 8
4150
4151/* Return offset of the symbol in PLT entry. */
4152#define elf_mn10300_plt_symbol_offset(info) 2
4153
4154/* Return offset of the relocation in PLT entry. */
4155#define elf_mn10300_plt_reloc_offset(info) 11
4156
4157/* The name of the dynamic interpreter. This is put in the .interp
4158 section. */
4159
4160#define ELF_DYNAMIC_INTERPRETER "/lib/ld.so.1"
4161
4162/* Create dynamic sections when linking against a dynamic object. */
4163
4164static bfd_boolean
603b7257 4165_bfd_mn10300_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
03a12831
AO		 4166{
4167 flagword flags;
4168 asection * s;
9c5bfbb7 4169 const struct elf_backend_data * bed = get_elf_backend_data (abfd);
03a12831
AO		 4170 int ptralign = 0;
4171
4172 switch (bed->s->arch_size)
4173 {
4174 case 32:
4175 ptralign = 2;
4176 break;
4177
4178 case 64:
4179 ptralign = 3;
4180 break;
4181
4182 default:
4183 bfd_set_error (bfd_error_bad_value);
4184 return FALSE;
4185 }
4186
4187 /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
4188 .rel[a].bss sections. */
03a12831
AO		 4189 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4190 | SEC_LINKER_CREATED);
4191
3496cb2a
L		 4192 s = bfd_make_section_with_flags (abfd,
4193 (bed->default_use_rela_p
4194 ? ".rela.plt" : ".rel.plt"),
4195 flags | SEC_READONLY);
03a12831 4196 if (s == NULL
03a12831
AO		 4197 || ! bfd_set_section_alignment (abfd, s, ptralign))
4198 return FALSE;
4199
4200 if (! _bfd_mn10300_elf_create_got_section (abfd, info))
4201 return FALSE;
4202
4203 {
4204 const char * secname;
4205 char * relname;
4206 flagword secflags;
4207 asection * sec;
4208
4209 for (sec = abfd->sections; sec; sec = sec->next)
4210 {
4211 secflags = bfd_get_section_flags (abfd, sec);
4212 if ((secflags & (SEC_DATA | SEC_LINKER_CREATED))
4213 || ((secflags & SEC_HAS_CONTENTS) != SEC_HAS_CONTENTS))
4214 continue;
4215
4216 secname = bfd_get_section_name (abfd, sec);
603b7257 4217 relname = bfd_malloc (strlen (secname) + 6);
03a12831
AO		 4218 strcpy (relname, ".rela");
4219 strcat (relname, secname);
4220
3496cb2a
L		 4221 s = bfd_make_section_with_flags (abfd, relname,
4222 flags | SEC_READONLY);
03a12831 4223 if (s == NULL
03a12831
AO		 4224 || ! bfd_set_section_alignment (abfd, s, ptralign))
4225 return FALSE;
4226 }
4227 }
4228
4229 if (bed->want_dynbss)
4230 {
4231 /* The .dynbss section is a place to put symbols which are defined
4232 by dynamic objects, are referenced by regular objects, and are
4233 not functions. We must allocate space for them in the process
4234 image and use a R_*_COPY reloc to tell the dynamic linker to
4235 initialize them at run time. The linker script puts the .dynbss
4236 section into the .bss section of the final image. */
3496cb2a
L		 4237 s = bfd_make_section_with_flags (abfd, ".dynbss",
4238 SEC_ALLOC | SEC_LINKER_CREATED);
4239 if (s == NULL)
03a12831
AO		 4240 return FALSE;
4241
4242 /* The .rel[a].bss section holds copy relocs. This section is not
4243 normally needed. We need to create it here, though, so that the
4244 linker will map it to an output section. We can't just create it
4245 only if we need it, because we will not know whether we need it
4246 until we have seen all the input files, and the first time the
4247 main linker code calls BFD after examining all the input files
4248 (size_dynamic_sections) the input sections have already been
4249 mapped to the output sections. If the section turns out not to
4250 be needed, we can discard it later. We will never need this
4251 section when generating a shared object, since they do not use
4252 copy relocs. */
4253 if (! info->shared)
4254 {
3496cb2a
L		 4255 s = bfd_make_section_with_flags (abfd,
4256 (bed->default_use_rela_p
4257 ? ".rela.bss" : ".rel.bss"),
4258 flags | SEC_READONLY);
03a12831 4259 if (s == NULL
03a12831
AO		 4260 || ! bfd_set_section_alignment (abfd, s, ptralign))
4261 return FALSE;
4262 }
4263 }
4264
4265 return TRUE;
4266}
4267\f
4268/* Adjust a symbol defined by a dynamic object and referenced by a
4269 regular object. The current definition is in some section of the
4270 dynamic object, but we're not including those sections. We have to
4271 change the definition to something the rest of the link can
4272 understand. */
4273
4274static bfd_boolean
603b7257
NC		 4275_bfd_mn10300_elf_adjust_dynamic_symbol (struct bfd_link_info * info,
4276 struct elf_link_hash_entry * h)
03a12831
AO		 4277{
4278 bfd * dynobj;
4279 asection * s;
03a12831
AO		 4280
4281 dynobj = elf_hash_table (info)->dynobj;
4282
4283 /* Make sure we know what is going on here. */
4284 BFD_ASSERT (dynobj != NULL
f5385ebf 4285 && (h->needs_plt
f6e332e6 4286 || h->u.weakdef != NULL
f5385ebf
AM		 4287 || (h->def_dynamic
4288 && h->ref_regular
4289 && !h->def_regular)));
03a12831
AO		 4290
4291 /* If this is a function, put it in the procedure linkage table. We
4292 will fill in the contents of the procedure linkage table later,
4293 when we know the address of the .got section. */
4294 if (h->type == STT_FUNC
f5385ebf 4295 || h->needs_plt)
03a12831
AO		 4296 {
4297 if (! info->shared
f5385ebf
AM		 4298 && !h->def_dynamic
4299 && !h->ref_dynamic)
03a12831
AO		 4300 {
4301 /* This case can occur if we saw a PLT reloc in an input
4302 file, but the symbol was never referred to by a dynamic
4303 object. In such a case, we don't actually need to build
4304 a procedure linkage table, and we can just do a REL32
4305 reloc instead. */
f5385ebf 4306 BFD_ASSERT (h->needs_plt);
03a12831
AO		 4307 return TRUE;
4308 }
4309
4310 /* Make sure this symbol is output as a dynamic symbol. */
4311 if (h->dynindx == -1)
4312 {
c152c796 4313 if (! bfd_elf_link_record_dynamic_symbol (info, h))
03a12831
AO		 4314 return FALSE;
4315 }
4316
4317 s = bfd_get_section_by_name (dynobj, ".plt");
4318 BFD_ASSERT (s != NULL);
4319
4320 /* If this is the first .plt entry, make room for the special
4321 first entry. */
eea6121a
AM		 4322 if (s->size == 0)
4323 s->size += elf_mn10300_sizeof_plt0 (info);
03a12831
AO		 4324
4325 /* If this symbol is not defined in a regular file, and we are
4326 not generating a shared library, then set the symbol to this
4327 location in the .plt. This is required to make function
4328 pointers compare as equal between the normal executable and
4329 the shared library. */
4330 if (! info->shared
f5385ebf 4331 && !h->def_regular)
03a12831
AO		 4332 {
4333 h->root.u.def.section = s;
eea6121a 4334 h->root.u.def.value = s->size;
03a12831
AO		 4335 }
4336
eea6121a 4337 h->plt.offset = s->size;
03a12831
AO		 4338
4339 /* Make room for this entry. */
eea6121a 4340 s->size += elf_mn10300_sizeof_plt (info);
03a12831
AO		 4341
4342 /* We also need to make an entry in the .got.plt section, which
4343 will be placed in the .got section by the linker script. */
03a12831
AO		 4344 s = bfd_get_section_by_name (dynobj, ".got.plt");
4345 BFD_ASSERT (s != NULL);
eea6121a 4346 s->size += 4;
03a12831
AO		 4347
4348 /* We also need to make an entry in the .rela.plt section. */
03a12831
AO		 4349 s = bfd_get_section_by_name (dynobj, ".rela.plt");
4350 BFD_ASSERT (s != NULL);
eea6121a 4351 s->size += sizeof (Elf32_External_Rela);
03a12831
AO		 4352
4353 return TRUE;
4354 }
4355
4356 /* If this is a weak symbol, and there is a real definition, the
4357 processor independent code will have arranged for us to see the
4358 real definition first, and we can just use the same value. */
f6e332e6 4359 if (h->u.weakdef != NULL)
03a12831 4360 {
f6e332e6
AM		 4361 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
4362 || h->u.weakdef->root.type == bfd_link_hash_defweak);
4363 h->root.u.def.section = h->u.weakdef->root.u.def.section;
4364 h->root.u.def.value = h->u.weakdef->root.u.def.value;
03a12831
AO		 4365 return TRUE;
4366 }
4367
4368 /* This is a reference to a symbol defined by a dynamic object which
4369 is not a function. */
4370
4371 /* If we are creating a shared library, we must presume that the
4372 only references to the symbol are via the global offset table.
4373 For such cases we need not do anything here; the relocations will
4374 be handled correctly by relocate_section. */
4375 if (info->shared)
4376 return TRUE;
4377
4378 /* If there are no references to this symbol that do not use the
4379 GOT, we don't need to generate a copy reloc. */
f5385ebf 4380 if (!h->non_got_ref)
03a12831
AO		 4381 return TRUE;
4382
909272ee
AM		 4383 if (h->size == 0)
4384 {
4385 (*_bfd_error_handler) (_("dynamic variable `%s' is zero size"),
4386 h->root.root.string);
4387 return TRUE;
4388 }
4389
03a12831
AO		 4390 /* We must allocate the symbol in our .dynbss section, which will
4391 become part of the .bss section of the executable. There will be
4392 an entry for this symbol in the .dynsym section. The dynamic
4393 object will contain position independent code, so all references
4394 from the dynamic object to this symbol will go through the global
4395 offset table. The dynamic linker will use the .dynsym entry to
4396 determine the address it must put in the global offset table, so
4397 both the dynamic object and the regular object will refer to the
4398 same memory location for the variable. */
4399
4400 s = bfd_get_section_by_name (dynobj, ".dynbss");
4401 BFD_ASSERT (s != NULL);
4402
4403 /* We must generate a R_MN10300_COPY reloc to tell the dynamic linker to
4404 copy the initial value out of the dynamic object and into the
4405 runtime process image. We need to remember the offset into the
4406 .rela.bss section we are going to use. */
4407 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
4408 {
4409 asection * srel;
4410
4411 srel = bfd_get_section_by_name (dynobj, ".rela.bss");
4412 BFD_ASSERT (srel != NULL);
eea6121a 4413 srel->size += sizeof (Elf32_External_Rela);
f5385ebf 4414 h->needs_copy = 1;
03a12831
AO		 4415 }
4416
027297b7 4417 return _bfd_elf_adjust_dynamic_copy (h, s);
03a12831
AO		 4418}
4419
03a12831
AO		 4420/* Set the sizes of the dynamic sections. */
4421
4422static bfd_boolean
603b7257
NC		 4423_bfd_mn10300_elf_size_dynamic_sections (bfd * output_bfd,
4424 struct bfd_link_info * info)
03a12831
AO		 4425{
4426 bfd * dynobj;
4427 asection * s;
4428 bfd_boolean plt;
4429 bfd_boolean relocs;
4430 bfd_boolean reltext;
4431
4432 dynobj = elf_hash_table (info)->dynobj;
4433 BFD_ASSERT (dynobj != NULL);
4434
4435 if (elf_hash_table (info)->dynamic_sections_created)
4436 {
4437 /* Set the contents of the .interp section to the interpreter. */
893c4fe2 4438 if (info->executable)
03a12831
AO		 4439 {
4440 s = bfd_get_section_by_name (dynobj, ".interp");
4441 BFD_ASSERT (s != NULL);
eea6121a 4442 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
03a12831
AO		 4443 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
4444 }
4445 }
4446 else
4447 {
4448 /* We may have created entries in the .rela.got section.
4449 However, if we are not creating the dynamic sections, we will
4450 not actually use these entries. Reset the size of .rela.got,
4451 which will cause it to get stripped from the output file
4452 below. */
4453 s = bfd_get_section_by_name (dynobj, ".rela.got");
4454 if (s != NULL)
eea6121a 4455 s->size = 0;
03a12831
AO		 4456 }
4457
03a12831
AO		 4458 /* The check_relocs and adjust_dynamic_symbol entry points have
4459 determined the sizes of the various dynamic sections. Allocate
4460 memory for them. */
4461 plt = FALSE;
4462 relocs = FALSE;
4463 reltext = FALSE;
4464 for (s = dynobj->sections; s != NULL; s = s->next)
4465 {
4466 const char * name;
03a12831
AO		 4467
4468 if ((s->flags & SEC_LINKER_CREATED) == 0)
4469 continue;
4470
4471 /* It's OK to base decisions on the section name, because none
4472 of the dynobj section names depend upon the input files. */
4473 name = bfd_get_section_name (dynobj, s);
4474
603b7257 4475 if (streq (name, ".plt"))
03a12831 4476 {
c456f082
AM		 4477 /* Remember whether there is a PLT. */
4478 plt = s->size != 0;
03a12831 4479 }
0112cd26 4480 else if (CONST_STRNEQ (name, ".rela"))
03a12831 4481 {
c456f082 4482 if (s->size != 0)
03a12831
AO		 4483 {
4484 asection * target;
4485
4486 /* Remember whether there are any reloc sections other
4487 than .rela.plt. */
603b7257 4488 if (! streq (name, ".rela.plt"))
03a12831
AO		 4489 {
4490 const char * outname;
4491
4492 relocs = TRUE;
4493
4494 /* If this relocation section applies to a read only
4495 section, then we probably need a DT_TEXTREL
4496 entry. The entries in the .rela.plt section
4497 really apply to the .got section, which we
4498 created ourselves and so know is not readonly. */
4499 outname = bfd_get_section_name (output_bfd,
4500 s->output_section);
4501 target = bfd_get_section_by_name (output_bfd, outname + 5);
4502 if (target != NULL
4503 && (target->flags & SEC_READONLY) != 0
4504 && (target->flags & SEC_ALLOC) != 0)
4505 reltext = TRUE;
4506 }
4507
4508 /* We use the reloc_count field as a counter if we need
4509 to copy relocs into the output file. */
4510 s->reloc_count = 0;
4511 }
4512 }
0112cd26 4513 else if (! CONST_STRNEQ (name, ".got")
603b7257 4514 && ! streq (name, ".dynbss"))
03a12831
AO		 4515 /* It's not one of our sections, so don't allocate space. */
4516 continue;
4517
c456f082 4518 if (s->size == 0)
03a12831 4519 {
c456f082
AM		 4520 /* If we don't need this section, strip it from the
4521 output file. This is mostly to handle .rela.bss and
4522 .rela.plt. We must create both sections in
4523 create_dynamic_sections, because they must be created
4524 before the linker maps input sections to output
4525 sections. The linker does that before
4526 adjust_dynamic_symbol is called, and it is that
4527 function which decides whether anything needs to go
4528 into these sections. */
8423293d 4529 s->flags |= SEC_EXCLUDE;
03a12831
AO		 4530 continue;
4531 }
4532
c456f082
AM		 4533 if ((s->flags & SEC_HAS_CONTENTS) == 0)
4534 continue;
4535
03a12831
AO		 4536 /* Allocate memory for the section contents. We use bfd_zalloc
4537 here in case unused entries are not reclaimed before the
4538 section's contents are written out. This should not happen,
4539 but this way if it does, we get a R_MN10300_NONE reloc
4540 instead of garbage. */
603b7257 4541 s->contents = bfd_zalloc (dynobj, s->size);
c456f082 4542 if (s->contents == NULL)
03a12831
AO		 4543 return FALSE;
4544 }
4545
4546 if (elf_hash_table (info)->dynamic_sections_created)
4547 {
4548 /* Add some entries to the .dynamic section. We fill in the
4549 values later, in _bfd_mn10300_elf_finish_dynamic_sections,
4550 but we must add the entries now so that we get the correct
4551 size for the .dynamic section. The DT_DEBUG entry is filled
4552 in by the dynamic linker and used by the debugger. */
4553 if (! info->shared)
4554 {
5a580b3a 4555 if (!_bfd_elf_add_dynamic_entry (info, DT_DEBUG, 0))
03a12831
AO		 4556 return FALSE;
4557 }
4558
4559 if (plt)
4560 {
5a580b3a
AM		 4561 if (!_bfd_elf_add_dynamic_entry (info, DT_PLTGOT, 0)
4562 || !_bfd_elf_add_dynamic_entry (info, DT_PLTRELSZ, 0)
4563 || !_bfd_elf_add_dynamic_entry (info, DT_PLTREL, DT_RELA)
4564 || !_bfd_elf_add_dynamic_entry (info, DT_JMPREL, 0))
03a12831
AO		 4565 return FALSE;
4566 }
4567
4568 if (relocs)
4569 {
5a580b3a
AM		 4570 if (!_bfd_elf_add_dynamic_entry (info, DT_RELA, 0)
4571 || !_bfd_elf_add_dynamic_entry (info, DT_RELASZ, 0)
4572 || !_bfd_elf_add_dynamic_entry (info, DT_RELAENT,
4573 sizeof (Elf32_External_Rela)))
03a12831
AO		 4574 return FALSE;
4575 }
4576
4577 if (reltext)
4578 {
5a580b3a 4579 if (!_bfd_elf_add_dynamic_entry (info, DT_TEXTREL, 0))
03a12831
AO		 4580 return FALSE;
4581 }
4582 }
4583
4584 return TRUE;
4585}
4586
4587/* Finish up dynamic symbol handling. We set the contents of various
4588 dynamic sections here. */
4589
4590static bfd_boolean
603b7257
NC		 4591_bfd_mn10300_elf_finish_dynamic_symbol (bfd * output_bfd,
4592 struct bfd_link_info * info,
4593 struct elf_link_hash_entry * h,
4594 Elf_Internal_Sym * sym)
03a12831
AO		 4595{
4596 bfd * dynobj;
4597
4598 dynobj = elf_hash_table (info)->dynobj;
4599
4600 if (h->plt.offset != (bfd_vma) -1)
4601 {
4602 asection * splt;
4603 asection * sgot;
4604 asection * srel;
4605 bfd_vma plt_index;
4606 bfd_vma got_offset;
4607 Elf_Internal_Rela rel;
4608
4609 /* This symbol has an entry in the procedure linkage table. Set
4610 it up. */
4611
4612 BFD_ASSERT (h->dynindx != -1);
4613
4614 splt = bfd_get_section_by_name (dynobj, ".plt");
4615 sgot = bfd_get_section_by_name (dynobj, ".got.plt");
4616 srel = bfd_get_section_by_name (dynobj, ".rela.plt");
4617 BFD_ASSERT (splt != NULL && sgot != NULL && srel != NULL);
4618
4619 /* Get the index in the procedure linkage table which
4620 corresponds to this symbol. This is the index of this symbol
4621 in all the symbols for which we are making plt entries. The
4622 first entry in the procedure linkage table is reserved. */
4623 plt_index = ((h->plt.offset - elf_mn10300_sizeof_plt0 (info))
4624 / elf_mn10300_sizeof_plt (info));
4625
4626 /* Get the offset into the .got table of the entry that
4627 corresponds to this function. Each .got entry is 4 bytes.
4628 The first three are reserved. */
4629 got_offset = (plt_index + 3) * 4;
4630
4631 /* Fill in the entry in the procedure linkage table. */
4632 if (! info->shared)
4633 {
4634 memcpy (splt->contents + h->plt.offset, elf_mn10300_plt_entry,
4635 elf_mn10300_sizeof_plt (info));
4636 bfd_put_32 (output_bfd,
4637 (sgot->output_section->vma
4638 + sgot->output_offset
4639 + got_offset),
4640 (splt->contents + h->plt.offset
4641 + elf_mn10300_plt_symbol_offset (info)));
4642
4643 bfd_put_32 (output_bfd,
4644 (1 - h->plt.offset - elf_mn10300_plt_plt0_offset (info)),
4645 (splt->contents + h->plt.offset
4646 + elf_mn10300_plt_plt0_offset (info)));
4647 }
4648 else
4649 {
4650 memcpy (splt->contents + h->plt.offset, elf_mn10300_pic_plt_entry,
4651 elf_mn10300_sizeof_plt (info));
4652
4653 bfd_put_32 (output_bfd, got_offset,
4654 (splt->contents + h->plt.offset
4655 + elf_mn10300_plt_symbol_offset (info)));
4656 }
4657
4658 bfd_put_32 (output_bfd, plt_index * sizeof (Elf32_External_Rela),
4659 (splt->contents + h->plt.offset
4660 + elf_mn10300_plt_reloc_offset (info)));
4661
4662 /* Fill in the entry in the global offset table. */
4663 bfd_put_32 (output_bfd,
4664 (splt->output_section->vma
4665 + splt->output_offset
4666 + h->plt.offset
4667 + elf_mn10300_plt_temp_offset (info)),
4668 sgot->contents + got_offset);
4669
4670 /* Fill in the entry in the .rela.plt section. */
4671 rel.r_offset = (sgot->output_section->vma
4672 + sgot->output_offset
4673 + got_offset);
4674 rel.r_info = ELF32_R_INFO (h->dynindx, R_MN10300_JMP_SLOT);
4675 rel.r_addend = 0;
4676 bfd_elf32_swap_reloca_out (output_bfd, &rel,
560e09e9
NC		 4677 (bfd_byte *) ((Elf32_External_Rela *) srel->contents
4678 + plt_index));
03a12831 4679
f5385ebf 4680 if (!h->def_regular)
03a12831
AO		 4681 /* Mark the symbol as undefined, rather than as defined in
4682 the .plt section. Leave the value alone. */
4683 sym->st_shndx = SHN_UNDEF;
4684 }
4685
4686 if (h->got.offset != (bfd_vma) -1)
4687 {
4688 asection * sgot;
4689 asection * srel;
4690 Elf_Internal_Rela rel;
4691
4692 /* This symbol has an entry in the global offset table. Set it up. */
03a12831
AO		 4693 sgot = bfd_get_section_by_name (dynobj, ".got");
4694 srel = bfd_get_section_by_name (dynobj, ".rela.got");
4695 BFD_ASSERT (sgot != NULL && srel != NULL);
4696
4697 rel.r_offset = (sgot->output_section->vma
4698 + sgot->output_offset
603b7257 4699 + (h->got.offset & ~1));
03a12831
AO		 4700
4701 /* If this is a -Bsymbolic link, and the symbol is defined
4702 locally, we just want to emit a RELATIVE reloc. Likewise if
4703 the symbol was forced to be local because of a version file.
4704 The entry in the global offset table will already have been
4705 initialized in the relocate_section function. */
4706 if (info->shared
4707 && (info->symbolic || h->dynindx == -1)
f5385ebf 4708 && h->def_regular)
03a12831
AO		 4709 {
4710 rel.r_info = ELF32_R_INFO (0, R_MN10300_RELATIVE);
4711 rel.r_addend = (h->root.u.def.value
4712 + h->root.u.def.section->output_section->vma
4713 + h->root.u.def.section->output_offset);
4714 }
4715 else
4716 {
4717 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset);
4718 rel.r_info = ELF32_R_INFO (h->dynindx, R_MN10300_GLOB_DAT);
4719 rel.r_addend = 0;
4720 }
4721
4722 bfd_elf32_swap_reloca_out (output_bfd, &rel,
560e09e9
NC		 4723 (bfd_byte *) ((Elf32_External_Rela *) srel->contents
4724 + srel->reloc_count));
03a12831
AO		 4725 ++ srel->reloc_count;
4726 }
4727
f5385ebf 4728 if (h->needs_copy)
03a12831
AO		 4729 {
4730 asection * s;
4731 Elf_Internal_Rela rel;
4732
4733 /* This symbol needs a copy reloc. Set it up. */
4734 BFD_ASSERT (h->dynindx != -1
4735 && (h->root.type == bfd_link_hash_defined
4736 || h->root.type == bfd_link_hash_defweak));
4737
4738 s = bfd_get_section_by_name (h->root.u.def.section->owner,
4739 ".rela.bss");
4740 BFD_ASSERT (s != NULL);
4741
4742 rel.r_offset = (h->root.u.def.value
4743 + h->root.u.def.section->output_section->vma
4744 + h->root.u.def.section->output_offset);
4745 rel.r_info = ELF32_R_INFO (h->dynindx, R_MN10300_COPY);
4746 rel.r_addend = 0;
603b7257 4747 bfd_elf32_swap_reloca_out (output_bfd, & rel,
560e09e9
NC		 4748 (bfd_byte *) ((Elf32_External_Rela *) s->contents
4749 + s->reloc_count));
03a12831
AO		 4750 ++ s->reloc_count;
4751 }
4752
4753 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
603b7257 4754 if (streq (h->root.root.string, "_DYNAMIC")
22edb2f1 4755 || h == elf_hash_table (info)->hgot)
03a12831
AO		 4756 sym->st_shndx = SHN_ABS;
4757
4758 return TRUE;
4759}
4760
4761/* Finish up the dynamic sections. */
4762
4763static bfd_boolean
603b7257
NC		 4764_bfd_mn10300_elf_finish_dynamic_sections (bfd * output_bfd,
4765 struct bfd_link_info * info)
03a12831
AO		 4766{
4767 bfd * dynobj;
4768 asection * sgot;
4769 asection * sdyn;
4770
4771 dynobj = elf_hash_table (info)->dynobj;
4772
4773 sgot = bfd_get_section_by_name (dynobj, ".got.plt");
4774 BFD_ASSERT (sgot != NULL);
4775 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
4776
4777 if (elf_hash_table (info)->dynamic_sections_created)
4778 {
4779 asection * splt;
4780 Elf32_External_Dyn * dyncon;
4781 Elf32_External_Dyn * dynconend;
4782
4783 BFD_ASSERT (sdyn != NULL);
4784
4785 dyncon = (Elf32_External_Dyn *) sdyn->contents;
eea6121a 4786 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
03a12831
AO		 4787
4788 for (; dyncon < dynconend; dyncon++)
4789 {
4790 Elf_Internal_Dyn dyn;
4791 const char * name;
4792 asection * s;
4793
4794 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
4795
4796 switch (dyn.d_tag)
4797 {
4798 default:
4799 break;
4800
4801 case DT_PLTGOT:
4802 name = ".got";
4803 goto get_vma;
4804
4805 case DT_JMPREL:
4806 name = ".rela.plt";
4807 get_vma:
4808 s = bfd_get_section_by_name (output_bfd, name);
4809 BFD_ASSERT (s != NULL);
4810 dyn.d_un.d_ptr = s->vma;
4811 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
4812 break;
4813
4814 case DT_PLTRELSZ:
4815 s = bfd_get_section_by_name (output_bfd, ".rela.plt");
4816 BFD_ASSERT (s != NULL);
eea6121a 4817 dyn.d_un.d_val = s->size;
03a12831
AO		 4818 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
4819 break;
4820
4821 case DT_RELASZ:
4822 /* My reading of the SVR4 ABI indicates that the
4823 procedure linkage table relocs (DT_JMPREL) should be
4824 included in the overall relocs (DT_RELA). This is
4825 what Solaris does. However, UnixWare can not handle
4826 that case. Therefore, we override the DT_RELASZ entry
4827 here to make it not include the JMPREL relocs. Since
4828 the linker script arranges for .rela.plt to follow all
4829 other relocation sections, we don't have to worry
4830 about changing the DT_RELA entry. */
4831 s = bfd_get_section_by_name (output_bfd, ".rela.plt");
4832 if (s != NULL)
eea6121a 4833 dyn.d_un.d_val -= s->size;
03a12831
AO		 4834 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
4835 break;
4836 }
4837 }
4838
4839 /* Fill in the first entry in the procedure linkage table. */
4840 splt = bfd_get_section_by_name (dynobj, ".plt");
eea6121a 4841 if (splt && splt->size > 0)
03a12831
AO		 4842 {
4843 if (info->shared)
4844 {
4845 memcpy (splt->contents, elf_mn10300_pic_plt_entry,
4846 elf_mn10300_sizeof_plt (info));
4847 }
4848 else
4849 {
4850 memcpy (splt->contents, elf_mn10300_plt0_entry, PLT0_ENTRY_SIZE);
4851 bfd_put_32 (output_bfd,
4852 sgot->output_section->vma + sgot->output_offset + 4,
4853 splt->contents + elf_mn10300_plt0_gotid_offset (info));
4854 bfd_put_32 (output_bfd,
4855 sgot->output_section->vma + sgot->output_offset + 8,
4856 splt->contents + elf_mn10300_plt0_linker_offset (info));
4857 }
4858
4859 /* UnixWare sets the entsize of .plt to 4, although that doesn't
4860 really seem like the right value. */
4861 elf_section_data (splt->output_section)->this_hdr.sh_entsize = 4;
4862 }
4863 }
4864
4865 /* Fill in the first three entries in the global offset table. */
eea6121a 4866 if (sgot->size > 0)
03a12831
AO		 4867 {
4868 if (sdyn == NULL)
4869 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
4870 else
4871 bfd_put_32 (output_bfd,
4872 sdyn->output_section->vma + sdyn->output_offset,
4873 sgot->contents);
4874 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
4875 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
4876 }
4877
4878 elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
4879
4880 return TRUE;
4881}
4882
a873f25a
AO		 4883/* Classify relocation types, such that combreloc can sort them
4884 properly. */
4885
4886static enum elf_reloc_type_class
4887_bfd_mn10300_elf_reloc_type_class (const Elf_Internal_Rela *rela)
4888{
4889 switch ((int) ELF32_R_TYPE (rela->r_info))
4890 {
603b7257
NC		 4891 case R_MN10300_RELATIVE: return reloc_class_relative;
4892 case R_MN10300_JMP_SLOT: return reloc_class_plt;
4893 case R_MN10300_COPY: return reloc_class_copy;
4894 default: return reloc_class_normal;
a873f25a
AO		 4895 }
4896}
4897
73c3cd1c 4898#ifndef ELF_ARCH
252b5132
RH		 4899#define TARGET_LITTLE_SYM bfd_elf32_mn10300_vec
4900#define TARGET_LITTLE_NAME "elf32-mn10300"
4901#define ELF_ARCH bfd_arch_mn10300
6f4514dc
AO		 4902#define ELF_MACHINE_CODE EM_MN10300
4903#define ELF_MACHINE_ALT1 EM_CYGNUS_MN10300
252b5132 4904#define ELF_MAXPAGESIZE 0x1000
73c3cd1c 4905#endif
252b5132
RH		 4906
4907#define elf_info_to_howto mn10300_info_to_howto
4908#define elf_info_to_howto_rel 0
4909#define elf_backend_can_gc_sections 1
b491616a 4910#define elf_backend_rela_normal 1
252b5132
RH		 4911#define elf_backend_check_relocs mn10300_elf_check_relocs
4912#define elf_backend_gc_mark_hook mn10300_elf_gc_mark_hook
4913#define elf_backend_relocate_section mn10300_elf_relocate_section
4914#define bfd_elf32_bfd_relax_section mn10300_elf_relax_section
4915#define bfd_elf32_bfd_get_relocated_section_contents \
4916 mn10300_elf_get_relocated_section_contents
4917#define bfd_elf32_bfd_link_hash_table_create \
4918 elf32_mn10300_link_hash_table_create
e2d34d7d
DJ		 4919#define bfd_elf32_bfd_link_hash_table_free \
4920 elf32_mn10300_link_hash_table_free
252b5132 4921
73c3cd1c 4922#ifndef elf_symbol_leading_char
252b5132 4923#define elf_symbol_leading_char '_'
73c3cd1c 4924#endif
252b5132
RH		 4925
4926/* So we can set bits in e_flags. */
4927#define elf_backend_final_write_processing \
3b36f7e6
AM		 4928 _bfd_mn10300_elf_final_write_processing
4929#define elf_backend_object_p _bfd_mn10300_elf_object_p
252b5132
RH		 4930
4931#define bfd_elf32_bfd_merge_private_bfd_data \
3b36f7e6 4932 _bfd_mn10300_elf_merge_private_bfd_data
252b5132 4933
03a12831
AO		 4934#define elf_backend_can_gc_sections 1
4935#define elf_backend_create_dynamic_sections \
4936 _bfd_mn10300_elf_create_dynamic_sections
4937#define elf_backend_adjust_dynamic_symbol \
4938 _bfd_mn10300_elf_adjust_dynamic_symbol
4939#define elf_backend_size_dynamic_sections \
4940 _bfd_mn10300_elf_size_dynamic_sections
74541ad4
AM		 4941#define elf_backend_omit_section_dynsym \
4942 ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
03a12831
AO		 4943#define elf_backend_finish_dynamic_symbol \
4944 _bfd_mn10300_elf_finish_dynamic_symbol
4945#define elf_backend_finish_dynamic_sections \
4946 _bfd_mn10300_elf_finish_dynamic_sections
4947
a873f25a
AO		 4948#define elf_backend_reloc_type_class \
4949 _bfd_mn10300_elf_reloc_type_class
4950
03a12831
AO		 4951#define elf_backend_want_got_plt 1
4952#define elf_backend_plt_readonly 1
4953#define elf_backend_want_plt_sym 0
4954#define elf_backend_got_header_size 12
03a12831 4955
252b5132 4956#include "elf32-target.h"
GDB Binutils - Deliverables
This page took 0.875529 seconds and 4 git commands to generate.