1# This shell script emits a C file. -*- C -*- 2# Copyright 2002, 2003, 2004, 2005 Free Software Foundation, Inc. 3# 4# This file is part of GLD, the Gnu Linker. 5# 6# This program is free software; you can redistribute it and/or modify 7# it under the terms of the GNU General Public License as published by 8# the Free Software Foundation; either version 2 of the License, or 9# (at your option) any later version. 10# 11# This program is distributed in the hope that it will be useful, 12# but WITHOUT ANY WARRANTY; without even the implied warranty of 13# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14# GNU General Public License for more details. 15# 16# You should have received a copy of the GNU General Public License 17# along with this program; if not, write to the Free Software 18# Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. 19# 20 21# This file is sourced from elf32.em, and defines extra powerpc64-elf 22# specific routines. 23# 24cat >>e${EMULATION_NAME}.c <<EOF 25 26#include "ldctor.h" 27#include "libbfd.h" 28#include "elf-bfd.h" 29#include "elf64-ppc.h" 30 31/* Fake input file for stubs. */ 32static lang_input_statement_type *stub_file; 33static int stub_added = 0; 34 35/* Whether we need to call ppc_layout_sections_again. */ 36static int need_laying_out = 0; 37 38/* Maximum size of a group of input sections that can be handled by 39 one stub section. A value of +/-1 indicates the bfd back-end 40 should use a suitable default size. */ 41static bfd_signed_vma group_size = 1; 42 43/* Whether to add ".foo" entries for each "foo" in a version script. */ 44static int dotsyms = 1; 45 46/* Whether to run tls optimization. */ 47static int no_tls_opt = 0; 48 49/* Whether to run opd optimization. */ 50static int no_opd_opt = 0; 51 52/* Whether to run toc optimization. */ 53static int no_toc_opt = 0; 54 55/* Whether to allow multiple toc sections. */ 56static int no_multi_toc = 0; 57 58/* Whether to emit symbols for stubs. */ 59static int emit_stub_syms = 0; 60 61static asection *toc_section = 0; 62 63/* Whether to canonicalize .opd so that there are no overlapping 64 .opd entries. */ 65static int non_overlapping_opd = 0; 66 67/* This is called before the input files are opened. We create a new 68 fake input file to hold the stub sections. */ 69 70static void 71ppc_create_output_section_statements (void) 72{ 73 extern const bfd_target bfd_elf64_powerpc_vec; 74 extern const bfd_target bfd_elf64_powerpcle_vec; 75 asection *sect; 76 77 if (link_info.hash->creator != &bfd_elf64_powerpc_vec 78 && link_info.hash->creator != &bfd_elf64_powerpcle_vec) 79 return; 80 81 link_info.wrap_char = '.'; 82 83 stub_file = lang_add_input_file ("linker stubs", 84 lang_input_file_is_fake_enum, 85 NULL); 86 stub_file->the_bfd = bfd_create ("linker stubs", output_bfd); 87 if (stub_file->the_bfd == NULL 88 || !bfd_set_arch_mach (stub_file->the_bfd, 89 bfd_get_arch (output_bfd), 90 bfd_get_mach (output_bfd))) 91 { 92 einfo ("%F%P: can not create BFD %E\n"); 93 return; 94 } 95 96 if (bfd_get_section_by_name (stub_file->the_bfd, ".note.GNU-stack") == NULL) 97 sect = bfd_make_section (stub_file->the_bfd, ".note.GNU-stack"); 98 stub_file->the_bfd->flags |= BFD_LINKER_CREATED; 99 ldlang_add_file (stub_file); 100 ppc64_elf_init_stub_bfd (stub_file->the_bfd, &link_info); 101} 102 103static void 104ppc_before_allocation (void) 105{ 106 if (stub_file != NULL) 107 { 108 if (!ppc64_elf_edit_opd (output_bfd, &link_info, no_opd_opt, 109 non_overlapping_opd)) 110 einfo ("%X%P: can not edit %s %E\n", "opd"); 111 112 if (ppc64_elf_tls_setup (output_bfd, &link_info) && !no_tls_opt) 113 { 114 /* Size the sections. This is premature, but we want to know the 115 TLS segment layout so that certain optimizations can be done. */ 116 expld.phase = lang_mark_phase_enum; 117 expld.dataseg.phase = exp_dataseg_none; 118 one_lang_size_sections_pass (NULL, TRUE); 119 120 if (!ppc64_elf_tls_optimize (output_bfd, &link_info)) 121 einfo ("%X%P: TLS problem %E\n"); 122 123 /* We must not cache anything from the preliminary sizing. */ 124 lang_reset_memory_regions (); 125 } 126 127 if (!no_toc_opt 128 && !link_info.relocatable 129 && !ppc64_elf_edit_toc (output_bfd, &link_info)) 130 einfo ("%X%P: can not edit %s %E\n", "toc"); 131 } 132 133 gld${EMULATION_NAME}_before_allocation (); 134} 135 136struct hook_stub_info 137{ 138 lang_statement_list_type add; 139 asection *input_section; 140}; 141 142/* Traverse the linker tree to find the spot where the stub goes. */ 143 144static bfd_boolean 145hook_in_stub (struct hook_stub_info *info, lang_statement_union_type **lp) 146{ 147 lang_statement_union_type *l; 148 bfd_boolean ret; 149 150 for (; (l = *lp) != NULL; lp = &l->header.next) 151 { 152 switch (l->header.type) 153 { 154 case lang_constructors_statement_enum: 155 ret = hook_in_stub (info, &constructor_list.head); 156 if (ret) 157 return ret; 158 break; 159 160 case lang_output_section_statement_enum: 161 ret = hook_in_stub (info, 162 &l->output_section_statement.children.head); 163 if (ret) 164 return ret; 165 break; 166 167 case lang_wild_statement_enum: 168 ret = hook_in_stub (info, &l->wild_statement.children.head); 169 if (ret) 170 return ret; 171 break; 172 173 case lang_group_statement_enum: 174 ret = hook_in_stub (info, &l->group_statement.children.head); 175 if (ret) 176 return ret; 177 break; 178 179 case lang_input_section_enum: 180 if (l->input_section.section == info->input_section) 181 { 182 /* We've found our section. Insert the stub immediately 183 before its associated input section. */ 184 *lp = info->add.head; 185 *(info->add.tail) = l; 186 return TRUE; 187 } 188 break; 189 190 case lang_data_statement_enum: 191 case lang_reloc_statement_enum: 192 case lang_object_symbols_statement_enum: 193 case lang_output_statement_enum: 194 case lang_target_statement_enum: 195 case lang_input_statement_enum: 196 case lang_assignment_statement_enum: 197 case lang_padding_statement_enum: 198 case lang_address_statement_enum: 199 case lang_fill_statement_enum: 200 break; 201 202 default: 203 FAIL (); 204 break; 205 } 206 } 207 return FALSE; 208} 209 210 211/* Call-back for ppc64_elf_size_stubs. */ 212 213/* Create a new stub section, and arrange for it to be linked 214 immediately before INPUT_SECTION. */ 215 216static asection * 217ppc_add_stub_section (const char *stub_sec_name, asection *input_section) 218{ 219 asection *stub_sec; 220 flagword flags; 221 asection *output_section; 222 const char *secname; 223 lang_output_section_statement_type *os; 224 struct hook_stub_info info; 225 226 stub_sec = bfd_make_section_anyway (stub_file->the_bfd, stub_sec_name); 227 if (stub_sec == NULL) 228 goto err_ret; 229 230 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_CODE 231 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_KEEP); 232 if (!bfd_set_section_flags (stub_file->the_bfd, stub_sec, flags)) 233 goto err_ret; 234 235 output_section = input_section->output_section; 236 secname = bfd_get_section_name (output_section->owner, output_section); 237 os = lang_output_section_find (secname); 238 239 info.input_section = input_section; 240 lang_list_init (&info.add); 241 lang_add_section (&info.add, stub_sec, os); 242 243 if (info.add.head == NULL) 244 goto err_ret; 245 246 stub_added = 1; 247 if (hook_in_stub (&info, &os->children.head)) 248 return stub_sec; 249 250 err_ret: 251 einfo ("%X%P: can not make stub section: %E\n"); 252 return NULL; 253} 254 255 256/* Another call-back for ppc64_elf_size_stubs. */ 257 258static void 259ppc_layout_sections_again (void) 260{ 261 /* If we have changed sizes of the stub sections, then we need 262 to recalculate all the section offsets. This may mean we need to 263 add even more stubs. */ 264 gld${EMULATION_NAME}_map_segments (TRUE); 265 need_laying_out = -1; 266} 267 268 269/* Call the back-end function to set TOC base after we have placed all 270 the sections. */ 271static void 272gld${EMULATION_NAME}_after_allocation (void) 273{ 274 if (!link_info.relocatable) 275 _bfd_set_gp_value (output_bfd, ppc64_elf_toc (output_bfd)); 276} 277 278 279static void 280build_toc_list (lang_statement_union_type *statement) 281{ 282 if (statement->header.type == lang_input_section_enum) 283 { 284 asection *i = statement->input_section.section; 285 286 if (!((lang_input_statement_type *) i->owner->usrdata)->just_syms_flag 287 && (i->flags & SEC_EXCLUDE) == 0 288 && i->output_section == toc_section) 289 ppc64_elf_next_toc_section (&link_info, i); 290 } 291} 292 293 294static void 295build_section_lists (lang_statement_union_type *statement) 296{ 297 if (statement->header.type == lang_input_section_enum) 298 { 299 asection *i = statement->input_section.section; 300 301 if (!((lang_input_statement_type *) i->owner->usrdata)->just_syms_flag 302 && (i->flags & SEC_EXCLUDE) == 0 303 && i->output_section != NULL 304 && i->output_section->owner == output_bfd) 305 { 306 if (!ppc64_elf_next_input_section (&link_info, i)) 307 einfo ("%X%P: can not size stub section: %E\n"); 308 } 309 } 310} 311 312 313/* Final emulation specific call. */ 314 315static void 316gld${EMULATION_NAME}_finish (void) 317{ 318 /* e_entry on PowerPC64 points to the function descriptor for 319 _start. If _start is missing, default to the first function 320 descriptor in the .opd section. */ 321 entry_section = ".opd"; 322 323 /* bfd_elf_discard_info just plays with debugging sections, 324 ie. doesn't affect any code, so we can delay resizing the 325 sections. It's likely we'll resize everything in the process of 326 adding stubs. */ 327 if (bfd_elf_discard_info (output_bfd, &link_info)) 328 need_laying_out = 1; 329 330 /* If generating a relocatable output file, then we don't have any 331 stubs. */ 332 if (stub_file != NULL && !link_info.relocatable) 333 { 334 int ret = ppc64_elf_setup_section_lists (output_bfd, &link_info, 335 no_multi_toc); 336 if (ret < 0) 337 einfo ("%X%P: can not size stub section: %E\n"); 338 else if (ret > 0) 339 { 340 toc_section = bfd_get_section_by_name (output_bfd, ".got"); 341 if (toc_section != NULL) 342 lang_for_each_statement (build_toc_list); 343 344 ppc64_elf_reinit_toc (output_bfd, &link_info); 345 346 lang_for_each_statement (build_section_lists); 347 348 /* Call into the BFD backend to do the real work. */ 349 if (!ppc64_elf_size_stubs (output_bfd, 350 &link_info, 351 group_size, 352 &ppc_add_stub_section, 353 &ppc_layout_sections_again)) 354 einfo ("%X%P: can not size stub section: %E\n"); 355 } 356 } 357 358 if (need_laying_out != -1) 359 gld${EMULATION_NAME}_map_segments (need_laying_out); 360 361 if (link_info.relocatable) 362 { 363 asection *toc = bfd_get_section_by_name (output_bfd, ".toc"); 364 if (toc != NULL 365 && bfd_section_size (output_bfd, toc) > 0x10000) 366 einfo ("%X%P: TOC section size exceeds 64k\n"); 367 } 368 369 if (stub_added) 370 { 371 char *msg = NULL; 372 char *line, *endline; 373 374 emit_stub_syms |= link_info.emitrelocations; 375 if (!ppc64_elf_build_stubs (emit_stub_syms, &link_info, 376 config.stats ? &msg : NULL)) 377 einfo ("%X%P: can not build stubs: %E\n"); 378 379 for (line = msg; line != NULL; line = endline) 380 { 381 endline = strchr (line, '\n'); 382 if (endline != NULL) 383 *endline++ = '\0'; 384 fprintf (stderr, "%s: %s\n", program_name, line); 385 } 386 if (msg != NULL) 387 free (msg); 388 } 389 390 ppc64_elf_restore_symbols (&link_info); 391 finish_default (); 392} 393 394 395/* Add a pattern matching ".foo" for every "foo" in a version script. 396 397 The reason for doing this is that many shared library version 398 scripts export a selected set of functions or data symbols, forcing 399 others local. eg. 400 401 . VERS_1 { 402 . global: 403 . this; that; some; thing; 404 . local: 405 . *; 406 . }; 407 408 To make the above work for PowerPC64, we need to export ".this", 409 ".that" and so on, otherwise only the function descriptor syms are 410 exported. Lack of an exported function code sym may cause a 411 definition to be pulled in from a static library. */ 412 413static struct bfd_elf_version_expr * 414gld${EMULATION_NAME}_new_vers_pattern (struct bfd_elf_version_expr *entry) 415{ 416 struct bfd_elf_version_expr *dot_entry; 417 unsigned int len; 418 char *dot_pat; 419 420 if (!dotsyms 421 || (entry->pattern != NULL 422 && (entry->pattern[0] == '*' || entry->pattern[0] == '.'))) 423 return entry; 424 425 dot_entry = xmalloc (sizeof *dot_entry); 426 *dot_entry = *entry; 427 dot_entry->next = entry; 428 if (entry->pattern != NULL) 429 { 430 len = strlen (entry->pattern) + 2; 431 dot_pat = xmalloc (len); 432 dot_pat[0] = '.'; 433 memcpy (dot_pat + 1, entry->pattern, len - 1); 434 dot_entry->pattern = dot_pat; 435 } 436 if (entry->symbol != NULL) 437 { 438 len = strlen (entry->symbol) + 2; 439 dot_pat = xmalloc (len); 440 dot_pat[0] = '.'; 441 memcpy (dot_pat + 1, entry->symbol, len - 1); 442 dot_entry->symbol = dot_pat; 443 } 444 return dot_entry; 445} 446 447 448/* Avoid processing the fake stub_file in vercheck, stat_needed and 449 check_needed routines. */ 450 451static void (*real_func) (lang_input_statement_type *); 452 453static void ppc_for_each_input_file_wrapper (lang_input_statement_type *l) 454{ 455 if (l != stub_file) 456 (*real_func) (l); 457} 458 459static void 460ppc_lang_for_each_input_file (void (*func) (lang_input_statement_type *)) 461{ 462 real_func = func; 463 lang_for_each_input_file (&ppc_for_each_input_file_wrapper); 464} 465 466#define lang_for_each_input_file ppc_lang_for_each_input_file 467 468EOF 469 470if grep -q 'ld_elf32_spu_emulation' ldemul-list.h; then 471 cat >>e${EMULATION_NAME}.c <<EOF 472/* Special handling for embedded SPU executables. */ 473extern bfd_boolean embedded_spu_file (lang_input_statement_type *, const char *); 474static bfd_boolean gld${EMULATION_NAME}_load_symbols (lang_input_statement_type *); 475 476static bfd_boolean 477ppc64_recognized_file (lang_input_statement_type *entry) 478{ 479 if (embedded_spu_file (entry, "-m64")) 480 return TRUE; 481 482 return gld${EMULATION_NAME}_load_symbols (entry); 483} 484EOF 485LDEMUL_RECOGNIZED_FILE=ppc64_recognized_file 486fi 487 488# Define some shell vars to insert bits of code into the standard elf 489# parse_args and list_options functions. 490# 491PARSE_AND_LIST_PROLOGUE=' 492#define OPTION_STUBGROUP_SIZE 301 493#define OPTION_STUBSYMS (OPTION_STUBGROUP_SIZE + 1) 494#define OPTION_DOTSYMS (OPTION_STUBSYMS + 1) 495#define OPTION_NO_DOTSYMS (OPTION_DOTSYMS + 1) 496#define OPTION_NO_TLS_OPT (OPTION_NO_DOTSYMS + 1) 497#define OPTION_NO_OPD_OPT (OPTION_NO_TLS_OPT + 1) 498#define OPTION_NO_TOC_OPT (OPTION_NO_OPD_OPT + 1) 499#define OPTION_NO_MULTI_TOC (OPTION_NO_TOC_OPT + 1) 500#define OPTION_NON_OVERLAPPING_OPD (OPTION_NO_MULTI_TOC + 1) 501' 502 503PARSE_AND_LIST_LONGOPTS=' 504 { "stub-group-size", required_argument, NULL, OPTION_STUBGROUP_SIZE }, 505 { "emit-stub-syms", no_argument, NULL, OPTION_STUBSYMS }, 506 { "dotsyms", no_argument, NULL, OPTION_DOTSYMS }, 507 { "no-dotsyms", no_argument, NULL, OPTION_NO_DOTSYMS }, 508 { "no-tls-optimize", no_argument, NULL, OPTION_NO_TLS_OPT }, 509 { "no-opd-optimize", no_argument, NULL, OPTION_NO_OPD_OPT }, 510 { "no-toc-optimize", no_argument, NULL, OPTION_NO_TOC_OPT }, 511 { "no-multi-toc", no_argument, NULL, OPTION_NO_MULTI_TOC }, 512 { "non-overlapping-opd", no_argument, NULL, OPTION_NON_OVERLAPPING_OPD }, 513' 514 515PARSE_AND_LIST_OPTIONS=' 516 fprintf (file, _("\ 517 --stub-group-size=N Maximum size of a group of input sections that can be\n\ 518 handled by one stub section. A negative value\n\ 519 locates all stubs before their branches (with a\n\ 520 group size of -N), while a positive value allows\n\ 521 two groups of input sections, one before, and one\n\ 522 after each stub section. Values of +/-1 indicate\n\ 523 the linker should choose suitable defaults.\n" 524 )); 525 fprintf (file, _("\ 526 --emit-stub-syms Label linker stubs with a symbol.\n" 527 )); 528 fprintf (file, _("\ 529 --dotsyms For every version pattern \"foo\" in a version script,\n\ 530 add \".foo\" so that function code symbols are\n\ 531 treated the same as function descriptor symbols.\n\ 532 Defaults to on.\n" 533 )); 534 fprintf (file, _("\ 535 --no-dotsyms Don'\''t do anything special in version scripts.\n" 536 )); 537 fprintf (file, _("\ 538 --no-tls-optimize Don'\''t try to optimize TLS accesses.\n" 539 )); 540 fprintf (file, _("\ 541 --no-opd-optimize Don'\''t optimize the OPD section.\n" 542 )); 543 fprintf (file, _("\ 544 --no-toc-optimize Don'\''t optimize the TOC section.\n" 545 )); 546 fprintf (file, _("\ 547 --no-multi-toc Disallow automatic multiple toc sections.\n" 548 )); 549 fprintf (file, _("\ 550 --non-overlapping-opd Canonicalize .opd, so that there are no overlapping\n\ 551 .opd entries.\n" 552 )); 553' 554 555PARSE_AND_LIST_ARGS_CASES=' 556 case OPTION_STUBGROUP_SIZE: 557 { 558 const char *end; 559 group_size = bfd_scan_vma (optarg, &end, 0); 560 if (*end) 561 einfo (_("%P%F: invalid number `%s'\''\n"), optarg); 562 } 563 break; 564 565 case OPTION_STUBSYMS: 566 emit_stub_syms = 1; 567 break; 568 569 case OPTION_DOTSYMS: 570 dotsyms = 1; 571 break; 572 573 case OPTION_NO_DOTSYMS: 574 dotsyms = 0; 575 break; 576 577 case OPTION_NO_TLS_OPT: 578 no_tls_opt = 1; 579 break; 580 581 case OPTION_NO_OPD_OPT: 582 no_opd_opt = 1; 583 break; 584 585 case OPTION_NO_TOC_OPT: 586 no_toc_opt = 1; 587 break; 588 589 case OPTION_NO_MULTI_TOC: 590 no_multi_toc = 1; 591 break; 592 593 case OPTION_NON_OVERLAPPING_OPD: 594 non_overlapping_opd = 1; 595 break; 596' 597 598# Put these extra ppc64elf routines in ld_${EMULATION_NAME}_emulation 599# 600LDEMUL_BEFORE_ALLOCATION=ppc_before_allocation 601LDEMUL_AFTER_ALLOCATION=gld${EMULATION_NAME}_after_allocation 602LDEMUL_FINISH=gld${EMULATION_NAME}_finish 603LDEMUL_CREATE_OUTPUT_SECTION_STATEMENTS=ppc_create_output_section_statements 604LDEMUL_NEW_VERS_PATTERN=gld${EMULATION_NAME}_new_vers_pattern 605