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