1# This shell script emits a C file. -*- C -*- 2# Copyright 2000, 2001, 2003, 2005, 2007, 2008, 2009 3# Free Software Foundation, Inc. 4# Written by Michael Sokolov <msokolov@ivan.Harhan.ORG>, based on armelf.em 5# 6# This file is part of the GNU Binutils. 7# 8# This program is free software; you can redistribute it and/or modify 9# it under the terms of the GNU General Public License as published by 10# the Free Software Foundation; either version 3 of the License, or 11# (at your option) any later version. 12# 13# This program is distributed in the hope that it will be useful, 14# but WITHOUT ANY WARRANTY; without even the implied warranty of 15# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16# GNU General Public License for more details. 17# 18# You should have received a copy of the GNU General Public License 19# along with this program; if not, write to the Free Software 20# Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, 21# MA 02110-1301, USA. 22 23 24# This file is sourced from elf32.em, and defines some extra routines for m68k 25# embedded systems using ELF and for some other systems using m68k ELF. While 26# it is sourced from elf32.em for all m68k ELF configurations, here we include 27# only the features we want depending on the configuration. 28 29case ${target} in 30 m68*-*-elf) 31 echo "#define SUPPORT_EMBEDDED_RELOCS" >>e${EMULATION_NAME}.c 32 ;; 33esac 34 35case ${target} in 36 *-linux*) 37# Don't use multi-GOT by default due to glibc linker's assumption 38# that GOT pointer points to GOT[0]. 39# got_handling_target_default=GOT_HANDLING_MULTIGOT 40 got_handling_target_default=GOT_HANDLING_SINGLE 41 ;; 42 *) 43 got_handling_target_default=GOT_HANDLING_SINGLE 44 ;; 45esac 46 47fragment <<EOF 48 49#define GOT_HANDLING_SINGLE (0) 50#define GOT_HANDLING_NEGATIVE (1) 51#define GOT_HANDLING_MULTIGOT (2) 52#define GOT_HANDLING_TARGET_DEFAULT ${got_handling_target_default} 53 54/* How to generate GOT. */ 55static int got_handling = GOT_HANDLING_DEFAULT; 56 57#ifdef SUPPORT_EMBEDDED_RELOCS 58static void check_sections (bfd *, asection *, void *); 59#endif 60 61/* This function is run after all the input files have been opened. */ 62 63static void 64m68k_elf_after_open (void) 65{ 66 /* Call the standard elf routine. */ 67 gld${EMULATION_NAME}_after_open (); 68 69#ifdef SUPPORT_EMBEDDED_RELOCS 70 if (command_line.embedded_relocs 71 && (! link_info.relocatable)) 72 { 73 bfd *abfd; 74 75 /* In the embedded relocs mode we create a .emreloc section for each 76 input file with a nonzero .data section. The BFD backend will fill in 77 these sections with magic numbers which can be used to relocate the 78 data section at run time. */ 79 for (abfd = link_info.input_bfds; abfd != NULL; abfd = abfd->link_next) 80 { 81 asection *datasec; 82 83 /* As first-order business, make sure that each input BFD is either 84 COFF or ELF. We need to call a special BFD backend function to 85 generate the embedded relocs, and we have such functions only for 86 COFF and ELF. */ 87 if (bfd_get_flavour (abfd) != bfd_target_coff_flavour 88 && bfd_get_flavour (abfd) != bfd_target_elf_flavour) 89 einfo ("%F%B: all input objects must be COFF or ELF for --embedded-relocs\n"); 90 91 datasec = bfd_get_section_by_name (abfd, ".data"); 92 93 /* Note that we assume that the reloc_count field has already 94 been set up. We could call bfd_get_reloc_upper_bound, but 95 that returns the size of a memory buffer rather than a reloc 96 count. We do not want to call bfd_canonicalize_reloc, 97 because although it would always work it would force us to 98 read in the relocs into BFD canonical form, which would waste 99 a significant amount of time and memory. */ 100 if (datasec != NULL && datasec->reloc_count > 0) 101 { 102 asection *relsec; 103 104 relsec = bfd_make_section_with_flags (abfd, ".emreloc", 105 (SEC_ALLOC 106 | SEC_LOAD 107 | SEC_HAS_CONTENTS 108 | SEC_IN_MEMORY)); 109 if (relsec == NULL 110 || ! bfd_set_section_alignment (abfd, relsec, 2) 111 || ! bfd_set_section_size (abfd, relsec, 112 datasec->reloc_count * 12)) 113 einfo ("%F%B: can not create .emreloc section: %E\n"); 114 } 115 116 /* Double check that all other data sections are empty, as is 117 required for embedded PIC code. */ 118 bfd_map_over_sections (abfd, check_sections, datasec); 119 } 120 } 121#endif /* SUPPORT_EMBEDDED_RELOCS */ 122} 123 124#ifdef SUPPORT_EMBEDDED_RELOCS 125/* Check that of the data sections, only the .data section has 126 relocs. This is called via bfd_map_over_sections. */ 127 128static void 129check_sections (bfd *abfd, asection *sec, void *datasec) 130{ 131 if ((bfd_get_section_flags (abfd, sec) & SEC_DATA) 132 && sec != datasec 133 && sec->reloc_count != 0) 134 einfo ("%B%X: section %s has relocs; can not use --embedded-relocs\n", 135 abfd, bfd_get_section_name (abfd, sec)); 136} 137 138#endif /* SUPPORT_EMBEDDED_RELOCS */ 139 140/* This function is called after the section sizes and offsets have 141 been set. */ 142 143static void 144m68k_elf_after_allocation (void) 145{ 146 /* Call the standard elf routine. */ 147 gld${EMULATION_NAME}_after_allocation (); 148 149#ifdef SUPPORT_EMBEDDED_RELOCS 150 if (command_line.embedded_relocs 151 && (! link_info.relocatable)) 152 { 153 bfd *abfd; 154 155 /* If we are generating embedded relocs, call a special BFD backend 156 routine to do the work. */ 157 for (abfd = link_info.input_bfds; abfd != NULL; abfd = abfd->link_next) 158 { 159 asection *datasec, *relsec; 160 char *errmsg; 161 162 datasec = bfd_get_section_by_name (abfd, ".data"); 163 164 if (datasec == NULL || datasec->reloc_count == 0) 165 continue; 166 167 relsec = bfd_get_section_by_name (abfd, ".emreloc"); 168 ASSERT (relsec != NULL); 169 170 if (bfd_get_flavour (abfd) == bfd_target_coff_flavour) 171 { 172 if (! bfd_m68k_coff_create_embedded_relocs (abfd, &link_info, 173 datasec, relsec, 174 &errmsg)) 175 { 176 if (errmsg == NULL) 177 einfo ("%B%X: can not create runtime reloc information: %E\n", 178 abfd); 179 else 180 einfo ("%X%B: can not create runtime reloc information: %s\n", 181 abfd, errmsg); 182 } 183 } 184 else if (bfd_get_flavour (abfd) == bfd_target_elf_flavour) 185 { 186 if (! bfd_m68k_elf32_create_embedded_relocs (abfd, &link_info, 187 datasec, relsec, 188 &errmsg)) 189 { 190 if (errmsg == NULL) 191 einfo ("%B%X: can not create runtime reloc information: %E\n", 192 abfd); 193 else 194 einfo ("%X%B: can not create runtime reloc information: %s\n", 195 abfd, errmsg); 196 } 197 } 198 else 199 abort (); 200 } 201 } 202#endif /* SUPPORT_EMBEDDED_RELOCS */ 203} 204 205/* This is a convenient point to tell BFD about target specific flags. 206 After the output has been created, but before inputs are read. */ 207 208static void 209elf_m68k_create_output_section_statements (void) 210{ 211 bfd_elf_m68k_set_target_options (&link_info, got_handling); 212} 213 214EOF 215 216# Define some shell vars to insert bits of code into the standard elf 217# parse_args and list_options functions. 218# 219PARSE_AND_LIST_PROLOGUE=' 220#define OPTION_GOT 301 221' 222 223PARSE_AND_LIST_LONGOPTS=' 224 { "got", required_argument, NULL, OPTION_GOT}, 225' 226 227PARSE_AND_LIST_OPTIONS=' 228 fprintf (file, _(" --got=<type> Specify GOT handling scheme\n")); 229' 230 231PARSE_AND_LIST_ARGS_CASES=' 232 case OPTION_GOT: 233 if (strcmp (optarg, "target") == 0) 234 got_handling = GOT_HANDLING_TARGET_DEFAULT; 235 else if (strcmp (optarg, "single") == 0) 236 got_handling = 0; 237 else if (strcmp (optarg, "negative") == 0) 238 got_handling = 1; 239 else if (strcmp (optarg, "multigot") == 0) 240 got_handling = 2; 241 else 242 einfo (_("Unrecognized --got argument '\''%s'\''.\n"), optarg); 243 break; 244' 245 246# We have our own after_open and after_allocation functions, but they call 247# the standard routines, so give them a different name. 248LDEMUL_AFTER_OPEN=m68k_elf_after_open 249LDEMUL_AFTER_ALLOCATION=m68k_elf_after_allocation 250LDEMUL_CREATE_OUTPUT_SECTION_STATEMENTS=elf_m68k_create_output_section_statements 251