1
/* BFD back-end for Motorola 68000 COFF binaries.
2
Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1999,
4
Free Software Foundation, Inc.
5
Written by Cygnus Support.
7
This file is part of BFD, the Binary File Descriptor library.
9
This program is free software; you can redistribute it and/or modify
10
it under the terms of the GNU General Public License as published by
11
the Free Software Foundation; either version 2 of the License, or
12
(at your option) any later version.
14
This program is distributed in the hope that it will be useful,
15
but WITHOUT ANY WARRANTY; without even the implied warranty of
16
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17
GNU General Public License for more details.
19
You should have received a copy of the GNU General Public License
20
along with this program; if not, write to the Free Software
21
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
26
#include "coff/m68k.h"
27
#include "coff/internal.h"
30
/* This source file is compiled multiple times for various m68k COFF
31
variants. The following macros control its behaviour:
34
The C name of the BFD target vector. The default is m68kcoff_vec.
36
The user visible target name. The default is "coff-m68k".
38
Whether symbol names have an underscore.
40
Only declare the relocation howto array. Don't actually compile
41
it. The actual array will be picked up in another version of the
44
Make the relocation howto array, and associated functions, static.
46
If this is defined, then, for a relocation against a common
47
symbol, the object file holds the value (the size) of the common
48
symbol. If this is not defined, then, for a relocation against a
49
common symbol, the object file holds zero. */
51
#define COFF_DEFAULT_SECTION_ALIGNMENT_POWER (2)
53
#ifndef COFF_PAGE_SIZE
54
/* The page size is a guess based on ELF. */
55
#define COFF_PAGE_SIZE 0x2000
58
#ifndef COFF_COMMON_ADDEND
59
#define RELOC_SPECIAL_FN 0
61
static bfd_reloc_status_type m68kcoff_common_addend_special_fn
62
PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
63
static reloc_howto_type *m68kcoff_common_addend_rtype_to_howto
64
PARAMS ((bfd *, asection *, struct internal_reloc *,
65
struct coff_link_hash_entry *, struct internal_syment *,
67
#define RELOC_SPECIAL_FN m68kcoff_common_addend_special_fn
70
static boolean m68k_coff_is_local_label_name PARAMS ((bfd *, const char *));
72
/* On the delta, a symbol starting with L% is local. We won't see
73
such a symbol on other platforms, so it should be safe to always
74
consider it local here. */
77
m68k_coff_is_local_label_name (abfd, name)
81
if (name[0] == 'L' && name[1] == '%')
84
return _bfd_coff_is_local_label_name (abfd, name);
88
/* Clean up namespace. */
89
#define m68kcoff_howto_table _bfd_m68kcoff_howto_table
90
#define m68k_rtype2howto _bfd_m68kcoff_rtype2howto
91
#define m68k_howto2rtype _bfd_m68kcoff_howto2rtype
92
#define m68k_reloc_type_lookup _bfd_m68kcoff_reloc_type_lookup
95
#ifdef ONLY_DECLARE_RELOCS
96
extern reloc_howto_type m68kcoff_howto_table[];
101
reloc_howto_type m68kcoff_howto_table[] =
103
HOWTO (R_RELBYTE, 0, 0, 8, false, 0, complain_overflow_bitfield, RELOC_SPECIAL_FN, "8", true, 0x000000ff,0x000000ff, false),
104
HOWTO (R_RELWORD, 0, 1, 16, false, 0, complain_overflow_bitfield, RELOC_SPECIAL_FN, "16", true, 0x0000ffff,0x0000ffff, false),
105
HOWTO (R_RELLONG, 0, 2, 32, false, 0, complain_overflow_bitfield, RELOC_SPECIAL_FN, "32", true, 0xffffffff,0xffffffff, false),
106
HOWTO (R_PCRBYTE, 0, 0, 8, true, 0, complain_overflow_signed, RELOC_SPECIAL_FN, "DISP8", true, 0x000000ff,0x000000ff, false),
107
HOWTO (R_PCRWORD, 0, 1, 16, true, 0, complain_overflow_signed, RELOC_SPECIAL_FN, "DISP16", true, 0x0000ffff,0x0000ffff, false),
108
HOWTO (R_PCRLONG, 0, 2, 32, true, 0, complain_overflow_signed, RELOC_SPECIAL_FN, "DISP32", true, 0xffffffff,0xffffffff, false),
109
HOWTO (R_RELLONG_NEG, 0, -2, 32, false, 0, complain_overflow_bitfield, RELOC_SPECIAL_FN, "-32", true, 0xffffffff,0xffffffff, false),
111
#endif /* not ONLY_DECLARE_RELOCS */
114
#define BADMAG(x) M68KBADMAG(x)
116
#define M68 1 /* Customize coffcode.h */
118
/* Turn a howto into a reloc number */
120
#ifdef ONLY_DECLARE_RELOCS
121
extern void m68k_rtype2howto PARAMS ((arelent *internal, int relocentry));
122
extern int m68k_howto2rtype PARAMS ((reloc_howto_type *));
123
extern reloc_howto_type *m68k_reloc_type_lookup
124
PARAMS ((bfd *, bfd_reloc_code_real_type));
128
#define STAT_REL static
133
STAT_REL reloc_howto_type * m68k_reloc_type_lookup PARAMS ((bfd *, bfd_reloc_code_real_type));
134
STAT_REL int m68k_howto2rtype PARAMS ((reloc_howto_type *));
135
STAT_REL void m68k_rtype2howto PARAMS ((arelent *, int));
139
m68k_rtype2howto(internal, relocentry)
145
case R_RELBYTE: internal->howto = m68kcoff_howto_table + 0; break;
146
case R_RELWORD: internal->howto = m68kcoff_howto_table + 1; break;
147
case R_RELLONG: internal->howto = m68kcoff_howto_table + 2; break;
148
case R_PCRBYTE: internal->howto = m68kcoff_howto_table + 3; break;
149
case R_PCRWORD: internal->howto = m68kcoff_howto_table + 4; break;
150
case R_PCRLONG: internal->howto = m68kcoff_howto_table + 5; break;
151
case R_RELLONG_NEG: internal->howto = m68kcoff_howto_table + 6; break;
156
m68k_howto2rtype (internal)
157
reloc_howto_type *internal;
159
if (internal->pc_relative)
161
switch (internal->bitsize)
163
case 32: return R_PCRLONG;
164
case 16: return R_PCRWORD;
165
case 8: return R_PCRBYTE;
170
switch (internal->bitsize)
172
case 32: return R_RELLONG;
173
case 16: return R_RELWORD;
174
case 8: return R_RELBYTE;
180
STAT_REL reloc_howto_type *
181
m68k_reloc_type_lookup (abfd, code)
182
bfd *abfd ATTRIBUTE_UNUSED;
183
bfd_reloc_code_real_type code;
187
default: return NULL;
188
case BFD_RELOC_8: return m68kcoff_howto_table + 0;
189
case BFD_RELOC_16: return m68kcoff_howto_table + 1;
191
case BFD_RELOC_32: return m68kcoff_howto_table + 2;
192
case BFD_RELOC_8_PCREL: return m68kcoff_howto_table + 3;
193
case BFD_RELOC_16_PCREL: return m68kcoff_howto_table + 4;
194
case BFD_RELOC_32_PCREL: return m68kcoff_howto_table + 5;
195
/* FIXME: There doesn't seem to be a code for R_RELLONG_NEG. */
200
#endif /* not ONLY_DECLARE_RELOCS */
202
#define RTYPE2HOWTO(internal, relocentry) \
203
m68k_rtype2howto(internal, (relocentry)->r_type)
205
#define SELECT_RELOC(external, internal) \
206
external.r_type = m68k_howto2rtype (internal)
208
#define coff_bfd_reloc_type_lookup m68k_reloc_type_lookup
210
#ifndef COFF_COMMON_ADDEND
211
#ifndef coff_rtype_to_howto
213
#define coff_rtype_to_howto m68kcoff_rtype_to_howto
215
static reloc_howto_type *m68kcoff_rtype_to_howto
216
PARAMS ((bfd *, asection *, struct internal_reloc *,
217
struct coff_link_hash_entry *, struct internal_syment *,
220
static reloc_howto_type *
221
m68kcoff_rtype_to_howto (abfd, sec, rel, h, sym, addendp)
222
bfd *abfd ATTRIBUTE_UNUSED;
224
struct internal_reloc *rel;
225
struct coff_link_hash_entry *h ATTRIBUTE_UNUSED;
226
struct internal_syment *sym ATTRIBUTE_UNUSED;
230
reloc_howto_type *howto;
232
RTYPE2HOWTO (&relent, rel);
234
howto = relent.howto;
236
if (howto->pc_relative)
237
*addendp += sec->vma;
242
#endif /* ! defined (coff_rtype_to_howto) */
243
#endif /* ! defined (COFF_COMMON_ADDEND) */
245
#ifdef COFF_COMMON_ADDEND
247
/* If COFF_COMMON_ADDEND is defined, then when using m68k COFF the
248
value stored in the .text section for a reference to a common
249
symbol is the value itself plus any desired offset. (taken from
250
work done by Ian Taylor, Cygnus Support, for I386 COFF). */
252
/* If we are producing relocateable output, we need to do some
253
adjustments to the object file that are not done by the
254
bfd_perform_relocation function. This function is called by every
255
reloc type to make any required adjustments. */
257
static bfd_reloc_status_type
258
m68kcoff_common_addend_special_fn (abfd, reloc_entry, symbol, data,
259
input_section, output_bfd, error_message)
261
arelent *reloc_entry;
264
asection *input_section ATTRIBUTE_UNUSED;
266
char **error_message ATTRIBUTE_UNUSED;
270
if (output_bfd == (bfd *) NULL)
271
return bfd_reloc_continue;
273
if (bfd_is_com_section (symbol->section))
275
/* We are relocating a common symbol. The current value in the
276
object file is ORIG + OFFSET, where ORIG is the value of the
277
common symbol as seen by the object file when it was compiled
278
(this may be zero if the symbol was undefined) and OFFSET is
279
the offset into the common symbol (normally zero, but may be
280
non-zero when referring to a field in a common structure).
281
ORIG is the negative of reloc_entry->addend, which is set by
282
the CALC_ADDEND macro below. We want to replace the value in
283
the object file with NEW + OFFSET, where NEW is the value of
284
the common symbol which we are going to put in the final
285
object file. NEW is symbol->value. */
286
diff = symbol->value + reloc_entry->addend;
290
/* For some reason bfd_perform_relocation always effectively
291
ignores the addend for a COFF target when producing
292
relocateable output. This seems to be always wrong for 386
293
COFF, so we handle the addend here instead. */
294
diff = reloc_entry->addend;
298
x = ((x & ~howto->dst_mask) | (((x & howto->src_mask) + diff) & howto->dst_mask))
302
reloc_howto_type *howto = reloc_entry->howto;
303
unsigned char *addr = (unsigned char *) data + reloc_entry->address;
309
char x = bfd_get_8 (abfd, addr);
311
bfd_put_8 (abfd, x, addr);
317
short x = bfd_get_16 (abfd, addr);
319
bfd_put_16 (abfd, (bfd_vma) x, addr);
325
long x = bfd_get_32 (abfd, addr);
327
bfd_put_32 (abfd, (bfd_vma) x, addr);
336
/* Now let bfd_perform_relocation finish everything up. */
337
return bfd_reloc_continue;
340
/* Compute the addend of a reloc. If the reloc is to a common symbol,
341
the object file contains the value of the common symbol. By the
342
time this is called, the linker may be using a different symbol
343
from a different object file with a different value. Therefore, we
344
hack wildly to locate the original symbol from this file so that we
345
can make the correct adjustment. This macro sets coffsym to the
346
symbol from the original file, and uses it to set the addend value
347
correctly. If this is not a common symbol, the usual addend
348
calculation is done, except that an additional tweak is needed for
350
FIXME: This macro refers to symbols and asect; these are from the
351
calling function, not the macro arguments. */
353
#define CALC_ADDEND(abfd, ptr, reloc, cache_ptr) \
355
coff_symbol_type *coffsym = (coff_symbol_type *) NULL; \
356
if (ptr && bfd_asymbol_bfd (ptr) != abfd) \
357
coffsym = (obj_symbols (abfd) \
358
+ (cache_ptr->sym_ptr_ptr - symbols)); \
360
coffsym = coff_symbol_from (abfd, ptr); \
361
if (coffsym != (coff_symbol_type *) NULL \
362
&& coffsym->native->u.syment.n_scnum == 0) \
363
cache_ptr->addend = - coffsym->native->u.syment.n_value; \
364
else if (ptr && bfd_asymbol_bfd (ptr) == abfd \
365
&& ptr->section != (asection *) NULL) \
366
cache_ptr->addend = - (ptr->section->vma + ptr->value); \
368
cache_ptr->addend = 0; \
369
if (ptr && (reloc.r_type == R_PCRBYTE \
370
|| reloc.r_type == R_PCRWORD \
371
|| reloc.r_type == R_PCRLONG)) \
372
cache_ptr->addend += asect->vma; \
375
#ifndef coff_rtype_to_howto
377
/* coff-m68k.c uses the special COFF backend linker. We need to
378
adjust common symbols. */
380
static reloc_howto_type *
381
m68kcoff_common_addend_rtype_to_howto (abfd, sec, rel, h, sym, addendp)
382
bfd *abfd ATTRIBUTE_UNUSED;
384
struct internal_reloc *rel;
385
struct coff_link_hash_entry *h;
386
struct internal_syment *sym;
390
reloc_howto_type *howto;
392
RTYPE2HOWTO (&relent, rel);
394
howto = relent.howto;
396
if (howto->pc_relative)
397
*addendp += sec->vma;
399
if (sym != NULL && sym->n_scnum == 0 && sym->n_value != 0)
401
/* This is a common symbol. The section contents include the
402
size (sym->n_value) as an addend. The relocate_section
403
function will be adding in the final value of the symbol. We
404
need to subtract out the current size in order to get the
406
BFD_ASSERT (h != NULL);
407
*addendp -= sym->n_value;
410
/* If the output symbol is common (in which case this must be a
411
relocateable link), we need to add in the final size of the
413
if (h != NULL && h->root.type == bfd_link_hash_common)
414
*addendp += h->root.u.c.size;
419
#define coff_rtype_to_howto m68kcoff_common_addend_rtype_to_howto
421
#endif /* ! defined (coff_rtype_to_howto) */
423
#endif /* COFF_COMMON_ADDEND */
425
#if !defined ONLY_DECLARE_RELOCS && ! defined STATIC_RELOCS
426
/* Given a .data section and a .emreloc in-memory section, store
427
relocation information into the .emreloc section which can be
428
used at runtime to relocate the section. This is called by the
429
linker when the --embedded-relocs switch is used. This is called
430
after the add_symbols entry point has been called for all the
431
objects, and before the final_link entry point is called. */
434
bfd_m68k_coff_create_embedded_relocs (abfd, info, datasec, relsec, errmsg)
436
struct bfd_link_info *info;
442
bfd_size_type symesz;
443
struct internal_reloc *irel, *irelend;
447
BFD_ASSERT (! info->relocateable);
451
if (datasec->reloc_count == 0)
454
extsyms = obj_coff_external_syms (abfd);
455
symesz = bfd_coff_symesz (abfd);
457
irel = _bfd_coff_read_internal_relocs (abfd, datasec, true, NULL, false,
459
irelend = irel + datasec->reloc_count;
461
amt = (bfd_size_type) datasec->reloc_count * 12;
462
relsec->contents = (bfd_byte *) bfd_alloc (abfd, amt);
463
if (relsec->contents == NULL)
466
p = relsec->contents;
468
for (; irel < irelend; irel++, p += 12)
472
/* We are going to write a four byte longword into the runtime
473
reloc section. The longword will be the address in the data
474
section which must be relocated. It is followed by the name
475
of the target section NUL-padded or truncated to 8
478
/* We can only relocate absolute longword relocs at run time. */
479
if (irel->r_type != R_RELLONG)
481
*errmsg = _("unsupported reloc type");
482
bfd_set_error (bfd_error_bad_value);
486
if (irel->r_symndx == -1)
487
targetsec = bfd_abs_section_ptr;
490
struct coff_link_hash_entry *h;
492
h = obj_coff_sym_hashes (abfd)[irel->r_symndx];
495
struct internal_syment isym;
497
bfd_coff_swap_sym_in (abfd, extsyms + symesz * irel->r_symndx,
499
targetsec = coff_section_from_bfd_index (abfd, isym.n_scnum);
501
else if (h->root.type == bfd_link_hash_defined
502
|| h->root.type == bfd_link_hash_defweak)
503
targetsec = h->root.u.def.section;
509
(irel->r_vaddr - datasec->vma + datasec->output_offset), p);
510
memset (p + 4, 0, 8);
511
if (targetsec != NULL)
512
strncpy (p + 4, targetsec->output_section->name, 8);
517
#endif /* neither ONLY_DECLARE_RELOCS not STATIC_RELOCS */
519
#define coff_bfd_is_local_label_name m68k_coff_is_local_label_name
521
#define coff_relocate_section _bfd_coff_generic_relocate_section
523
#include "coffcode.h"
526
#define TARGET_SYM m68kcoff_vec
530
#define TARGET_NAME "coff-m68k"
533
#ifdef NAMES_HAVE_UNDERSCORE
534
CREATE_BIG_COFF_TARGET_VEC (TARGET_SYM, TARGET_NAME, D_PAGED, 0, '_', NULL)
536
CREATE_BIG_COFF_TARGET_VEC (TARGET_SYM, TARGET_NAME, D_PAGED, 0, 0, NULL)
added
removed
binutils/bfd/coff-m68k.c
