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