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