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