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