diff options
Diffstat (limited to 'sys-devel/binutils/files/binutils-2.22-mint.patch')
| -rw-r--r-- | sys-devel/binutils/files/binutils-2.22-mint.patch | 2656 |
1 files changed, 2656 insertions, 0 deletions
diff --git a/sys-devel/binutils/files/binutils-2.22-mint.patch b/sys-devel/binutils/files/binutils-2.22-mint.patch new file mode 100644 index 0000000..4c2442e --- /dev/null +++ b/sys-devel/binutils/files/binutils-2.22-mint.patch @@ -0,0 +1,2656 @@ +http://bugs.gentoo.org/show_bug.cgi?id=362559 + +diff -ur --new-file binutils-2.21.51.0.7/bfd/Makefile.am binutils-2.21.51.0.7-mint/bfd/Makefile.am +--- binutils-2.21.51.0.7/bfd/Makefile.am 2010-12-06 14:23:53.000000000 +0000 ++++ binutils-2.21.51.0.7-mint/bfd/Makefile.am 2011-04-08 10:07:06.000000000 +0000 +@@ -379,6 +379,7 @@ + peigen.lo \ + plugin.lo \ + ppcboot.lo \ ++ prg-mint.lo \ + reloc16.lo \ + riscix.lo \ + som.lo \ +@@ -559,6 +560,7 @@ + pei-sh.c \ + plugin.c \ + ppcboot.c \ ++ prg-mint.c \ + reloc16.c \ + riscix.c \ + som.c \ +diff -ur --new-file binutils-2.21.51.0.7/bfd/Makefile.in binutils-2.21.51.0.7-mint/bfd/Makefile.in +--- binutils-2.21.51.0.7/bfd/Makefile.in 2010-12-06 14:23:53.000000000 +0000 ++++ binutils-2.21.51.0.7-mint/bfd/Makefile.in 2011-04-08 10:07:06.000000000 +0000 +@@ -679,6 +679,7 @@ + peigen.lo \ + plugin.lo \ + ppcboot.lo \ ++ prg-mint.lo \ + reloc16.lo \ + riscix.lo \ + som.lo \ +@@ -859,6 +860,7 @@ + pei-sh.c \ + plugin.c \ + ppcboot.c \ ++ prg-mint.c \ + reloc16.c \ + riscix.c \ + som.c \ +diff -ur --new-file binutils-2.21.51.0.7/bfd/acinclude.m4 binutils-2.21.51.0.7-mint/bfd/acinclude.m4 +--- binutils-2.21.51.0.7/bfd/acinclude.m4 2009-12-14 15:46:47.000000000 +0000 ++++ binutils-2.21.51.0.7-mint/bfd/acinclude.m4 2011-04-08 10:07:06.000000000 +0000 +@@ -5,7 +5,7 @@ + [AC_REQUIRE([AC_CANONICAL_TARGET]) + case "${host}" in + changequote(,)dnl +-*-*-msdos* | *-*-go32* | *-*-mingw32* | *-*-cygwin* | *-*-windows*) ++*-*-msdos* | *-*-go32* | *-*-mingw32* | *-*-cygwin* | *-*-windows* | *-*-mint*) + changequote([,])dnl + AC_DEFINE(USE_BINARY_FOPEN, 1, [Use b modifier when opening binary files?]) ;; + esac])dnl +diff -ur --new-file binutils-2.21.51.0.7/bfd/aoutx.h binutils-2.21.51.0.7-mint/bfd/aoutx.h +--- binutils-2.21.51.0.7/bfd/aoutx.h 2011-03-07 18:05:31.000000000 +0000 ++++ binutils-2.21.51.0.7-mint/bfd/aoutx.h 2011-04-08 10:07:06.000000000 +0000 +@@ -1841,6 +1841,11 @@ + bfd_byte buffer[BYTES_IN_WORD]; + bfd_size_type amt = BYTES_IN_WORD; + ++ /* The MiNT backend writes past the string table. It therefore has to ++ know about the table size. */ ++ obj_aout_external_string_size (abfd) = _bfd_stringtab_size (tab) + ++ BYTES_IN_WORD; ++ + /* The string table starts with the size. */ + PUT_WORD (abfd, _bfd_stringtab_size (tab) + BYTES_IN_WORD, buffer); + if (bfd_bwrite ((void *) buffer, amt, abfd) != amt) +@@ -4220,10 +4225,17 @@ + return FALSE; + } + ++#ifdef MY_final_link_relocate_rel ++ r = MY_final_link_relocate_rel (howto, ++ input_bfd, input_section, ++ contents, r_addr, relocation, ++ (bfd_vma) 0, rel); ++#else + r = MY_final_link_relocate (howto, + input_bfd, input_section, + contents, r_addr, relocation, + (bfd_vma) 0); ++#endif + } + + if (r != bfd_reloc_ok) +diff -ur --new-file binutils-2.21.51.0.7/bfd/bfd-in.h binutils-2.21.51.0.7-mint/bfd/bfd-in.h +--- binutils-2.21.51.0.7/bfd/bfd-in.h 2010-11-12 17:32:58.000000000 +0000 ++++ binutils-2.21.51.0.7-mint/bfd/bfd-in.h 2011-04-08 10:07:06.000000000 +0000 +@@ -742,6 +742,15 @@ + extern bfd_boolean bfd_sparclinux_size_dynamic_sections + (bfd *, struct bfd_link_info *); + ++/* MiNT executable support routines for the linker. */ ++ ++extern bfd_boolean bfd_m68kmint_set_extended_flags ++ (bfd *, flagword); ++extern bfd_boolean bfd_m68kmint_set_stack_size ++ (bfd *, bfd_signed_vma); ++extern bfd_boolean bfd_m68kmint_add_tpa_relocation_entry ++ (bfd *, bfd_vma); ++ + /* mmap hacks */ + + struct _bfd_window_internal; +diff -ur --new-file binutils-2.21.51.0.7/bfd/bfd-in2.h binutils-2.21.51.0.7-mint/bfd/bfd-in2.h +--- binutils-2.21.51.0.7/bfd/bfd-in2.h 2011-03-07 18:05:57.000000000 +0000 ++++ binutils-2.21.51.0.7-mint/bfd/bfd-in2.h 2011-04-08 10:07:06.000000000 +0000 +@@ -749,6 +749,15 @@ + extern bfd_boolean bfd_sparclinux_size_dynamic_sections + (bfd *, struct bfd_link_info *); + ++/* MiNT executable support routines for the linker. */ ++ ++extern bfd_boolean bfd_m68kmint_set_extended_flags ++ (bfd *, flagword); ++extern bfd_boolean bfd_m68kmint_set_stack_size ++ (bfd *, bfd_signed_vma); ++extern bfd_boolean bfd_m68kmint_add_tpa_relocation_entry ++ (bfd *, bfd_vma); ++ + /* mmap hacks */ + + struct _bfd_window_internal; +diff -ur --new-file binutils-2.21.51.0.7/bfd/config.bfd binutils-2.21.51.0.7-mint/bfd/config.bfd +--- binutils-2.21.51.0.7/bfd/config.bfd 2011-01-04 17:51:04.000000000 +0000 ++++ binutils-2.21.51.0.7-mint/bfd/config.bfd 2011-04-08 10:07:06.000000000 +0000 +@@ -823,6 +823,11 @@ + # targ_selvecs=m68kmach3_vec + # targ_cflags=-DSTAT_FOR_EXEC + ;; ++ m68*-*-mint*) ++ targ_defvec=aout0_big_vec ++ targ_selvecs=m68kmint_prg_vec ++ targ_underscore=yes ++ ;; + m68*-hp*-netbsd*) + targ_defvec=m68k4knetbsd_vec + targ_selvecs="m68knetbsd_vec hp300bsd_vec sunos_big_vec" +diff -ur --new-file binutils-2.21.51.0.7/bfd/configure binutils-2.21.51.0.7-mint/bfd/configure +--- binutils-2.21.51.0.7/bfd/configure 2011-03-07 18:05:31.000000000 +0000 ++++ binutils-2.21.51.0.7-mint/bfd/configure 2011-04-08 10:07:07.000000000 +0000 +@@ -13623,7 +13623,7 @@ + + + case "${host}" in +-*-*-msdos* | *-*-go32* | *-*-mingw32* | *-*-cygwin* | *-*-windows*) ++*-*-msdos* | *-*-go32* | *-*-mingw32* | *-*-cygwin* | *-*-windows* | *-*-mint*) + + $as_echo "#define USE_BINARY_FOPEN 1" >>confdefs.h + ;; +@@ -15237,6 +15237,7 @@ + m68kcoff_vec) tb="$tb coff-m68k.lo cofflink.lo" ;; + m68kcoffun_vec) tb="$tb coff-u68k.lo coff-m68k.lo cofflink.lo" ;; + m68klinux_vec) tb="$tb m68klinux.lo aout32.lo" ;; ++ m68kmint_prg_vec) tb="$tb prg-mint.lo aout32.lo" ;; + m68knetbsd_vec) tb="$tb m68knetbsd.lo aout32.lo" ;; + m68ksysvcoff_vec) tb="$tb coff-svm68k.lo cofflink.lo" ;; + m88kbcs_vec) tb="$tb coff-m88k.lo" ;; +diff -ur --new-file binutils-2.21.51.0.7/bfd/configure.in binutils-2.21.51.0.7-mint/bfd/configure.in +--- binutils-2.21.51.0.7/bfd/configure.in 2011-03-07 18:05:31.000000000 +0000 ++++ binutils-2.21.51.0.7-mint/bfd/configure.in 2011-04-08 10:07:07.000000000 +0000 +@@ -880,6 +880,7 @@ + m68kcoff_vec) tb="$tb coff-m68k.lo cofflink.lo" ;; + m68kcoffun_vec) tb="$tb coff-u68k.lo coff-m68k.lo cofflink.lo" ;; + m68klinux_vec) tb="$tb m68klinux.lo aout32.lo" ;; ++ m68kmint_prg_vec) tb="$tb prg-mint.lo aout32.lo" ;; + m68knetbsd_vec) tb="$tb m68knetbsd.lo aout32.lo" ;; + m68ksysvcoff_vec) tb="$tb coff-svm68k.lo cofflink.lo" ;; + m88kbcs_vec) tb="$tb coff-m88k.lo" ;; +diff -ur --new-file binutils-2.21.51.0.7/bfd/libaout.h binutils-2.21.51.0.7-mint/bfd/libaout.h +--- binutils-2.21.51.0.7/bfd/libaout.h 2009-10-09 22:25:42.000000000 +0000 ++++ binutils-2.21.51.0.7-mint/bfd/libaout.h 2011-04-08 10:07:08.000000000 +0000 +@@ -422,6 +422,10 @@ + table, used when linking on SunOS. This is indexed by the symbol + index. */ + bfd_vma *local_got_offsets; ++ ++ /* A pointer for data used by aout extensions. (Currently only used ++ by MiNT executables (see prg-mint.c). */ ++ void *ext; + }; + + struct aout_data_struct +@@ -449,6 +453,7 @@ + #define obj_aout_string_window(bfd) (adata (bfd).string_window) + #define obj_aout_sym_hashes(bfd) (adata (bfd).sym_hashes) + #define obj_aout_dynamic_info(bfd) (adata (bfd).dynamic_info) ++#define obj_aout_ext(bfd) (adata (bfd).ext) + + /* We take the address of the first element of an asymbol to ensure that the + macro is only ever applied to an asymbol. */ +diff -ur --new-file binutils-2.21.51.0.7/bfd/prg-mint.c binutils-2.21.51.0.7-mint/bfd/prg-mint.c +--- binutils-2.21.51.0.7/bfd/prg-mint.c 1970-01-01 00:00:00.000000000 +0000 ++++ binutils-2.21.51.0.7-mint/bfd/prg-mint.c 2011-04-08 10:07:08.000000000 +0000 +@@ -0,0 +1,1732 @@ ++/* BFD backend for traditional MiNT executables. ++ Copyright 1998, 2007, 2008, 2009 Free Software Foundation, Inc. ++ Originally written by Guido Flohr (guido@freemint.de). ++ Modified by Vincent Riviere (vincent.riviere@freesbee.fr). ++ ++ This file is part of BFD, the Binary File Descriptor library. ++ ++ This program is free software; you can redistribute it and/or modify ++ it under the terms of the GNU General Public License as published by ++ the Free Software Foundation; either version 3 of the License, or ++ (at your option) any later version. ++ ++ This program is distributed in the hope that it will be useful, ++ but WITHOUT ANY WARRANTY; without even the implied warranty of ++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ GNU General Public License for more details. ++ ++ You should have received a copy of the GNU General Public License ++ along with this program; if not, write to the Free Software ++ Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, ++ MA 02110-1301, USA. */ ++ ++/* The format of executables on Atari is actually not a.out, it is ++ only chosen as an approach which comes close enough. The layout of a ++ program image on disk looked like this: ++ ++ +-----------------+ ++ | 28 Bytes Header | ++ +-----------------+ ++ | Text segment | ++ +-----------------+ ++ | Data segment | ++ +-----------------+ ++ | BSS | ++ +-----------------+ ++ | Symbol table | ++ +-----------------+ ++ | TPA relocation | ++ +-----------------+ ++ ++ The 28 byte exec header used to look like this: ++ ++ struct old_exec_header ++ { ++ bfd_byte a_magic[2]; ++ bfd_byte a_text[4]; ++ bfd_byte a_data[4]; ++ bfd_byte a_bss[4]; ++ bfd_byte a_syms[4]; ++ bfd_byte a_resvd[4]; ++ bfd_byte a_abs[2]; ++ }; ++ ++ The first two bytes (A_MAGIC) contained an assembler branch ++ instruction to the beginning of the text segment. Because the ++ exec header had a fixed size and the text entry point was constant ++ this assembler instruction also had a constant value (0x601a). ++ In fact the operating system never really executed the branch ++ instruction but used this value (0x601a) as a magic value. ++ ++ TEXT, DATA and BSS were as one would expect them. The symbol ++ table wasn't. Several different formats were in use, none of them ++ very efficient, none of them powerful enough to support source ++ level debugging. I've changed that and the GNU symbol table will ++ now be used instead (unless the --traditional-format option was ++ given to the linker). ++ ++ If the last member A_ABS of the exec header is zero the program ++ image contains an additional table with relocation information ++ at the end of the image. The kernel can load program images at ++ virtually any address in the address space. In fact it will load ++ it at the start of the biggest block of free memory. This block ++ is then called the Transient Program Area TPA and the image has ++ to be relocated against the TPA at runtime. The relocation info ++ itself is in a simply way compressed: It starts with a four-byte ++ value, the first address within the image to be relocated. Now ++ following are one-byte offsets to the last address. The special ++ value of 1 (which is impossible as an offset) signifies that 254 ++ has to be added to the next offset. The table is finished with ++ a zero-byte. ++ ++ I now simply extended the header from its old 28 bytes to 256 ++ bytes. The first 28 bytes give home to a standard Atari header, ++ the rest is for extensions. The extension header starts with ++ a ``real'' assembler instruction, a far jump to the text entry ++ point. The extension header gives home to a standard a.out ++ exec header (currently NMAGIC) plus some extra ++ more or less useful fields plus space to future extensions. ++ For the OS the extension header will already belong to the text ++ segment, for BFD backends the text segment is 228 (or 0xe4) ++ bytes smaller than for the OS. This explains for example the ++ funny TEXT_START_ADDR 0xe4. ++ ++ The TARGET_PAGE_SIZE is 2 which is only fake. There is currently ++ no such thing as memory paging on the Atari (and this is why ++ ZMAGICs are disabled for now to allow for future enhancements). ++ ++ If you think that this whole file looks quite like a big hack ++ you're probably right. But the results (mainly the output of ++ the linker) seem to work and they allow to use up-to-date ++ binutils on the Atari until a better executable format (maybe ++ ELF) has been established for this machine. */ ++ ++#include "sysdep.h" ++#include "bfd.h" ++ ++#define N_HEADER_IN_TEXT(x) 0 ++#define BYTES_IN_WORD 4 ++#define ENTRY_CAN_BE_ZERO ++#define N_SHARED_LIB(x) 0 ++#define TEXT_START_ADDR 0xe4 ++#define TARGET_PAGE_SIZE 2 ++#define TARGET_IS_BIG_ENDIAN_P ++#define DEFAULT_ARCH bfd_arch_m68k ++#define N_TXTADDR(x) TEXT_START_ADDR ++ ++/* Do not "beautify" the CONCAT* macro args. Traditional C will not ++ remove whitespace added here, and thus will fail to concatenate ++ the tokens. */ ++#define MY(OP) CONCAT2 (m68kmint_prg_,OP) ++#define TARGETNAME "a.out-mintprg" ++#define NAME(x,y) CONCAT3 (mintprg,_32_,y) ++ ++/* We have to do quite a lot of magic to make the Atari format ++ for GEMDOS executables fit into the standard a.out format. ++ We start with the original header. */ ++#define external_exec mint_external_exec ++struct mint_external_exec ++{ ++ bfd_byte g_branch[2]; /* 0x601a. */ ++ bfd_byte g_text[4]; /* Length of text section. */ ++ bfd_byte g_data[4]; /* Length of data section. */ ++ bfd_byte g_bss[4]; /* Length of bss section. */ ++ bfd_byte g_syms[4]; /* Length of symbol table. */ ++ bfd_byte g_extmagic[4]; /* Always 0x4d694e54 ++ (in ASCII: ``MiNT''). */ ++ bfd_byte g_flags[4]; /* Atari special flags. */ ++ bfd_byte g_abs[2]; /* Non-zero if absolute (no relocation ++ info. */ ++ ++ /* We extend this header now to provide the information that the ++ binutils want to see. Everything following will actually be part ++ of the text segment (from MiNT's point of view). As a ++ consequence the text section has 228 bytes of redundancy. ++ ++ The following eight bytes should be treated as opaque. ++ If the word ``opaque'' always attracts your curiosity in ++ typedefs and structs, here's the explanation: These eight bytes ++ are really two assembler instructions. The first one moves ++ the contents of e_entry into register d0, the second one ++ jumps (pc-relative) to the entry point. See swap_exec_header_out ++ for details. */ ++ bfd_byte g_jump_entry[8]; ++ ++ /* Now following a standard a.out header. Note that the values ++ may differ from the one given on top. The traditional header ++ contains the values that the OS wants to see, the values below ++ are the values that make the binutils work. */ ++ bfd_byte e_info[4]; /* Magic number and stuff. */ ++ bfd_byte e_text[4]; /* Length of text section in bytes. */ ++ bfd_byte e_data[4]; /* Length of data section. */ ++ bfd_byte e_bss[4]; /* Length of standard symbol ++ table. */ ++ bfd_byte e_syms[4]; /* Length of symbol table. */ ++ bfd_byte e_entry[4]; /* Start address. */ ++ bfd_byte e_trsize[4]; /* Length of text relocation ++ info. */ ++ bfd_byte e_drsize[4]; /* Length of data relocation ++ info. */ ++ ++ bfd_byte g_tparel_pos[4]; /* File position of TPA relative ++ relocation info. */ ++ bfd_byte g_tparel_size[4]; /* Length of TPA relative relocation ++ info. */ ++ ++ /* This is for extensions. */ ++ bfd_byte g_stkpos[4]; /* If stacksize is hardcoded into ++ the executable you will find it ++ at file offset g_stkpos. If ++ not this is NULL. */ ++ ++ bfd_byte g_symbol_format[4]; /* Format of the symbol table. See ++ definitions for _MINT_SYMBOL_FORMAT* ++ above. */ ++ ++ /* Pad with zeros. */ ++ bfd_byte g_pad0[172]; ++}; ++#define EXEC_BYTES_SIZE 256 ++#define GEMDOS_HEADER_SIZE 28 ++ ++/* The following defines are required by aoutx.h. ++ They are not automatically defined in aout/aout64.h ++ if external_exec is defined. */ ++ ++#define OMAGIC 0407 /* Object file or impure executable. */ ++#define NMAGIC 0410 /* Code indicating pure executable. */ ++#define ZMAGIC 0413 /* Code indicating demand-paged executable. */ ++#define BMAGIC 0415 /* Used by a b.out object. */ ++#define QMAGIC 0314 /* Like ZMAGIC but with N_HEADER_IN_TEXT true. */ ++ ++/* Files using the following magic flags will not be loaded. */ ++#define N_BADMAG(x) (N_MAGIC(x) != NMAGIC) ++ ++/* For DRI symbol table format. */ ++struct dri_symbol ++{ ++ bfd_byte a_name[8]; /* Symbol name */ ++ bfd_byte a_type[2]; /* Type flag, i.e. A_TEXT etc; see below. */ ++ bfd_byte a_value[4]; /* value of this symbol (or sdb offset). */ ++}; ++#define DRI_SYMBOL_SIZE 14 ++ ++/* Simple values for a_type. */ ++#define A_UNDF 0 ++#define A_BSS 0x0100 ++#define A_TEXT 0x0200 ++#define A_DATA 0x0400 ++#define A_EXT 0x0800 /* External. */ ++#define A_EQREG 0x1000 /* Equated register. */ ++#define A_GLOBL 0x2000 /* Global. */ ++#define A_EQU 0x4000 /* Equated. */ ++#define A_DEF 0x8000 /* Defined. */ ++#define A_LNAM 0x0048 /* GST compatible long name. */ ++ /* File symbols ala aln. */ ++#define A_TFILE 0x0280 /* Text file corresponding to object module. */ ++#define A_TFARC 0x02C0 /* Text file archive. Unfortunately this ++ conflicts with the bits in A_LNAM. */ ++ ++/* The following include contains the definitions for internal a.out structures ++ as well as the prototypes for the NAME(...) functions defined in aoutx.h. */ ++ ++#include "libaout.h" ++ ++/* The following function is similar to _bfd_final_link_relocate, except it ++ adds the reloc structure as an additional parameter. ++ It will be used int aoutx.h. */ ++ ++static bfd_reloc_status_type ++m68kmint_prg_final_link_relocate_rel (reloc_howto_type *howto, ++ bfd *input_bfd, ++ asection *input_section, ++ bfd_byte *contents, ++ bfd_vma address, ++ bfd_vma value, ++ bfd_vma addend, ++ struct reloc_std_external *rel); ++ ++#define MY_final_link_relocate_rel m68kmint_prg_final_link_relocate_rel ++ ++/* The following include contains the definitions for the NAME(...) functions. */ ++ ++#include "aoutx.h" ++ ++/* Data structure that holds some private information for us. */ ++struct mint_internal_info ++{ ++ struct bfd_link_info *linkinfo; /* Remembered from final_link. */ ++ bfd_boolean traditional_format; /* Saved from link info. */ ++ int symbol_format; /* Format of the symbol table. */ ++ void *tparel; /* Data for TPA relative relocation ++ information. */ ++ file_ptr tparel_pos; /* File position of TPA relative ++ relocation information. */ ++ bfd_size_type tparel_size; /* Size of TPA relative relocation ++ information. */ ++ bfd_size_type dri_symtab_size; /* Size of traditional symbol table. */ ++ ++#define MINT_RELOC_CHUNKSIZE 0x1000 ++ bfd_vma *relocs; /* Array of address relocations. */ ++ unsigned long relocs_used; /* Number of relocation entries ++ already used up. */ ++ unsigned long relocs_allocated; /* Number of relocation entries ++ allocated. */ ++ ++ bfd_vma stkpos; /* File offset to value of _stksize. */ ++ ++ flagword prg_flags; /* Standard GEMDOS flags. */ ++ ++ bfd_boolean override_stack_size; /* TRUE if the executable stack size ++ must be overriden with stack_size. */ ++ bfd_signed_vma stack_size; ++ ++ bfd_boolean reloc_error; /* TRUE if an unhandled error during ++ relocation occured. */ ++}; ++ ++/* If --traditional-format was given to the linker an old-style DRI ++ symbol table is written into the executable. This is with respect ++ to many old debugging tools or disassemblers which expect this format. ++ Although created by the linker, these symbols will be ignored from ++ input files. */ ++#define _MINT_SYMBOL_FORMAT_GNU 0 ++#define _MINT_SYMBOL_FORMAT_DRI 1 ++ ++/* Declarations for the variables and functions ++ defined later in aout-target.h. */ ++ ++static const bfd_target * ++m68kmint_prg_callback (bfd *abfd); ++ ++static void ++MY_final_link_callback (bfd *abfd, ++ file_ptr *ptreloff, ++ file_ptr *pdreloff, ++ file_ptr *psymoff); ++ ++extern const bfd_target m68kmint_prg_vec; ++ ++/* Initialize a new BFD using our file format. */ ++ ++#define MY_mkobject m68kmint_prg_mkobject ++ ++static bfd_boolean ++m68kmint_prg_mkobject (bfd *abfd) ++{ ++ struct mint_internal_info *myinfo; ++ ++ if (!NAME (aout, mkobject (abfd))) ++ return FALSE; ++ ++ /* Allocate our private BFD data. */ ++ myinfo = bfd_zalloc (abfd, sizeof (*myinfo)); ++ if (myinfo == NULL) ++ return FALSE; ++ obj_aout_ext (abfd) = myinfo; ++ ++ return TRUE; ++} ++ ++/* Finish up the reading of an a.out file header. */ ++ ++#define MY_object_p m68kmint_prg_object_p ++ ++static const bfd_target * ++m68kmint_prg_object_p (bfd *abfd) ++{ ++ struct external_exec exec_bytes; /* Raw exec header from file. */ ++ struct internal_exec exec; /* Cleaned-up exec header. */ ++ const bfd_target *target; ++ bfd_size_type amt = EXEC_BYTES_SIZE; ++ struct mint_internal_info *myinfo; ++ ++ /* Read the exec bytesd from the file. */ ++ if (bfd_bread (&exec_bytes, amt, abfd) != amt) ++ { ++ if (bfd_get_error () != bfd_error_system_call) ++ bfd_set_error (bfd_error_wrong_format); ++ return NULL; ++ } ++ ++ /* Instead of byte-swapping we compare bytes. */ ++ if (exec_bytes.g_branch[0] != 0x60 ++ || exec_bytes.g_branch[1] != 0x1a ++ || exec_bytes.g_extmagic[0] != 'M' ++ || exec_bytes.g_extmagic[1] != 'i' ++ || exec_bytes.g_extmagic[2] != 'N' ++ || exec_bytes.g_extmagic[3] != 'T') ++ { ++ bfd_set_error (bfd_error_wrong_format); ++ return NULL; ++ } ++ ++ /* Swap the standard a.out fields. */ ++ NAME (aout, swap_exec_header_in) (abfd, &exec_bytes, &exec); ++ ++ /* Check a.out magic value. */ ++ if (N_BADMAG (exec)) ++ { ++ bfd_set_error (bfd_error_wrong_format); ++ return NULL; ++ } ++ ++ /* Initialize this BFD with the exec values. */ ++ target = NAME (aout, some_aout_object_p) (abfd, &exec, m68kmint_prg_callback); ++ ++ /* Allocate our private BFD data. */ ++ myinfo = bfd_zalloc (abfd, sizeof (*myinfo)); ++ if (myinfo == NULL) ++ return NULL; ++ obj_aout_ext (abfd) = myinfo; ++ ++ /* Now get the missing information. */ ++ myinfo->prg_flags = bfd_h_get_32 (abfd, exec_bytes.g_flags); ++ myinfo->stkpos = bfd_h_get_32 (abfd, exec_bytes.g_stkpos); ++ myinfo->symbol_format = bfd_h_get_32 (abfd, exec_bytes.g_symbol_format); ++ ++ /* TPA relocation information. */ ++ myinfo->tparel_pos = bfd_h_get_32 (abfd, exec_bytes.g_tparel_pos); ++ myinfo->tparel_size = bfd_h_get_32 (abfd, exec_bytes.g_tparel_size); ++ ++ /* FIXME: Currently we always read the TPA relative relocation ++ information. This is suboptimal because often times there ++ is no need for it. Read it only if need be! Maybe this should ++ also depend on abfd->cacheable? */ ++ if (myinfo->tparel_size == 0) ++ myinfo->tparel = bfd_zalloc (abfd, 4); ++ else ++ myinfo->tparel = bfd_alloc (abfd, myinfo->tparel_size); ++ ++ if (myinfo->tparel == NULL) ++ return NULL; ++ ++ if (myinfo->tparel_size == 0) ++ { ++ myinfo->tparel_size = 4; ++ } ++ else ++ { ++ /* Read the information from the bfd. */ ++ if (bfd_seek (abfd, myinfo->tparel_pos, SEEK_SET) != 0 ++ || (bfd_bread (myinfo->tparel, myinfo->tparel_size, abfd) ++ != myinfo->tparel_size)) ++ return NULL; ++ } ++ ++ return target; ++} ++ ++/* Free all information we have cached for this BFD. We can always ++ read it again later if we need it. */ ++ ++#define MY_bfd_free_cached_info m68kmint_prg_bfd_free_cached_info ++ ++static bfd_boolean ++m68kmint_prg_bfd_free_cached_info (bfd *abfd) ++{ ++ struct mint_internal_info *myinfo = obj_aout_ext (abfd); ++ ++ if (myinfo != NULL && myinfo->relocs != NULL) ++ { ++ free (myinfo->relocs); ++ myinfo->relocs = NULL; ++ } ++ ++ /* myinfo itself has been allocated by bfd_zalloc() ++ so will be automatically freed along with the BFD. ++ Same for myinfo->tparel. */ ++ ++ return NAME (aout, bfd_free_cached_info) (abfd); ++} ++ ++/* Write a DRI symbol with TYPE and VALUE. If the NAME of the ++ symbol exceeds 8 characters write a long symbol. If it ++ exceeds 22 characters truncate the name. */ ++ ++static int ++write_dri_symbol (bfd *abfd, const char *name, int type, bfd_vma value) ++{ ++ int written_bytes = 0; ++ struct dri_symbol sym; ++ int is_long_name = strlen (name) > sizeof (sym.a_name); ++ ++ if (is_long_name) ++ type |= A_LNAM; ++ ++ strncpy ((char*)sym.a_name, name, sizeof (sym.a_name)); ++ bfd_put_16 (abfd, type, sym.a_type); ++ bfd_put_32 (abfd, value, sym.a_value); ++ ++ if (bfd_bwrite (&sym, DRI_SYMBOL_SIZE, abfd) != DRI_SYMBOL_SIZE) ++ return -1; ++ written_bytes += DRI_SYMBOL_SIZE; ++ ++ if (is_long_name) ++ { ++ char more_name[DRI_SYMBOL_SIZE]; ++ ++ strncpy (more_name, name + sizeof (sym.a_name), DRI_SYMBOL_SIZE); ++ ++ if (bfd_bwrite (more_name, DRI_SYMBOL_SIZE, abfd) != DRI_SYMBOL_SIZE) ++ return -1; ++ written_bytes += DRI_SYMBOL_SIZE; ++ } ++ ++ return written_bytes; ++} ++ ++/* Emit a traditional DRI symbol table while linking. ++ Most of this code comes from aout_link_write_symbols() in aoutx.h. */ ++ ++static bfd_boolean ++link_write_traditional_syms (bfd *abfd, struct bfd_link_info *info) ++{ ++ bfd *input_bfd; ++ enum bfd_link_strip strip = info->strip; ++ enum bfd_link_discard discard = info->discard; ++ struct mint_internal_info *myinfo = obj_aout_ext (abfd); ++ bfd *last_archive = NULL; ++ ++ /* Position file pointer. */ ++ if (bfd_seek (abfd, obj_sym_filepos (abfd), SEEK_SET) != 0) ++ return FALSE; ++ ++ myinfo->dri_symtab_size = 0; ++ ++ for (input_bfd = info->input_bfds; input_bfd != NULL; input_bfd = input_bfd->link_next) ++ { ++ bfd_size_type sym_count = obj_aout_external_sym_count (input_bfd); ++ char *strings = obj_aout_external_strings (input_bfd); ++ struct external_nlist *sym = obj_aout_external_syms (input_bfd); ++ struct external_nlist *sym_end = sym + sym_count; ++ struct aout_link_hash_entry **sym_hash = obj_aout_sym_hashes (input_bfd); ++ bfd_boolean pass = FALSE; ++ bfd_boolean skip = FALSE; ++ bfd_boolean skip_next = FALSE; ++ int written_bytes; ++ int a_type; ++ bfd_boolean write_archive_name = FALSE; ++ bfd_vma val = 0; ++ ++ /* First write out a symbol for the archive if we do not ++ strip these symbols and if it differs from the last ++ one. */ ++ if (input_bfd->my_archive != last_archive ++ && input_bfd->my_archive != NULL) ++ { ++ write_archive_name = TRUE; ++ last_archive = input_bfd->my_archive; ++ } ++ ++ if (write_archive_name ++ && strip != strip_all ++ && (strip != strip_some ++ || bfd_hash_lookup (info->keep_hash, ++ input_bfd->my_archive->filename, ++ FALSE, FALSE) != NULL) ++ && discard != discard_all) ++ { ++ val = bfd_get_section_vma (abfd, ++ obj_textsec (input_bfd)->output_section) ++ + obj_textsec (input_bfd)->output_offset; ++ ++ written_bytes = write_dri_symbol (abfd, ++ input_bfd->my_archive->filename, ++ A_TFILE, val); ++ ++ if (written_bytes < 0) ++ return FALSE; ++ else ++ myinfo->dri_symtab_size += written_bytes; ++ } ++ ++ /* Now write out a symbol for the object file if we do not ++ strip these symbols. */ ++ if (strip != strip_all ++ && (strip != strip_some ++ || bfd_hash_lookup (info->keep_hash, input_bfd->filename, ++ FALSE, FALSE) != NULL) ++ && discard != discard_all) ++ { ++ val = bfd_get_section_vma (abfd, ++ obj_textsec (input_bfd)->output_section) ++ + obj_textsec (input_bfd)->output_offset; ++ ++ written_bytes = write_dri_symbol (abfd, input_bfd->filename, ++ A_TFILE, val); ++ if (written_bytes < 0) ++ return FALSE; ++ else ++ myinfo->dri_symtab_size += written_bytes; ++ } ++ ++ /* Now we have a problem. All symbols that we see have already ++ been marked written (because we write them a second time ++ here. If we would do it the clean way we would have ++ to traverse the entire symbol map and reset the written ++ flag. We hack here instead... */ ++#define mark_written(h) (* (int *) &h->written = (int) TRUE + 1) ++#define is_written(h) ((int) h->written == (int) TRUE + 1) ++ for (; sym < sym_end; sym++, sym_hash++) ++ { ++ const char *name; ++ int type; ++ struct aout_link_hash_entry *h; ++ asection *symsec; ++ val = 0; ++ ++ type = H_GET_8 (input_bfd, sym->e_type); ++ name = strings + GET_WORD (input_bfd, sym->e_strx); ++ ++ h = NULL; ++ ++ if (pass) ++ { ++ /* Pass this symbol through. It is the target of an ++ indirect or warning symbol. */ ++ val = GET_WORD (input_bfd, sym->e_value); ++ pass = FALSE; ++ } ++ else if (skip_next) ++ { ++ /* Skip this symbol, which is the target of an indirect ++ symbol that we have changed to no longer be an indirect ++ symbol. */ ++ skip_next = FALSE; ++ continue; ++ } ++ else ++ { ++ struct aout_link_hash_entry *hresolve = *sym_hash; ++ ++ /* We have saved the hash table entry for this symbol, if ++ there is one. Note that we could just look it up again ++ in the hash table, provided we first check that it is an ++ external symbol. */ ++ h = *sym_hash; ++ ++ /* Use the name from the hash table, in case the symbol was ++ wrapped. */ ++ if (h != NULL ++ && h->root.type != bfd_link_hash_warning) ++ name = h->root.root.string; ++ ++ /* If this is an indirect or warning symbol, then change ++ hresolve to the base symbol. */ ++ hresolve = h; ++ if (h != (struct aout_link_hash_entry *) NULL ++ && (h->root.type == bfd_link_hash_indirect ++ || h->root.type == bfd_link_hash_warning)) ++ { ++ hresolve = (struct aout_link_hash_entry*) h->root.u.i.link; ++ while (hresolve->root.type == bfd_link_hash_indirect ++ || hresolve->root.type == bfd_link_hash_warning) ++ hresolve = ((struct aout_link_hash_entry*) ++ hresolve->root.u.i.link); ++ } ++ ++ /* If the symbol has already been written out skip it. */ ++ if (h != NULL ++ && is_written (h)) ++ { ++ if ((type & N_TYPE) == N_INDR ++ || type == N_WARNING) ++ skip_next = TRUE; ++ continue; ++ } ++ ++ /* See if we are stripping this symbol. */ ++ skip = FALSE; ++ ++ /* Skip all debugger symbols. No way to output them in ++ DRI format. This will also reduce a lot of headaches. */ ++ if ((type & N_STAB) != 0) ++ skip = TRUE; ++ ++ switch (strip) ++ { ++ case strip_none: ++ case strip_debugger: ++ break; ++ case strip_some: ++ if (bfd_hash_lookup (info->keep_hash, name, FALSE, FALSE) ++ == NULL) ++ skip = TRUE; ++ break; ++ case strip_all: ++ skip = TRUE; ++ break; ++ } ++ ++ if (skip) ++ { ++ if (h != NULL) ++ mark_written (h); ++ continue; ++ } ++ ++ /* Get the value of the symbol. */ ++ if ((type & N_TYPE) == N_TEXT ++ || type == N_WEAKT) ++ symsec = obj_textsec (input_bfd); ++ else if ((type & N_TYPE) == N_DATA ++ || type == N_WEAKD) ++ symsec = obj_datasec (input_bfd); ++ else if ((type & N_TYPE) == N_BSS ++ || type == N_WEAKB) ++ symsec = obj_bsssec (input_bfd); ++ else if ((type & N_TYPE) == N_ABS ++ || type == N_WEAKA) ++ symsec = bfd_abs_section_ptr; ++ else if (((type & N_TYPE) == N_INDR ++ && (hresolve == NULL ++ || (hresolve->root.type != bfd_link_hash_defined ++ && hresolve->root.type != bfd_link_hash_defweak ++ && hresolve->root.type != bfd_link_hash_common))) ++ || type == N_WARNING) ++ { ++ /* Pass the next symbol through unchanged. The ++ condition above for indirect symbols is so that if ++ the indirect symbol was defined, we output it with ++ the correct definition so the debugger will ++ understand it. */ ++ pass = TRUE; ++ val = GET_WORD (input_bfd, sym->e_value); ++ symsec = NULL; ++ } ++ else ++ { ++ /* If we get here with an indirect symbol, it means that ++ we are outputting it with a real definition. In such ++ a case we do not want to output the next symbol, ++ which is the target of the indirection. */ ++ if ((type & N_TYPE) == N_INDR) ++ skip_next = TRUE; ++ ++ symsec = NULL; ++ ++ /* We need to get the value from the hash table. We use ++ hresolve so that if we have defined an indirect ++ symbol we output the final definition. */ ++ if (h == NULL) ++ { ++ switch (type & N_TYPE) ++ { ++ case N_SETT: ++ symsec = obj_textsec (input_bfd); ++ break; ++ case N_SETD: ++ symsec = obj_datasec (input_bfd); ++ break; ++ case N_SETB: ++ symsec = obj_bsssec (input_bfd); ++ break; ++ case N_SETA: ++ symsec = bfd_abs_section_ptr; ++ break; ++ default: ++ val = 0; ++ break; ++ } ++ } ++ else if (hresolve->root.type == bfd_link_hash_defined ++ || hresolve->root.type == bfd_link_hash_defweak) ++ { ++ asection *input_section; ++ asection *output_section; ++ ++ /* This case usually means a common symbol which was ++ turned into a defined symbol. */ ++ input_section = hresolve->root.u.def.section; ++ output_section = input_section->output_section; ++ BFD_ASSERT (bfd_is_abs_section (output_section) ++ || output_section->owner == abfd); ++ ++ /* The following reference to the output section VMA ++ is commented out because DRI symbols are relative ++ to the beginning of the section. */ ++ val = (hresolve->root.u.def.value ++ /*+ bfd_get_section_vma (abfd, output_section)*/ ++ + input_section->output_offset); ++ ++ /* TEXT symbols values must be adjusted ++ by adding the size of the extended header. */ ++ if (output_section == obj_textsec (abfd)) ++ val += TEXT_START_ADDR; ++ ++ /* Get the correct type based on the section. If ++ this is a constructed set, force it to be ++ globally visible. */ ++ if (type == N_SETT ++ || type == N_SETD ++ || type == N_SETB ++ || type == N_SETA) ++ type |= N_EXT; ++ ++ type &=~ N_TYPE; ++ ++ if (output_section == obj_textsec (abfd)) ++ type |= N_TEXT; ++ else if (output_section == obj_datasec (abfd)) ++ type |= N_DATA; ++ else if (output_section == obj_bsssec (abfd)) ++ type |= N_BSS; ++ else ++ type |= N_ABS; ++ } ++ else if (hresolve->root.type == bfd_link_hash_common) ++ val = hresolve->root.u.c.size; ++ else if (hresolve->root.type == bfd_link_hash_undefweak) ++ { ++ val = 0; ++ type = N_UNDF; ++ } ++ else ++ val = 0; ++ } ++ if (symsec != NULL) ++ { ++ /* The following reference to the output section VMA ++ is commented out because DRI symbols are relative ++ to the beginning of the section. */ ++ val = (/*symsec->output_section->vma ++ +*/ symsec->output_offset ++ + (GET_WORD (input_bfd, sym->e_value) ++ - symsec->vma)); ++ ++ /* TEXT symbols values must be adjusted ++ by adding the size of the extended header. */ ++ if (symsec == obj_textsec (input_bfd)) ++ val += TEXT_START_ADDR; ++ } ++ ++ /* If this is a global symbol set the written flag, and if ++ it is a local symbol see if we should discard it. */ ++ if (h != NULL) ++ { ++ mark_written (h); ++ } ++ else if ((type & N_TYPE) != N_SETT ++ && (type & N_TYPE) != N_SETD ++ && (type & N_TYPE) != N_SETB ++ && (type & N_TYPE) != N_SETA) ++ { ++ switch (discard) ++ { ++ case discard_none: ++ case discard_sec_merge: ++ break; ++ case discard_l: ++ if (bfd_is_local_label_name (input_bfd, name)) ++ skip = TRUE; ++ break; ++ default: ++ case discard_all: ++ skip = TRUE; ++ break; ++ } ++ if (skip) ++ { ++ pass = FALSE; ++ continue; ++ } ++ } ++ } ++ ++ /* Now find the nearest type in DRI format. */ ++ switch (type) ++ { ++ case N_ABS: ++ case N_ABS | N_EXT: ++ case N_SETA: ++ case N_SETA | N_EXT: ++ case N_WEAKA: ++ a_type = A_EQU | A_DEF | A_GLOBL; ++ break; ++ case N_TEXT: ++ case N_TEXT | N_EXT: ++ case N_SETT: ++ case N_SETT | N_EXT: ++ case N_WEAKT: ++ a_type = A_TEXT | A_DEF | A_GLOBL; ++ break; ++ case N_DATA: ++ case N_DATA | N_EXT: ++ case N_SETD: ++ case N_SETD | N_EXT: ++ case N_WEAKD: ++ a_type = A_DATA | A_DEF | A_GLOBL; ++ break; ++ case N_BSS: ++ case N_BSS | N_EXT: ++ case N_SETB: ++ case N_SETB | N_EXT: ++ case N_WEAKB: ++ a_type = A_BSS | A_DEF | A_GLOBL; ++ break; ++ default: ++ continue; ++ } ++ ++ written_bytes = write_dri_symbol (abfd, name, a_type, val); ++ if (written_bytes < 0) ++ return FALSE; ++ ++ myinfo->dri_symtab_size += written_bytes; ++ } ++ } ++ ++ obj_aout_external_string_size (abfd) = 0; ++ return TRUE; ++} ++ ++/* This is used for qsort() to sort addresses ++ for the TPA relocation table. */ ++ ++static int ++vma_cmp (const void *v1, const void *v2) ++{ ++ return (int) ((*((bfd_vma *) v1)) - (*((bfd_vma *) v2))); ++} ++ ++/* Alloc and fill the TPA relocation table. */ ++ ++static bfd_boolean ++fill_tparel (bfd *abfd) ++{ ++ struct mint_internal_info *myinfo = obj_aout_ext (abfd); ++ unsigned long i; ++ bfd_size_type bytes; ++ unsigned char *ptr; ++ ++ /* Sort the relocation info. */ ++ if (myinfo->relocs != NULL) ++ qsort (myinfo->relocs, myinfo->relocs_used, sizeof (bfd_vma), ++ vma_cmp); ++ ++ /* Now calculate the number of bytes we need. The relocation info ++ is encoded as follows: The first entry is a 32-bit value ++ denoting the first offset to relocate. All following entries ++ are relative to the preceding one. For relative offsets of ++ more than 254 bytes a value of 1 is used. The OS will then ++ add 254 bytes to the current offset. The list is then terminated ++ with the byte 0. */ ++ bytes = 4; /* First entry is a long. */ ++ for (i = 1; i < myinfo->relocs_used; i++) ++ { ++ unsigned long diff = myinfo->relocs[i] - myinfo->relocs[i - 1]; ++ BFD_ASSERT(diff > 0); ++ bytes += (diff + 253) / 254; ++ } ++ /* Last entry is (bfd_byte) 0 if there are some relocations. */ ++ if (myinfo->relocs_used > 0) ++ bytes++; ++ ++ myinfo->tparel_size = bytes; ++ myinfo->tparel = bfd_alloc (abfd, bytes); ++ if (myinfo->tparel == NULL) ++ return FALSE; ++ ++ /* Now fill the array. */ ++ ptr = (bfd_byte*) myinfo->tparel; ++ if (myinfo->relocs != NULL) ++ bfd_put_32 (abfd, myinfo->relocs[0], ptr); ++ else ++ bfd_put_32 (abfd, 0, ptr); ++ ptr += 4; ++ ++ for (i = 1; i < myinfo->relocs_used; i++) ++ { ++ unsigned long diff = myinfo->relocs[i] - myinfo->relocs[i - 1]; ++ while (diff > 254) ++ { ++ *ptr++ = 1; ++ diff -= 254; ++ } ++ *ptr++ = (bfd_byte) diff; ++ } ++ ++ if (myinfo->relocs_used > 0) ++ *ptr = 0; ++ ++ return TRUE; ++} ++ ++/* Final link routine. We need to use a call back to get the correct ++ offsets in the output file. And we need to malloc some internal ++ buffers. */ ++ ++#define MY_bfd_final_link m68kmint_prg_bfd_final_link ++ ++static bfd_boolean ++m68kmint_prg_bfd_final_link (bfd *abfd, struct bfd_link_info *info) ++{ ++ struct mint_internal_info *myinfo = obj_aout_ext (abfd); ++ struct bfd_link_hash_table *hash = info->hash; ++ enum bfd_link_strip original_strip = info->strip; ++ ++ if (info->relocatable) ++ { ++ _bfd_error_handler ("%B: relocatable output is not supported by format %s", ++ abfd, bfd_get_target (abfd)); ++ bfd_set_error (bfd_error_invalid_operation); ++ return FALSE; ++ } ++ ++ myinfo->linkinfo = info; ++ ++ /* Make sure that for now we never write zmagics. */ ++ abfd->flags &= ~D_PAGED; ++ ++ /* Find the __stksize symbol. This symbol is used for a MiNT ++ special kludge. The libc defines this symbol in an object file ++ initialized to a default value to make sure it is defined in ++ every output file. The start-up code in crtinit() then simply ++ sets the stacksize accordingly. In your programs (if they need ++ an unusual stacksize) you can then simply code: ++ ++ long _stksize = 0x2000; ++ ++ This will create a program stack of 2k. Since MiNT cannot detect ++ a stack overflow this is the only way to prevent program crashes ++ caused by a stack that is too small. ++ ++ The ancient linker ignored this feature, the ancient strip ++ program paid heed to it. By default, strip never stripped this ++ special symbol from the binary. ++ ++ Another program called ``printstk'' and its colleague ``fixstk'' ++ could be used to either print the current value of the stacksize ++ or to modify it without recompiling and rebuilding. These ++ programs traversed the symbol table and then took the appropriate ++ measures if the symbol was found. ++ ++ Here we do a different approach. Since we already expanded the ++ standard executable header we now hardcode the address (as a file ++ offset) that the __stksize symbol points to into the header. We ++ can now let strip safely remove the entry from the symbol table ++ and we're not dependent on a special format of the symbol table. ++ Because the address is kept in the header we will always be able ++ to manipulate the stacksize value later. */ ++ if (hash != NULL) ++ { ++ struct aout_link_hash_entry *h = ++ aout_link_hash_lookup (aout_hash_table (info), "__stksize", ++ FALSE, FALSE, FALSE); ++ asection *sec; ++ ++ if (h != NULL) ++ { ++ switch (h->root.type) ++ { ++ case bfd_link_hash_defined: ++ case bfd_link_hash_defweak: ++ sec = h->root.u.def.section->output_section; ++ BFD_ASSERT (sec->owner == abfd); ++ ++ myinfo->stkpos = (h->root.u.def.value + sec->vma ++ + h->root.u.def.section->output_offset ++ + GEMDOS_HEADER_SIZE); ++ break; ++ default: /* Ignore other types. */ ++ break; ++ } ++ } ++ } ++ ++ if ((abfd->flags & BFD_TRADITIONAL_FORMAT) != 0) ++ { ++ myinfo->traditional_format = TRUE; ++ myinfo->symbol_format = _MINT_SYMBOL_FORMAT_DRI; ++ } ++ ++ /* Unconditionally unset the traditional flag. The only effect in ++ the a.out code is to disable string hashing (with respect to ++ SunOS gdx). This is not necessary for us. */ ++ ++ abfd->flags &= ~BFD_TRADITIONAL_FORMAT; ++ ++ /* Do not write GNU symbols in traditional format. */ ++ if (myinfo->traditional_format) ++ info->strip = strip_all; ++ ++ if (NAME(aout,final_link) (abfd, info, MY_final_link_callback) ++ != TRUE) ++ return FALSE; ++ ++ if (myinfo->reloc_error) ++ return FALSE; ++ ++ /* Restore the strip status for the traditional symbols. */ ++ info->strip = original_strip; ++ ++ if (myinfo->traditional_format ++ && link_write_traditional_syms (abfd, info) != TRUE) ++ return FALSE; ++ ++ if (fill_tparel (abfd) != TRUE) ++ return FALSE; ++ ++ return TRUE; ++} ++ ++/* Copy private BFD header information from the input BFD. */ ++ ++#define MY_bfd_copy_private_header_data m68kmint_prg_bfd_copy_private_header_data ++ ++static bfd_boolean ++m68kmint_prg_bfd_copy_private_header_data (bfd *ibfd, bfd *obfd) ++{ ++ (void)obfd; /* Unused. */ ++ ++ /* We can only copy BFD files using our own file format. */ ++ if (ibfd->xvec != &m68kmint_prg_vec) ++ { ++ _bfd_error_handler ("%B: cannot convert from format %s to format %s", ++ ibfd, bfd_get_target (ibfd), bfd_get_target (obfd)); ++ bfd_set_error (bfd_error_invalid_operation); ++ return FALSE; ++ } ++ ++ return TRUE; ++} ++ ++/* Copy backend specific data from one object module to another. ++ This function is used by objcopy and strip. */ ++ ++#define MY_bfd_copy_private_bfd_data m68kmint_prg_bfd_copy_private_bfd_data ++ ++static bfd_boolean ++m68kmint_prg_bfd_copy_private_bfd_data (bfd *ibfd, bfd *obfd) ++{ ++ struct mint_internal_info *myinfo_in; ++ struct mint_internal_info *myinfo_out; ++ ++ /* obfd uses our file format, ibfd may be foreign. */ ++ if (ibfd->xvec != &m68kmint_prg_vec) ++ return TRUE; ++ ++ myinfo_in = obj_aout_ext (ibfd); ++ BFD_ASSERT (myinfo_in != NULL); ++ ++ myinfo_out = obj_aout_ext (obfd); ++ BFD_ASSERT (myinfo_out != NULL); ++ ++ /* Copy myinfo. */ ++ memcpy (myinfo_out, myinfo_in, sizeof (*myinfo_out)); ++ ++ /* Copy tparel. */ ++ myinfo_out->tparel = bfd_alloc (obfd, myinfo_out->tparel_size); ++ if (myinfo_out->tparel == NULL) ++ return FALSE; ++ memcpy (myinfo_out->tparel, myinfo_in->tparel, myinfo_out->tparel_size); ++ ++ /* Normalize the type of empty symbols. */ ++ if (bfd_get_symcount (obfd) == 0) ++ myinfo_out->symbol_format = _MINT_SYMBOL_FORMAT_GNU; ++ ++ return TRUE; /* _bfd_generic_bfd_copy_private_bfd_data (ibfd, obfd); */ ++} ++ ++/* Merge private BFD information from an input BFD to the output BFD when linking. */ ++ ++#define MY_bfd_merge_private_bfd_data m68kmint_prg_merge_private_bfd_data ++ ++static bfd_boolean ++m68kmint_prg_merge_private_bfd_data (bfd *ibfd, bfd *obfd) ++{ ++ (void)obfd; /* Unused. */ ++ ++ /* Our file format cannot be used as linker input. */ ++ if (ibfd->xvec == &m68kmint_prg_vec) ++ { ++ _bfd_error_handler ("%B: file format %s cannot be used as linker input", ++ ibfd, bfd_get_target (ibfd)); ++ bfd_set_error (bfd_error_invalid_operation); ++ return FALSE; ++ } ++ ++ return TRUE; /* _bfd_generic_bfd_merge_private_bfd_data (ibfd, obfd); */ ++} ++ ++/* Find out the symbol name. */ ++ ++static const char * ++find_symbol_name (reloc_howto_type *howto, bfd *input_bfd, ++ bfd_byte *location, struct reloc_std_external *rel) ++{ ++ struct external_nlist *syms = obj_aout_external_syms (input_bfd); ++ char *strings = obj_aout_external_strings (input_bfd); ++ struct aout_link_hash_entry **sym_hashes ++ = obj_aout_sym_hashes (input_bfd); ++ struct aout_link_hash_entry *h = NULL; ++ const char *name; ++ bfd_size_type r_index; ++ int r_extern; ++ ++ if (bfd_get_reloc_size (howto) != 4) ++ return "(not a symbol)"; ++ ++ /* The input bfd is always big-endian. There is no need to ++ call bfd_header_big_endian (input_bfd). */ ++ r_index = ((rel->r_index[0] << 16) ++ | (rel->r_index[1] << 8) ++ | (rel->r_index[2])); ++ r_extern = (0 != (rel->r_type[0] & RELOC_STD_BITS_EXTERN_BIG)); ++ ++ if (sym_hashes != NULL) ++ h = sym_hashes[r_index]; ++ ++ if (!r_extern) ++ { ++ bfd_size_type i; ++ bfd_vma wanted_value = bfd_get_32 (input_bfd, location); ++ ++ name = NULL; ++ for (i = 0; i < obj_aout_external_sym_count (input_bfd); i++) ++ { ++ bfd_vma this_value = bfd_get_32 (input_bfd, syms[i].e_value); ++ ++ if (this_value == wanted_value) ++ { ++ bfd_byte symtype = bfd_get_8 (input_bfd, syms[i].e_type); ++ ++ /* Skip debug symbols and the like. */ ++ if ((symtype & N_STAB) != 0) ++ continue; ++ ++ /* This is dirty but preferable to a plethoria of ++ single comparisons. */ ++ if (symtype <= (N_BSS | N_EXT) ++ || (symtype >= N_WEAKU && symtype <= N_COMM)) ++ { ++ name = strings + GET_WORD (input_bfd, syms[i].e_strx); ++ break; ++ } ++ } ++ } ++ ++ /* FIXME: If the relocation is against a section there is ++ probably a symbol for that section floating around somewhere ++ in the bfd jungle. */ ++ if (name == NULL) ++ { ++ switch ((r_index & N_TYPE) & ~N_EXT) ++ { ++ case N_TEXT: ++ name = "text section"; ++ break; ++ case N_DATA: ++ name = "data section"; ++ break; ++ case N_BSS: ++ name = "bss section"; ++ break; ++ case N_ABS: ++ name = "absolute section"; ++ break; ++ default: ++ name = "unknown section"; ++ break; ++ } ++ } ++ } ++ else if (h != NULL) ++ name = h->root.root.string; ++ else if (r_index >= obj_aout_external_sym_count (input_bfd)) ++ name = "(unknown symbol)"; /* Shouldn't happen. */ ++ else ++ name = strings + GET_WORD (input_bfd, syms[r_index].e_strx); ++ ++ return name; ++} ++ ++/* This relocation routine is used by some of the backend linkers. ++ They do not construct asymbol or arelent structures, so there is no ++ reason for them to use bfd_perform_relocation. Also, ++ bfd_perform_relocation is so hacked up it is easier to write a new ++ function than to try to deal with it. ++ ++ This routine does a final relocation. Whether it is useful for a ++ relocatable link depends upon how the object format defines ++ relocations. ++ ++ FIXME: This routine ignores any special_function in the HOWTO, ++ since the existing special_function values have been written for ++ bfd_perform_relocation. ++ ++ HOWTO is the reloc howto information. ++ INPUT_BFD is the BFD which the reloc applies to. ++ INPUT_SECTION is the section which the reloc applies to. ++ CONTENTS is the contents of the section. ++ ADDRESS is the address of the reloc within INPUT_SECTION. ++ VALUE is the value of the symbol the reloc refers to. ++ ADDEND is the addend of the reloc. */ ++ ++/* The additional parameter REL is specific to this backend. ++ This function is derived from _bfd_final_link_relocate() ++ found in reloc.c. It adds additional checking for dangerous ++ relocations in MiNT sharable text sections, then it records ++ the relocated offset in myinfo->relocs[] for further processing. */ ++ ++static bfd_reloc_status_type ++m68kmint_prg_final_link_relocate_rel (reloc_howto_type *howto, ++ bfd *input_bfd, ++ asection *input_section, ++ bfd_byte *contents, ++ bfd_vma address, ++ bfd_vma value, ++ bfd_vma addend, ++ struct reloc_std_external *rel) ++{ ++ bfd_vma relocation; ++ bfd *output_bfd = input_section->output_section->owner; ++ struct mint_internal_info *myinfo = obj_aout_ext (output_bfd); ++ bfd_reloc_status_type retval; ++ int r_index; ++ int r_extern; ++ bfd_boolean need_tpa_relocation; ++ ++ /* The input bfd is always big-endian. There is no need to ++ call bfd_header_big_endian (input_bfd). */ ++ r_index = ((rel->r_index[0] << 16) ++ | (rel->r_index[1] << 8) ++ | (rel->r_index[2])); ++ r_extern = (0 != (rel->r_type[0] & RELOC_STD_BITS_EXTERN_BIG)); ++ ++#define _MINT_F_SHTEXT 0x800 ++ ++ /* Sanity check the address. */ ++ if (address > bfd_get_section_limit (input_bfd, input_section)) ++ return bfd_reloc_outofrange; ++ ++ /* This function assumes that we are dealing with a basic relocation ++ against a symbol. We want to compute the value of the symbol to ++ relocate to. This is just VALUE, the value of the symbol, plus ++ ADDEND, any addend associated with the reloc. */ ++ relocation = value + addend; ++ ++ /* Check for dangerous relocations in images with a sharable ++ text section. */ ++ if ((myinfo->prg_flags & _MINT_F_SHTEXT) != 0 ++ && bfd_get_reloc_size (howto) == 4) ++ { ++ bfd_boolean error_found = FALSE; ++ const char *name = NULL; ++ ++ if (input_section == obj_textsec (input_bfd)) ++ { ++ if (!r_extern) ++ { ++ /* This is a relocation against another section. Only ++ relocations against the text section are allowed. */ ++ if (r_index != N_TEXT && r_index != (N_TEXT | N_EXT)) ++ error_found = TRUE; ++ } ++ else if (relocation > (input_section->output_section->vma ++ + input_section->output_section->size)) ++ { ++ error_found = TRUE; ++ } ++ else if (relocation == (input_section->output_section->vma ++ + input_section->output_section->size)) ++ { ++ name = find_symbol_name (howto, input_bfd, ++ contents + address, ++ rel); ++ if (strcmp (name, "_etext") == 0) ++ error_found = FALSE; ++ } ++ } ++ ++ if (error_found) ++ { ++ const struct bfd_link_callbacks *callbacks ++ = myinfo->linkinfo->callbacks; ++ ++ myinfo->reloc_error = TRUE; ++ ++ if (callbacks->reloc_dangerous != NULL) ++ { ++ if (name == NULL) ++ name = find_symbol_name (howto, input_bfd, ++ contents + address, ++ rel); ++ ++ callbacks->reloc_dangerous (myinfo->linkinfo, name, ++ input_bfd, ++ input_section, address); ++ } ++ } ++ } ++ ++ /* If the relocation is PC relative, we want to set RELOCATION to ++ the distance between the symbol (currently in RELOCATION) and the ++ location we are relocating. Some targets (e.g., i386-aout) ++ arrange for the contents of the section to be the negative of the ++ offset of the location within the section; for such targets ++ pcrel_offset is FALSE. Other targets (e.g., m88kbcs or ELF) ++ simply leave the contents of the section as zero; for such ++ targets pcrel_offset is TRUE. If pcrel_offset is FALSE we do not ++ need to subtract out the offset of the location within the ++ section (which is just ADDRESS). */ ++ if (howto->pc_relative) ++ { ++ relocation -= (input_section->output_section->vma ++ + input_section->output_offset); ++ if (howto->pcrel_offset) ++ relocation -= address; ++ } ++ ++ retval = _bfd_relocate_contents (howto, input_bfd, relocation, ++ contents + address); ++ ++ /* The symbol has to be relocated again iff the length of the relocation ++ is 2 words and it is not pc relative. */ ++ need_tpa_relocation = FALSE; ++ if (!howto->pc_relative && bfd_get_reloc_size (howto) == 4) ++ { ++ if (r_extern) ++ { ++ struct aout_link_hash_entry **sym_hashes = obj_aout_sym_hashes (input_bfd); ++ struct aout_link_hash_entry *h = sym_hashes[r_index]; ++ asection *output_section = h->root.u.def.section->output_section; ++ ++ /* Do not relocate absolute symbols. */ ++ if (output_section == obj_textsec (output_bfd) ++ || output_section == obj_datasec (output_bfd) ++ || output_section == obj_bsssec (output_bfd)) ++ { ++ need_tpa_relocation = TRUE; ++ } ++ } ++ else ++ { ++ need_tpa_relocation = TRUE; ++ } ++ } ++ ++ /* Here we add the TPA relocation entries for the address references ++ located inside the input sections. Note that if some references ++ to addresses are generated using data statements in the linker ++ script, they will not be relocated here because they do not ++ belong to any input section. */ ++ if (need_tpa_relocation) ++ { ++ bfd_vma tpa_address = input_section->output_section->vma ++ + input_section->output_offset + address; ++ ++ if (!bfd_m68kmint_add_tpa_relocation_entry(output_bfd, tpa_address)) ++ return bfd_reloc_other; ++ } ++ ++ return retval; ++} ++ ++/* Write out the TPA relocation table. */ ++ ++static bfd_boolean ++write_tparel (bfd *abfd, struct internal_exec *execp) ++{ ++ struct mint_internal_info* myinfo = obj_aout_ext (abfd); ++ ++ if (myinfo->dri_symtab_size == 0) ++ myinfo->tparel_pos = N_STROFF (*execp) ++ + obj_aout_external_string_size (abfd); ++ else ++ myinfo->tparel_pos = N_SYMOFF (*execp) ++ + myinfo->dri_symtab_size; ++ ++ if (bfd_seek (abfd, myinfo->tparel_pos, SEEK_SET) != 0) ++ return FALSE; ++ ++ if (bfd_bwrite (myinfo->tparel, myinfo->tparel_size, abfd) ++ != myinfo->tparel_size) ++ return FALSE; ++ ++ return TRUE; ++} ++ ++/* Write the full exec header. ++ This function must be called last to ensure that we have all the ++ information needed to fill the MiNT-specific header fields. */ ++ ++static bfd_boolean ++write_exec_header (bfd *abfd, struct internal_exec *execp, struct external_exec *exec_bytes) ++{ ++ struct mint_internal_info *myinfo = obj_aout_ext (abfd); ++ bfd_size_type symtab_size; ++ ++ bfd_h_put_16 (abfd, 0x601a, exec_bytes->g_branch); ++ ++ /* The OS will load our extension header fields into the text segment. */ ++ bfd_h_put_32 (abfd, execp->a_text + (EXEC_BYTES_SIZE - GEMDOS_HEADER_SIZE), ++ exec_bytes->g_text); ++ bfd_h_put_32 (abfd, execp->a_data, exec_bytes->g_data); ++ bfd_h_put_32 (abfd, execp->a_bss, exec_bytes->g_bss); ++ ++ /* The OS' notion of the size of the symbol table is another than ++ the bfd library's. We have to fill in the size of the table ++ itself plus the size of the string table but only if we have not written ++ a traditional symbol table. If we have written a traditional symbol ++ table we know the size. */ ++ if (myinfo->dri_symtab_size != 0) ++ symtab_size = myinfo->dri_symtab_size; ++ else ++ symtab_size = myinfo->tparel_pos - N_SYMOFF (*execp); ++ ++ bfd_h_put_32 (abfd, symtab_size, exec_bytes->g_syms); ++ ++ bfd_h_put_32 (abfd, 0x4d694e54, exec_bytes->g_extmagic); ++ bfd_h_put_32 (abfd, myinfo->prg_flags, exec_bytes->g_flags); ++ bfd_h_put_16 (abfd, 0, exec_bytes->g_abs); ++ ++ /* Generate the jump instruction to the entry point. In m68k ++ assembler mnemnonics it looks more or less like this: ++ ++ move.l exec_bytes->e_entry(pc),d0 ++ jmp -6(pc,d0.l) ++ ++ Sorry for the wrong syntax. As a real assembler addict I ++ never actually use an assembler. I edit my binaries manually ++ with a hex editor, looks much cooler and it strengthens your ++ abstraction abilities. */ ++ ++ exec_bytes->g_jump_entry[0] = 0x20; ++ exec_bytes->g_jump_entry[1] = 0x3a; ++ exec_bytes->g_jump_entry[2] = 0x00; ++ exec_bytes->g_jump_entry[3] = 0x1a; ++ exec_bytes->g_jump_entry[4] = 0x4e; ++ exec_bytes->g_jump_entry[5] = 0xfb; ++ exec_bytes->g_jump_entry[6] = 0x08; ++ exec_bytes->g_jump_entry[7] = 0xfa; ++ ++ bfd_h_put_32 (abfd, myinfo->tparel_pos, exec_bytes->g_tparel_pos); ++ bfd_h_put_32 (abfd, myinfo->tparel_size, exec_bytes->g_tparel_size); ++ bfd_h_put_32 (abfd, myinfo->stkpos, exec_bytes->g_stkpos); ++ ++ /* If there are no symbols, pretend they are in GNU format. */ ++ if (symtab_size == 0) ++ myinfo->symbol_format = _MINT_SYMBOL_FORMAT_GNU; ++ ++ bfd_h_put_32 (abfd, myinfo->symbol_format, exec_bytes->g_symbol_format); ++ ++ memset (&exec_bytes->g_pad0, 0, sizeof (exec_bytes->g_pad0)); ++ ++ /* The standard stuff. */ ++ NAME(aout, swap_exec_header_out) (abfd, execp, exec_bytes); ++ if (myinfo->symbol_format != _MINT_SYMBOL_FORMAT_GNU) ++ PUT_WORD (abfd, 0, exec_bytes->e_syms); ++ ++ if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0) ++ return FALSE; ++ ++ if (bfd_bwrite (exec_bytes, (bfd_size_type) EXEC_BYTES_SIZE, abfd) ++ != EXEC_BYTES_SIZE) ++ return FALSE; ++ ++ /* Override the stack size. */ ++ if (myinfo->override_stack_size && myinfo->stkpos) ++ { ++ bfd_byte big_endian_stack_size[4]; ++ ++ bfd_put_32 (abfd, myinfo->stack_size, &big_endian_stack_size); ++ ++ if (bfd_seek (abfd, (file_ptr) myinfo->stkpos, SEEK_SET) != 0) ++ return FALSE; ++ ++ if (bfd_bwrite (big_endian_stack_size, 4, abfd) != 4) ++ return FALSE; ++ } ++ ++ return TRUE; ++} ++ ++/* Write an object file. ++ Section contents have already been written. We write the ++ file header, symbols, and relocation. */ ++ ++#define MY_write_object_contents m68kmint_prg_write_object_contents ++ ++static bfd_boolean ++m68kmint_prg_write_object_contents (bfd *abfd) ++{ ++ struct external_exec exec_bytes; ++ struct internal_exec *execp = exec_hdr (abfd); ++ bfd_size_type text_size; ++ file_ptr text_end; ++ ++ BFD_ASSERT (obj_aout_ext (abfd) != NULL); ++ ++ obj_reloc_entry_size (abfd) = RELOC_STD_SIZE; ++ ++ /* Most of the following code come from the WRITE_HEADERS macro ++ found in libaout.h. */ ++ ++ if (adata(abfd).magic == undecided_magic) ++ NAME (aout, adjust_sizes_and_vmas) (abfd, & text_size, & text_end); ++ ++ execp->a_syms = bfd_get_symcount (abfd) * EXTERNAL_NLIST_SIZE; ++ execp->a_entry = bfd_get_start_address (abfd); ++ ++ execp->a_trsize = ((obj_textsec (abfd)->reloc_count) * ++ obj_reloc_entry_size (abfd)); ++ execp->a_drsize = ((obj_datasec (abfd)->reloc_count) * ++ obj_reloc_entry_size (abfd)); ++ ++ /* Now write out reloc info, followed by syms and strings. */ ++ ++ if (bfd_get_outsymbols (abfd) != NULL ++ && bfd_get_symcount (abfd) != 0) ++ { ++ if (bfd_seek (abfd, (file_ptr) (N_SYMOFF(*execp)), SEEK_SET) != 0) ++ return FALSE; ++ ++ if (! NAME (aout, write_syms) (abfd)) ++ return FALSE; ++ } ++ ++ if (bfd_seek (abfd, (file_ptr) (N_TRELOFF (*execp)), SEEK_SET) != 0) ++ return FALSE; ++ if (!NAME (aout, squirt_out_relocs) (abfd, obj_textsec (abfd))) ++ return FALSE; ++ ++ if (bfd_seek (abfd, (file_ptr) (N_DRELOFF (*execp)), SEEK_SET) != 0) ++ return FALSE; ++ if (!NAME (aout, squirt_out_relocs) (abfd, obj_datasec (abfd))) ++ return FALSE; ++ ++ if (write_tparel (abfd, execp) != TRUE) ++ return FALSE; ++ ++ if (write_exec_header (abfd, execp, &exec_bytes) != TRUE) ++ return FALSE; ++ ++ return TRUE; ++} ++ ++/* Print private BFD data. Used by objdump -p. */ ++ ++#define MY_bfd_print_private_bfd_data m68kmint_prg_print_private_bfd_data ++ ++static bfd_boolean ++m68kmint_prg_print_private_bfd_data (bfd *abfd, void *ptr) ++{ ++ FILE *file = (FILE *) ptr; ++ struct mint_internal_info *myinfo = obj_aout_ext (abfd); ++ const char* symbol_format; ++ long stksize = 0; ++ ++ fprintf (file, "\n"); ++ ++ fprintf (file, " GEMDOS flags: 0x%08lx\n", (unsigned long) myinfo->prg_flags); ++ fprintf (file, "Start address: 0x%08lx\n", bfd_get_start_address (abfd)); ++ ++ /* Stack size. */ ++ if (myinfo->stkpos != 0) ++ { ++ if (bfd_seek (abfd, myinfo->stkpos, SEEK_SET) != 0 ++ || (bfd_bread (&stksize, sizeof(long), abfd) != sizeof(long))) ++ return FALSE; ++ ++ stksize = bfd_get_signed_32 (abfd, &stksize); ++ } ++ fprintf (file, " Stack size: %ld\n", stksize); ++ ++ /* Symbol format. */ ++ switch (myinfo->symbol_format) ++ { ++ case _MINT_SYMBOL_FORMAT_GNU: symbol_format = "stabs"; break; ++ case _MINT_SYMBOL_FORMAT_DRI: symbol_format = "DRI"; break; ++ default: symbol_format = "?"; break; ++ } ++ fprintf (file, "Symbol format: %s\n", symbol_format); ++ ++ return TRUE; ++} ++ ++/* Special case for NAME (aout, get_section_contents) ++ It is not declared in libaout.h, neither implemented in aoutx.h. ++ Instead, a macro named aout_32_get_section_contents is defined in libaout.h. ++ So the default value of MY_get_section_contents provided by aout-target.h ++ is not correct, it has to be defined here with the right value. */ ++ ++#define MY_get_section_contents aout_32_get_section_contents ++ ++/* The following include will define m68kmint_prg_vec ++ and a default implementation for all the MY_ functions ++ not overriden here. */ ++ ++#include "aout-target.h" ++ ++/* Set the GEMDOS executable flags. ++ It is called by the linker emulation script. */ ++ ++bfd_boolean ++bfd_m68kmint_set_extended_flags (bfd *abfd, flagword prg_flags) ++{ ++ struct mint_internal_info *myinfo; ++ ++ BFD_ASSERT(abfd->xvec == &m68kmint_prg_vec); ++ myinfo = obj_aout_ext (abfd); ++ BFD_ASSERT(myinfo != NULL); ++ ++ myinfo->prg_flags = prg_flags; ++ ++ return TRUE; ++} ++ ++/* Override the stack size. ++ It is called by the linker emulation script. */ ++ ++bfd_boolean ++bfd_m68kmint_set_stack_size (bfd *abfd, bfd_signed_vma stack_size) ++{ ++ struct mint_internal_info *myinfo; ++ ++ BFD_ASSERT(abfd->xvec == &m68kmint_prg_vec); ++ myinfo = obj_aout_ext (abfd); ++ BFD_ASSERT(myinfo != NULL); ++ ++ myinfo->stack_size = stack_size; ++ myinfo->override_stack_size = TRUE; ++ ++ return TRUE; ++} ++ ++/* Add a TPA relocation entry. ++ It is called by BFD when linking the input sections, and by the ++ linker when it generates a reference to an address (in particular, ++ when building the constructors list). */ ++ ++bfd_boolean ++bfd_m68kmint_add_tpa_relocation_entry (bfd *abfd, bfd_vma address) ++{ ++ struct mint_internal_info *myinfo; ++ ++ BFD_ASSERT(abfd->xvec == &m68kmint_prg_vec); ++ myinfo = obj_aout_ext (abfd); ++ BFD_ASSERT(myinfo != NULL); ++ ++ /* Enlarge the buffer if necessary. */ ++ if (myinfo->relocs_used * sizeof (bfd_vma) >= myinfo->relocs_allocated) ++ { ++ bfd_vma *newbuf; ++ myinfo->relocs_allocated += MINT_RELOC_CHUNKSIZE; ++ newbuf = bfd_realloc (myinfo->relocs, myinfo->relocs_allocated); ++ if (newbuf == NULL) ++ return FALSE; ++ ++ myinfo->relocs = newbuf; ++ } ++ ++ /* The TPA relative relocation actually just adds the address of ++ the text segment (i. e. beginning of the executable in memory) ++ to the addresses at the specified locations. This allows an ++ executable to be loaded everywhere in the address space without ++ memory management. */ ++ myinfo->relocs[myinfo->relocs_used++] = address; ++ ++ return TRUE; ++} +diff -ur --new-file binutils-2.21.51.0.7/bfd/targets.c binutils-2.21.51.0.7-mint/bfd/targets.c +--- binutils-2.21.51.0.7/bfd/targets.c 2011-01-04 17:51:04.000000000 +0000 ++++ binutils-2.21.51.0.7-mint/bfd/targets.c 2011-04-08 10:07:08.000000000 +0000 +@@ -770,6 +770,7 @@ + extern const bfd_target m68kcoff_vec; + extern const bfd_target m68kcoffun_vec; + extern const bfd_target m68klinux_vec; ++extern const bfd_target m68kmint_prg_vec; + extern const bfd_target m68knetbsd_vec; + extern const bfd_target m68ksysvcoff_vec; + extern const bfd_target m88kbcs_vec; +diff -ur --new-file binutils-2.21.51.0.7/binutils/configure binutils-2.21.51.0.7-mint/binutils/configure +--- binutils-2.21.51.0.7/binutils/configure 2011-03-07 18:05:31.000000000 +0000 ++++ binutils-2.21.51.0.7-mint/binutils/configure 2011-04-08 10:07:09.000000000 +0000 +@@ -13041,7 +13041,7 @@ + + + case "${host}" in +-*-*-msdos* | *-*-go32* | *-*-mingw32* | *-*-cygwin* | *-*-windows*) ++*-*-msdos* | *-*-go32* | *-*-mingw32* | *-*-cygwin* | *-*-windows* | *-*-mint*) + + $as_echo "#define USE_BINARY_FOPEN 1" >>confdefs.h + ;; +diff -ur --new-file binutils-2.21.51.0.7/binutils/dlltool.c binutils-2.21.51.0.7-mint/binutils/dlltool.c +--- binutils-2.21.51.0.7/binutils/dlltool.c 2010-12-06 14:23:54.000000000 +0000 ++++ binutils-2.21.51.0.7-mint/binutils/dlltool.c 2011-04-08 10:07:09.000000000 +0000 +@@ -4360,7 +4360,7 @@ + if (*cp == '-') + dash = cp; + if ( +-#if defined(__DJGPP__) || defined (__CYGWIN__) || defined(__WIN32__) ++#if defined(__DJGPP__) || defined (__CYGWIN__) || defined(__WIN32__) || defined(__MINT__) + *cp == ':' || *cp == '\\' || + #endif + *cp == '/') +diff -ur --new-file binutils-2.21.51.0.7/binutils/dllwrap.c binutils-2.21.51.0.7-mint/binutils/dllwrap.c +--- binutils-2.21.51.0.7/binutils/dllwrap.c 2010-08-11 21:51:51.000000000 +0000 ++++ binutils-2.21.51.0.7-mint/binutils/dllwrap.c 2011-04-08 10:07:09.000000000 +0000 +@@ -263,7 +263,7 @@ + dash = cp; + + if ( +-#if defined(__DJGPP__) || defined (__CYGWIN__) || defined(__WIN32__) ++#if defined(__DJGPP__) || defined (__CYGWIN__) || defined(__WIN32__) || defined(__MINT__) + *cp == ':' || *cp == '\\' || + #endif + *cp == '/') +diff -ur --new-file binutils-2.21.51.0.7/binutils/readelf.c binutils-2.21.51.0.7-mint/binutils/readelf.c +--- binutils-2.21.51.0.7/binutils/readelf.c 2011-04-08 09:37:05.000000000 +0000 ++++ binutils-2.21.51.0.7-mint/binutils/readelf.c 2011-04-08 10:07:10.000000000 +0000 +@@ -9903,7 +9903,11 @@ + #ifndef __MSVCRT__ + /* PR 11128: Use two separate invocations in order to work + around bugs in the Solaris 8 implementation of printf. */ ++#if GCC_VERSION < 3000 ++ printf (" [%6lx] ", (unsigned long) (data - start)); ++#else + printf (" [%6tx] ", data - start); ++#endif + printf ("%s\n", data); + #else + printf (" [%6Ix] %s\n", (size_t) (data - start), data); +diff -ur --new-file binutils-2.21.51.0.7/binutils/resrc.c binutils-2.21.51.0.7-mint/binutils/resrc.c +--- binutils-2.21.51.0.7/binutils/resrc.c 2010-12-06 14:23:55.000000000 +0000 ++++ binutils-2.21.51.0.7-mint/binutils/resrc.c 2011-04-08 10:07:10.000000000 +0000 +@@ -396,7 +396,7 @@ + *space = 0; + + if ( +-#if defined (__DJGPP__) || defined (__CYGWIN__) || defined (_WIN32) ++#if defined (__DJGPP__) || defined (__CYGWIN__) || defined (_WIN32) || defined (__MINT__) + strchr (cmd, '\\') || + #endif + strchr (cmd, '/')) +@@ -514,7 +514,7 @@ + if (*cp == '-') + dash = cp; + if ( +-#if defined (__DJGPP__) || defined (__CYGWIN__) || defined(_WIN32) ++#if defined (__DJGPP__) || defined (__CYGWIN__) || defined(_WIN32) || defined (__MINT__) + *cp == ':' || *cp == '\\' || + #endif + *cp == '/') +diff -ur --new-file binutils-2.21.51.0.7/gas/config/te-mint.h binutils-2.21.51.0.7-mint/gas/config/te-mint.h +--- binutils-2.21.51.0.7/gas/config/te-mint.h 1970-01-01 00:00:00.000000000 +0000 ++++ binutils-2.21.51.0.7-mint/gas/config/te-mint.h 2011-04-08 10:07:10.000000000 +0000 +@@ -0,0 +1,30 @@ ++/* Copyright 2008 Free Software Foundation, Inc. ++ ++ This file is part of GAS, the GNU Assembler. ++ ++ GAS is free software; you can redistribute it and/or modify ++ it under the terms of the GNU General Public License as ++ published by the Free Software Foundation; either version 3, ++ or (at your option) any later version. ++ ++ GAS is distributed in the hope that it will be useful, but ++ WITHOUT ANY WARRANTY; without even the implied warranty of ++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See ++ the GNU General Public License for more details. ++ ++ You should have received a copy of the GNU General Public License ++ along with GAS; see the file COPYING. If not, write to the Free ++ Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA ++ 02110-1301, USA. */ ++ ++#define TE_MINT ++ ++#define LOCAL_LABELS_DOLLAR 1 ++#define LOCAL_LABELS_FB 1 ++ ++/* These define interfaces. */ ++#ifdef OBJ_HEADER ++#include OBJ_HEADER ++#else ++#include "obj-format.h" ++#endif +diff -ur --new-file binutils-2.21.51.0.7/gas/configure.tgt binutils-2.21.51.0.7-mint/gas/configure.tgt +--- binutils-2.21.51.0.7/gas/configure.tgt 2011-01-04 17:51:04.000000000 +0000 ++++ binutils-2.21.51.0.7-mint/gas/configure.tgt 2011-04-08 10:07:10.000000000 +0000 +@@ -266,6 +266,7 @@ + m68k-*-linux-*) fmt=elf em=linux ;; + m68k-*-uclinux*) fmt=elf em=uclinux ;; + m68k-*-gnu*) fmt=elf ;; ++ m68k-*-mint*) fmt=aout em=mint bfd_gas=yes ;; + m68k-*-netbsdelf*) fmt=elf em=nbsd ;; + m68k-*-netbsd*) fmt=aout em=nbsd bfd_gas=yes ;; + m68k-*-openbsd*) fmt=aout em=nbsd bfd_gas=yes ;; +diff -ur --new-file binutils-2.21.51.0.7/gas/testsuite/gas/all/weakref1u.d binutils-2.21.51.0.7-mint/gas/testsuite/gas/all/weakref1u.d +--- binutils-2.21.51.0.7/gas/testsuite/gas/all/weakref1u.d 2009-11-11 16:52:57.000000000 +0000 ++++ binutils-2.21.51.0.7-mint/gas/testsuite/gas/all/weakref1u.d 2011-04-08 10:07:10.000000000 +0000 +@@ -3,7 +3,7 @@ + #source: weakref1.s + # aout turns undefined into *ABS* symbols. + # see weakref1.d for comments on the other not-targets +-#not-target: *-*-*aout m68k-*-netbsd m68k-*-openbsd* ns32k-*-netbsd alpha*-*-osf* *-*-ecoff ++#not-target: *-*-*aout m68k-*-netbsd m68k-*-openbsd* m68k-*-mint* ns32k-*-netbsd alpha*-*-osf* *-*-ecoff + + # the rest of this file is generated with the following script: + # # script begin +diff -ur --new-file binutils-2.21.51.0.7/gas/testsuite/gas/m68k/all.exp binutils-2.21.51.0.7-mint/gas/testsuite/gas/m68k/all.exp +--- binutils-2.21.51.0.7/gas/testsuite/gas/m68k/all.exp 2011-03-07 18:05:32.000000000 +0000 ++++ binutils-2.21.51.0.7-mint/gas/testsuite/gas/m68k/all.exp 2011-04-08 10:10:06.000000000 +0000 +@@ -71,7 +71,7 @@ + + gas_test_error "p11673.s" "-march=isab" "movel immediate with offset unsupported on isab" + +- if { [istarget *-*-*aout] || [istarget *-*-netbsd] || [istarget *-*-openbsd*] } then { ++ if { [istarget *-*-*aout] || [istarget *-*-netbsd] || [istarget *-*-openbsd*] || [istarget *-*-mint*] } then { + run_dump_test p3041 + run_dump_test p3041data + run_dump_test p3041pcrel +diff -ur --new-file binutils-2.21.51.0.7/gas/testsuite/gas/m68k/br-isaa.d binutils-2.21.51.0.7-mint/gas/testsuite/gas/m68k/br-isaa.d +--- binutils-2.21.51.0.7/gas/testsuite/gas/m68k/br-isaa.d 2009-11-11 16:52:56.000000000 +0000 ++++ binutils-2.21.51.0.7-mint/gas/testsuite/gas/m68k/br-isaa.d 2011-04-08 10:07:10.000000000 +0000 +@@ -1,7 +1,7 @@ + #name: br-isaa.d + #objdump: -dr + #as: -march=isaa -pcrel +-#not-target: *-*-*aout m68k-*-netbsd m68k-*-openbsd* ++#not-target: *-*-*aout m68k-*-netbsd m68k-*-openbsd* m68k-*-mint* + + .*: file format .* + +diff -ur --new-file binutils-2.21.51.0.7/gas/testsuite/gas/m68k/br-isab.d binutils-2.21.51.0.7-mint/gas/testsuite/gas/m68k/br-isab.d +--- binutils-2.21.51.0.7/gas/testsuite/gas/m68k/br-isab.d 2009-11-11 16:52:56.000000000 +0000 ++++ binutils-2.21.51.0.7-mint/gas/testsuite/gas/m68k/br-isab.d 2011-04-08 10:07:10.000000000 +0000 +@@ -1,7 +1,7 @@ + #name: br-isab.d + #objdump: -dr + #as: -march=isab -pcrel +-#not-target: *-*-*aout m68k-*-netbsd m68k-*-openbsd* ++#not-target: *-*-*aout m68k-*-netbsd m68k-*-openbsd* m68k-*-mint* + + .*: file format .* + +diff -ur --new-file binutils-2.21.51.0.7/gas/testsuite/gas/m68k/br-isac.d binutils-2.21.51.0.7-mint/gas/testsuite/gas/m68k/br-isac.d +--- binutils-2.21.51.0.7/gas/testsuite/gas/m68k/br-isac.d 2009-11-11 16:52:56.000000000 +0000 ++++ binutils-2.21.51.0.7-mint/gas/testsuite/gas/m68k/br-isac.d 2011-04-08 10:07:10.000000000 +0000 +@@ -1,7 +1,7 @@ + #name: br-isac.d + #objdump: -dr + #as: -march=isac -pcrel +-#not-target: *-*-*aout m68k-*-netbsd m68k-*-openbsd* ++#not-target: *-*-*aout m68k-*-netbsd m68k-*-openbsd* m68k-*-mint* + + .*: file format .* + +diff -ur --new-file binutils-2.21.51.0.7/include/filenames.h binutils-2.21.51.0.7-mint/include/filenames.h +--- binutils-2.21.51.0.7/include/filenames.h 2011-03-07 18:05:32.000000000 +0000 ++++ binutils-2.21.51.0.7-mint/include/filenames.h 2011-04-08 10:07:27.000000000 +0000 +@@ -30,7 +30,7 @@ + extern "C" { + #endif + +-#if defined(__MSDOS__) || defined(_WIN32) || defined(__OS2__) || defined (__CYGWIN__) ++#if defined(__MSDOS__) || defined(_WIN32) || defined(__OS2__) || defined (__CYGWIN__) || defined (__MINT__) + # ifndef HAVE_DOS_BASED_FILE_SYSTEM + # define HAVE_DOS_BASED_FILE_SYSTEM 1 + # endif +diff -ur --new-file binutils-2.21.51.0.7/include/getopt.h binutils-2.21.51.0.7-mint/include/getopt.h +--- binutils-2.21.51.0.7/include/getopt.h 2005-05-10 22:46:48.000000000 +0000 ++++ binutils-2.21.51.0.7-mint/include/getopt.h 2011-04-08 10:07:27.000000000 +0000 +@@ -106,7 +106,7 @@ + to find the declaration so provide a fully prototyped one. If it + is 1, we found it so don't provide any declaration at all. */ + #if !HAVE_DECL_GETOPT +-#if defined (__GNU_LIBRARY__) || defined (HAVE_DECL_GETOPT) ++#if defined (__GNU_LIBRARY__) || defined (__MINT__) || defined (HAVE_DECL_GETOPT) + /* Many other libraries have conflicting prototypes for getopt, with + differences in the consts, in unistd.h. To avoid compilation + errors, only prototype getopt for the GNU C library. */ +diff -ur --new-file binutils-2.21.51.0.7/ld/Makefile.am binutils-2.21.51.0.7-mint/ld/Makefile.am +--- binutils-2.21.51.0.7/ld/Makefile.am 2011-03-07 18:05:32.000000000 +0000 ++++ binutils-2.21.51.0.7-mint/ld/Makefile.am 2011-04-08 10:07:27.000000000 +0000 +@@ -308,6 +308,7 @@ + em68kelf.c \ + em68kelfnbsd.c \ + em68klinux.c \ ++ em68kmint.c \ + em68knbsd.c \ + em68kpsos.c \ + em88kbcs.c \ +@@ -1319,6 +1320,10 @@ + em68klinux.c: $(srcdir)/emulparams/m68klinux.sh \ + $(srcdir)/emultempl/linux.em $(srcdir)/scripttempl/aout.sc ${GEN_DEPENDS} + ${GENSCRIPTS} m68klinux "$(tdir_m68klinux)" ++em68kmint.c: $(srcdir)/emulparams/m68kmint.sh \ ++ $(srcdir)/emultempl/generic.em $(srcdir)/emultempl/mint.em \ ++ $(srcdir)/scripttempl/m68kmint.sc ${GEN_DEPENDS} ++ ${GENSCRIPTS} m68kmint "$(tdir_m68kmint)" + em68knbsd.c: $(srcdir)/emulparams/m68knbsd.sh \ + $(srcdir)/emultempl/generic.em $(srcdir)/scripttempl/aout.sc ${GEN_DEPENDS} + ${GENSCRIPTS} m68knbsd "$(tdir_m68knbsd)" +diff -ur --new-file binutils-2.21.51.0.7/ld/Makefile.in binutils-2.21.51.0.7-mint/ld/Makefile.in +--- binutils-2.21.51.0.7/ld/Makefile.in 2011-03-07 18:05:32.000000000 +0000 ++++ binutils-2.21.51.0.7-mint/ld/Makefile.in 2011-04-08 10:07:27.000000000 +0000 +@@ -614,6 +614,7 @@ + em68kelf.c \ + em68kelfnbsd.c \ + em68klinux.c \ ++ em68kmint.c \ + em68knbsd.c \ + em68kpsos.c \ + em88kbcs.c \ +@@ -1229,6 +1230,7 @@ + @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/em68kelf.Po@am__quote@ + @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/em68kelfnbsd.Po@am__quote@ + @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/em68klinux.Po@am__quote@ ++@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/em68kmint.Po@am__quote@ + @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/em68knbsd.Po@am__quote@ + @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/em68kpsos.Po@am__quote@ + @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/em88kbcs.Po@am__quote@ +@@ -2762,6 +2764,10 @@ + em68klinux.c: $(srcdir)/emulparams/m68klinux.sh \ + $(srcdir)/emultempl/linux.em $(srcdir)/scripttempl/aout.sc ${GEN_DEPENDS} + ${GENSCRIPTS} m68klinux "$(tdir_m68klinux)" ++em68kmint.c: $(srcdir)/emulparams/m68kmint.sh \ ++ $(srcdir)/emultempl/generic.em $(srcdir)/emultempl/mint.em \ ++ $(srcdir)/scripttempl/m68kmint.sc ${GEN_DEPENDS} ++ ${GENSCRIPTS} m68kmint "$(tdir_m68kmint)" + em68knbsd.c: $(srcdir)/emulparams/m68knbsd.sh \ + $(srcdir)/emultempl/generic.em $(srcdir)/scripttempl/aout.sc ${GEN_DEPENDS} + ${GENSCRIPTS} m68knbsd "$(tdir_m68knbsd)" +diff -ur --new-file binutils-2.21.51.0.7/ld/configure binutils-2.21.51.0.7-mint/ld/configure +--- binutils-2.21.51.0.7/ld/configure 2011-03-07 18:05:32.000000000 +0000 ++++ binutils-2.21.51.0.7-mint/ld/configure 2011-04-08 10:07:28.000000000 +0000 +@@ -16557,7 +16557,7 @@ + + + case "${host}" in +-*-*-msdos* | *-*-go32* | *-*-mingw32* | *-*-cygwin* | *-*-windows*) ++*-*-msdos* | *-*-go32* | *-*-mingw32* | *-*-cygwin* | *-*-windows* | *-*-mint*) + + $as_echo "#define USE_BINARY_FOPEN 1" >>confdefs.h + ;; +diff -ur --new-file binutils-2.21.51.0.7/ld/configure.tgt binutils-2.21.51.0.7-mint/ld/configure.tgt +--- binutils-2.21.51.0.7/ld/configure.tgt 2011-01-04 17:51:04.000000000 +0000 ++++ binutils-2.21.51.0.7-mint/ld/configure.tgt 2011-04-08 10:07:28.000000000 +0000 +@@ -344,6 +344,7 @@ + tdir_m68klinux=`echo ${targ_alias} | sed -e 's/linux/linuxaout/'` ;; + m68k-*-uclinux*) targ_emul=m68kelf ;; + m68*-*-gnu*) targ_emul=m68kelf ;; ++m68*-*-mint*) targ_emul=m68kmint ;; + m68*-*-netbsd*4k*) targ_emul=m68k4knbsd + targ_extra_emuls="m68knbsd m68kelfnbsd" ;; + m68*-*-netbsdelf*) targ_emul=m68kelfnbsd +diff -ur --new-file binutils-2.21.51.0.7/ld/emulparams/m68kmint.sh binutils-2.21.51.0.7-mint/ld/emulparams/m68kmint.sh +--- binutils-2.21.51.0.7/ld/emulparams/m68kmint.sh 1970-01-01 00:00:00.000000000 +0000 ++++ binutils-2.21.51.0.7-mint/ld/emulparams/m68kmint.sh 2011-04-08 10:07:28.000000000 +0000 +@@ -0,0 +1,6 @@ ++SCRIPT_NAME=m68kmint ++OUTPUT_FORMAT="a.out-mintprg" ++RELOCATEABLE_OUTPUT_FORMAT="a.out-zero-big" ++TEXT_START_ADDR=0xe4 ++ARCH=m68k ++EXTRA_EM_FILE=mint +diff -ur --new-file binutils-2.21.51.0.7/ld/emultempl/mint.em binutils-2.21.51.0.7-mint/ld/emultempl/mint.em +--- binutils-2.21.51.0.7/ld/emultempl/mint.em 1970-01-01 00:00:00.000000000 +0000 ++++ binutils-2.21.51.0.7-mint/ld/emultempl/mint.em 2011-04-08 10:07:28.000000000 +0000 +@@ -0,0 +1,330 @@ ++# This shell script emits a C file. -*- C -*- ++# Copyright 2006, 2007 Free Software Foundation, Inc. ++# ++# This file is part of the GNU Binutils. ++# ++# This program is free software; you can redistribute it and/or modify ++# it under the terms of the GNU General Public License as published by ++# the Free Software Foundation; either version 3 of the License, or ++# (at your option) any later version. ++# ++# This program is distributed in the hope that it will be useful, ++# but WITHOUT ANY WARRANTY; without even the implied warranty of ++# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++# GNU General Public License for more details. ++# ++# You should have received a copy of the GNU General Public License ++# along with this program; if not, write to the Free Software ++# Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, ++# MA 02110-1301, USA. ++# ++ ++# This file is sourced from generic.em ++# ++fragment <<EOF ++ ++#include "getopt.h" ++#include "ldgram.h" ++ ++/* Standard GEMDOS program flags. */ ++#define _MINT_F_FASTLOAD 0x01 /* Don't clear heap. */ ++#define _MINT_F_ALTLOAD 0x02 /* OK to load in alternate RAM. */ ++#define _MINT_F_ALTALLOC 0x04 /* OK to malloc from alt. RAM. */ ++#define _MINT_F_BESTFIT 0x08 /* Load with optimal heap size. */ ++/* The memory flags are mutually exclusive. */ ++#define _MINT_F_MEMPROTECTION 0xf0 /* Masks out protection bits. */ ++#define _MINT_F_MEMPRIVATE 0x00 /* Memory is private. */ ++#define _MINT_F_MEMGLOBAL 0x10 /* Read/write access to mem allowed. */ ++#define _MINT_F_MEMSUPER 0x20 /* Only supervisor access allowed. */ ++#define _MINT_F_MEMREADABLE 0x30 /* Any read access OK. */ ++#define _MINT_F_SHTEXT 0x800 /* Program's text may be shared */ ++ ++/* Option flags. */ ++static flagword prg_flags = (_MINT_F_FASTLOAD | _MINT_F_ALTLOAD ++ | _MINT_F_ALTALLOC | _MINT_F_MEMPRIVATE); ++ ++/* If override_stack_size is TRUE, then the executable stack size ++ * must be overriden with the value of stack_size. */ ++static bfd_boolean override_stack_size = FALSE; ++static bfd_signed_vma stack_size; ++ ++/* MiNT format extra command line options. */ ++ ++/* Used for setting flags in the MiNT header. */ ++#define OPTION_FASTLOAD (300) ++#define OPTION_NO_FASTLOAD (OPTION_FASTLOAD + 1) ++#define OPTION_FASTRAM (OPTION_NO_FASTLOAD + 1) ++#define OPTION_NO_FASTRAM (OPTION_FASTRAM + 1) ++#define OPTION_FASTALLOC (OPTION_NO_FASTRAM + 1) ++#define OPTION_NO_FASTALLOC (OPTION_FASTALLOC + 1) ++#define OPTION_BESTFIT (OPTION_NO_FASTALLOC + 1) ++#define OPTION_NO_BESTFIT (OPTION_BESTFIT + 1) ++#define OPTION_BASEREL (OPTION_NO_BESTFIT + 1) ++#define OPTION_NO_BASEREL (OPTION_BASEREL + 1) ++#define OPTION_MEM_PRIVATE (OPTION_NO_BASEREL + 1) ++#define OPTION_MEM_GLOBAL (OPTION_MEM_PRIVATE + 1) ++#define OPTION_MEM_SUPER (OPTION_MEM_GLOBAL + 1) ++#define OPTION_MEM_READONLY (OPTION_MEM_SUPER + 1) ++#define OPTION_PRG_FLAGS (OPTION_MEM_READONLY + 1) ++#define OPTION_STACK (OPTION_PRG_FLAGS + 1) ++ ++static void ++gld${EMULATION_NAME}_add_options ++ (int ns ATTRIBUTE_UNUSED, char **shortopts ATTRIBUTE_UNUSED, int nl, ++ struct option **longopts, int nrl ATTRIBUTE_UNUSED, ++ struct option **really_longopts ATTRIBUTE_UNUSED) ++{ ++ static const struct option xtra_long[] = { ++ {"mfastload", no_argument, NULL, OPTION_FASTLOAD}, ++ {"mno-fastload", no_argument, NULL, OPTION_NO_FASTLOAD}, ++ {"mfastram", no_argument, NULL, OPTION_FASTRAM}, ++ {"mno-fastram", no_argument, NULL, OPTION_NO_FASTRAM}, ++ {"maltram", no_argument, NULL, OPTION_FASTRAM}, ++ {"mno-altram", no_argument, NULL, OPTION_NO_FASTRAM}, ++ {"mfastalloc", no_argument, NULL, OPTION_FASTALLOC}, ++ {"mno-fastalloc", no_argument, NULL, OPTION_NO_FASTALLOC}, ++ {"maltalloc", no_argument, NULL, OPTION_FASTALLOC}, ++ {"mno-altalloc", no_argument, NULL, OPTION_NO_FASTALLOC}, ++ {"mbest-fit", no_argument, NULL, OPTION_BESTFIT}, ++ {"mno-best-fit", no_argument, NULL, OPTION_NO_BESTFIT}, ++ {"mbaserel", no_argument, NULL, OPTION_BASEREL}, ++ {"mno-baserel", no_argument, NULL, OPTION_NO_BASEREL}, ++ {"mshared-text", no_argument, NULL, OPTION_BASEREL}, ++ {"mno-shared-text", no_argument, NULL, OPTION_NO_BASEREL}, ++ {"msharable-text", no_argument, NULL, OPTION_BASEREL}, ++ {"mno-sharable-text", no_argument, NULL, OPTION_NO_BASEREL}, ++ /* Memory protection bits. */ ++ {"mprivate-memory", no_argument, NULL, OPTION_MEM_PRIVATE }, ++ {"mglobal-memory", no_argument, NULL, OPTION_MEM_GLOBAL}, ++ {"msuper-memory", no_argument, NULL, OPTION_MEM_SUPER}, ++ {"mreadable-memory", no_argument, NULL, OPTION_MEM_READONLY}, ++ {"mreadonly-memory", no_argument, NULL, OPTION_MEM_READONLY}, ++ {"mprg-flags", required_argument, NULL, OPTION_PRG_FLAGS}, ++ {"stack", required_argument, NULL, OPTION_STACK}, ++ {NULL, no_argument, NULL, 0} ++ }; ++ ++ *longopts = (struct option *) ++ xrealloc (*longopts, nl * sizeof (struct option) + sizeof (xtra_long)); ++ memcpy (*longopts + nl, &xtra_long, sizeof (xtra_long)); ++} ++ ++static bfd_boolean ++gld${EMULATION_NAME}_handle_option (int optc) ++{ ++ switch (optc) ++ { ++ default: ++ return FALSE; ++ ++ case OPTION_FASTLOAD: ++ prg_flags |= _MINT_F_FASTLOAD; ++ break; ++ ++ case OPTION_NO_FASTLOAD: ++ prg_flags &= ~_MINT_F_FASTLOAD; ++ break; ++ ++ case OPTION_FASTRAM: ++ prg_flags |= _MINT_F_ALTLOAD; ++ break; ++ ++ case OPTION_NO_FASTRAM: ++ prg_flags &= ~_MINT_F_ALTLOAD; ++ break; ++ ++ case OPTION_FASTALLOC: ++ prg_flags |= _MINT_F_ALTALLOC; ++ break; ++ ++ case OPTION_NO_FASTALLOC: ++ prg_flags &= ~_MINT_F_ALTALLOC; ++ break; ++ ++ case OPTION_BESTFIT: ++ prg_flags |= _MINT_F_BESTFIT; ++ break; ++ ++ case OPTION_NO_BESTFIT: ++ prg_flags &= ~_MINT_F_BESTFIT; ++ break; ++ ++ case OPTION_BASEREL: ++ prg_flags |= _MINT_F_SHTEXT; ++ break; ++ ++ case OPTION_NO_BASEREL: ++ prg_flags &= ~_MINT_F_SHTEXT; ++ break; ++ ++ case OPTION_MEM_PRIVATE: ++ prg_flags &= ~_MINT_F_MEMPROTECTION; ++ break; ++ ++ case OPTION_MEM_GLOBAL: ++ prg_flags &= ~_MINT_F_MEMPROTECTION; ++ prg_flags |= _MINT_F_MEMPRIVATE; ++ break; ++ ++ case OPTION_MEM_SUPER: ++ prg_flags &= ~_MINT_F_MEMPROTECTION; ++ prg_flags |= _MINT_F_MEMSUPER; ++ break; ++ ++ case OPTION_MEM_READONLY: ++ prg_flags &= ~_MINT_F_MEMPROTECTION; ++ prg_flags |= _MINT_F_MEMREADABLE; ++ break; ++ ++ case OPTION_PRG_FLAGS: ++ { ++ char* tail; ++ unsigned long flag_value = strtoul (optarg, &tail, 0); ++ ++ if (*tail != '\0') ++ einfo (_("%P: warning: ignoring invalid program flags %s\n"), optarg); ++ else ++ prg_flags = flag_value; ++ ++ break; ++ } ++ case OPTION_STACK: ++ { ++ char* tail; ++ long size = strtol (optarg, &tail, 0); ++ ++ if (*tail == 'K' || *tail == 'k') ++ { ++ size *= 1024; ++ ++tail; ++ } ++ else if (*tail == 'M' || *tail == 'm') ++ { ++ size *= 1024*1024; ++ ++tail; ++ } ++ ++ if (*tail != '\0') ++ einfo (_("%P: warning: ignoring invalid stack size %s\n"), optarg); ++ else ++ { ++ stack_size = (bfd_signed_vma) size; ++ override_stack_size = TRUE; ++ } ++ ++ break; ++ } ++ } ++ return TRUE; ++} ++ ++/* This callback is called when ld is invoked ++ with the --help and --target-help options. */ ++ ++static void ++gld_${EMULATION_NAME}_list_options (FILE *file) ++{ ++ fprintf (file, _(" --m[no-]fastload Enable/Disable not cleaning the heap on startup\n")); ++ fprintf (file, _(" --m[no-]altram, --m[no-]fastram\n")); ++ fprintf (file, _(" Enable/Disable loading into alternate RAM\n")); ++ fprintf (file, _(" --m[no-]altalloc, --m[no-]fastalloc\n")); ++ fprintf (file, _(" Enable/Disable malloc from alternate RAM\n")); ++ fprintf (file, _(" --m[no-]best-fit Enable/Disable loading with optimal heap size\n")); ++ fprintf (file, _(" --m[no-]sharable-text, --m[no-]shared-text, --m[no-]baserel\n")); ++ fprintf (file, _(" Enable/Disable sharing the text segment\n")); ++ fprintf (file, "\n"); ++ fprintf (file, _("The following memory options are mutually exclusive:\n")); ++ fprintf (file, _(" --mprivate-memory Process memory is not accessible\n")); ++ fprintf (file, _(" --mglobal-memory Process memory is readable and writable\n")); ++ fprintf (file, _(" --msuper-memory Process memory is accessible in supervisor mode\n")); ++ fprintf (file, _(" --mreadonly-memory, --mreadable-memory\n")); ++ fprintf (file, _(" Process memory is readable but not writable\n")); ++ fprintf (file, "\n"); ++ fprintf (file, _(" --mprg-flags <value> Set all the flags with an integer raw value\n")); ++ fprintf (file, _(" --stack <size> Override the stack size (suffix k or M allowed)\n")); ++} ++ ++/* This callback is called by lang_for_each_statement. It checks that the ++ output sections speficied in the linker script are compatible with the MiNT ++ executable format. */ ++ ++static void ++gld${EMULATION_NAME}_check_output_sections (lang_statement_union_type *s) ++{ ++ if (s->header.type == lang_output_section_statement_enum) ++ { ++ lang_output_section_statement_type *oss = &s->output_section_statement; ++ ++ if (strcmp(oss->name, ".text") == 0 && oss->bfd_section->vma != ${TEXT_START_ADDR}) ++ einfo (_("%F%P: the VMA of section %A must be 0x%V, but actual value is 0x%V\n"), ++ oss->bfd_section, ${TEXT_START_ADDR}, oss->bfd_section->vma); ++ else if (strcmp(oss->name, ".data") == 0 && oss->addr_tree != NULL) ++ einfo (_("%F%P: the VMA of section %A must not be specified\n"), ++ oss->bfd_section); ++ else if (strcmp(oss->name, ".bss") == 0 && oss->addr_tree != NULL) ++ einfo (_("%F%P: the VMA of section %A must not be specified\n"), ++ oss->bfd_section); ++ } ++} ++ ++/* This callback is called by lang_for_each_statement. It looks for the data ++ statements of type REL generated by the linker, and adds a TPA relocation ++ entry for them. This is used by the CONSTRUCTORS list. */ ++ ++static void ++gld${EMULATION_NAME}_add_tpa_relocs (lang_statement_union_type *s) ++{ ++ if (s->header.type == lang_data_statement_enum) ++ { ++ lang_data_statement_type *ds = &s->data_statement; ++ ++ if (ds->exp->type.node_code == REL) ++ { ++ if (ds->type == LONG) ++ { ++ bfd_vma tpa_address = ds->output_section->vma + ds->output_offset; ++ if (!bfd_m68kmint_add_tpa_relocation_entry(link_info.output_bfd, tpa_address)) ++ einfo (_("%F%P:%B: unable to add a relocation entry\n"), link_info.output_bfd); ++ } ++ else ++ { ++ einfo (_("%F%P:%B: invalid size for TPA relocation entry in section %A, offset 0x%V\n"), ++ link_info.output_bfd, ds->output_section, ds->output_offset); ++ } ++ } ++ } ++} ++ ++/* Final emulation specific call. */ ++ ++static void ++gld${EMULATION_NAME}_finish (void) ++{ ++ /* Do nothing if we are not generating a MiNT executable (ex: binary). */ ++ if (strcmp (bfd_get_target (link_info.output_bfd), "${OUTPUT_FORMAT}") != 0) ++ return; ++ ++ /* Check the output sections. */ ++ lang_for_each_statement (gld${EMULATION_NAME}_check_output_sections); ++ ++ /* Set the GEMDOS executable header flags. */ ++ if (!bfd_m68kmint_set_extended_flags (link_info.output_bfd, prg_flags)) ++ einfo (_("%F%P:%B: unable to set the header flags\n"), link_info.output_bfd); ++ ++ /* Override the stack size. */ ++ if (override_stack_size) ++ if (!bfd_m68kmint_set_stack_size (link_info.output_bfd, stack_size)) ++ einfo (_("%F%P:%B: unable to set the stack size\n"), link_info.output_bfd); ++ ++ /* Generate TPA relocation entries for the data statements. */ ++ lang_for_each_statement (gld${EMULATION_NAME}_add_tpa_relocs); ++} ++ ++EOF ++ ++# Put these extra routines in ld_${EMULATION_NAME}_emulation ++# ++LDEMUL_ADD_OPTIONS=gld${EMULATION_NAME}_add_options ++LDEMUL_HANDLE_OPTION=gld${EMULATION_NAME}_handle_option ++LDEMUL_LIST_OPTIONS=gld_${EMULATION_NAME}_list_options ++LDEMUL_FINISH=gld${EMULATION_NAME}_finish +diff -ur --new-file binutils-2.21.51.0.7/ld/scripttempl/m68kmint.sc binutils-2.21.51.0.7-mint/ld/scripttempl/m68kmint.sc +--- binutils-2.21.51.0.7/ld/scripttempl/m68kmint.sc 1970-01-01 00:00:00.000000000 +0000 ++++ binutils-2.21.51.0.7-mint/ld/scripttempl/m68kmint.sc 2011-04-08 10:07:28.000000000 +0000 +@@ -0,0 +1,35 @@ ++cat <<EOF ++${RELOCATING+OUTPUT_FORMAT(${OUTPUT_FORMAT})} ++${RELOCATING-OUTPUT_FORMAT(${RELOCATEABLE_OUTPUT_FORMAT})} ++${RELOCATING+${LIB_SEARCH_DIRS}} ++SECTIONS ++{ ++ ${RELOCATING+/* The VMA of the .text section is ${TEXT_START_ADDR} instead of 0 ++ because the extended MiNT header is just before, ++ at the beginning of the TEXT segment. */} ++ .text ${RELOCATING+${TEXT_START_ADDR}}: ++ { ++ CREATE_OBJECT_SYMBOLS ++ *(.text) ++ ${CONSTRUCTING+CONSTRUCTORS} ++ ${RELOCATING+_etext = .;} ++ ${RELOCATING+__etext = .;} ++ } ++ ++ .data : ++ { ++ *(.data) ++ ${RELOCATING+_edata = .;} ++ ${RELOCATING+__edata = .;} ++ } ++ ++ .bss : ++ { ++ ${RELOCATING+__bss_start = .;} ++ *(.bss) ++ *(COMMON) ++ ${RELOCATING+_end = .;} ++ ${RELOCATING+__end = .;} ++ } ++} ++EOF +diff -ur --new-file binutils-2.21.51.0.7/libiberty/hex.c binutils-2.21.51.0.7-mint/libiberty/hex.c +--- binutils-2.21.51.0.7/libiberty/hex.c 2007-03-16 15:48:30.000000000 +0000 ++++ binutils-2.21.51.0.7-mint/libiberty/hex.c 2011-04-08 10:07:28.000000000 +0000 +@@ -24,7 +24,7 @@ + #include "libiberty.h" + #include "safe-ctype.h" /* for HOST_CHARSET_ASCII */ + +-#if EOF != -1 ++#if !(EOF == -1) /* gcc 2.95.3 has bug in '!=' operator for negative constants */ + #error "hex.c requires EOF == -1" + #endif + +diff -ur --new-file binutils-2.21.51.0.7/libiberty/safe-ctype.c binutils-2.21.51.0.7-mint/libiberty/safe-ctype.c +--- binutils-2.21.51.0.7/libiberty/safe-ctype.c 2005-06-22 20:53:36.000000000 +0000 ++++ binutils-2.21.51.0.7-mint/libiberty/safe-ctype.c 2011-04-08 10:07:28.000000000 +0000 +@@ -119,7 +119,7 @@ + #include <safe-ctype.h> + #include <stdio.h> /* for EOF */ + +-#if EOF != -1 ++#if !(EOF == -1) /* gcc 2.95.3 has bug in '!=' operator for negative constants */ + #error "<safe-ctype.h> requires EOF == -1" + #endif + +--- binutils-2.21.51.0.7/ld/lexsup.c 2011-04-08 15:39:47.000000000 +0000 ++++ binutils-2.21.51.0.7-mint/ld/lexsup.c 2011-04-08 15:39:25.000000000 +0000 +@@ -57,6 +57,9 @@ + #define S_ISDIR(m) (((m) & S_IFMT) == S_IFDIR) + #endif + ++/* Report plugin symbols. */ ++bfd_boolean report_plugin_symbols; ++ + static void set_default_dirlist (char *); + static void set_section_start (char *, char *); + static void set_segment_start (const char *, char *); +--- binutils-2.22/ld/plugin.c 2011-11-21 09:29:39.000000000 +0000 ++++ binutils-2.22-mint/ld/plugin.c 2011-12-07 21:24:05.000000000 +0000 +@@ -36,9 +36,6 @@ + #include <windows.h> + #endif + +-/* Report plugin symbols. */ +-bfd_boolean report_plugin_symbols; +- + /* The suffix to append to the name of the real (claimed) object file + when generating a dummy BFD to hold the IR symbols sent from the + plugin. For cosmetic use only; appears in maps, crefs etc. */ +--- binutils-2.22/libiberty/configure 2011-12-08 00:17:02.000000000 +0000 ++++ binutils-2.22-mint/libiberty/configure 2011-12-08 00:17:39.000000000 +0000 +@@ -4888,6 +4888,8 @@ + i[34567]86-*-* | x86_64-*-*) + PICFLAG=-fpic + ;; ++ *-*-mint*) ++ ;; + m68k-*-*) + PICFLAG=-fpic + ;; |