]> git.ipfire.org Git - thirdparty/binutils-gdb.git/blob - ld/emultempl/ppc64elf.em
4987243fa1e361a2b50b67f2c68bb60a03cb5b00
[thirdparty/binutils-gdb.git] / ld / emultempl / ppc64elf.em
1 # This shell script emits a C file. -*- C -*-
2 # Copyright (C) 2002-2020 Free Software Foundation, Inc.
3 #
4 # This file is part of the GNU Binutils.
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 3 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,
19 # MA 02110-1301, USA.
20 #
21
22 # This file is sourced from elf.em, and defines extra powerpc64-elf
23 # specific routines.
24 #
25 fragment <<EOF
26
27 #include "ldctor.h"
28 #include "elf-bfd.h"
29 #include "elf64-ppc.h"
30 #include "ldlex.h"
31 #include "elf/ppc64.h"
32
33 static asection *ppc_add_stub_section (const char *, asection *);
34 static void ppc_layout_sections_again (void);
35
36 static struct ppc64_elf_params params = { NULL,
37 &ppc_add_stub_section,
38 &ppc_layout_sections_again,
39 1, -1, -1, 0,
40 ${DEFAULT_PLT_STATIC_CHAIN-0}, -1, 5,
41 -1, -1, 0, -1, -1, 0};
42
43 /* Fake input file for stubs. */
44 static lang_input_statement_type *stub_file;
45
46 /* Whether we need to call ppc_layout_sections_again. */
47 static int need_laying_out = 0;
48
49 /* Whether to add ".foo" entries for each "foo" in a version script. */
50 static int dotsyms = 1;
51
52 /* Whether to run tls optimization. */
53 static int no_tls_opt = 0;
54
55 /* Whether to run opd optimization. */
56 static int no_opd_opt = 0;
57
58 /* Whether to convert inline PLT calls to direct. */
59 static int no_inline_opt = 0;
60
61 /* Whether to run toc optimization. */
62 static int no_toc_opt = 0;
63
64 /* Whether to sort input toc and got sections. */
65 static int no_toc_sort = 0;
66
67 /* Input .toc sections will be placed in this output section. */
68 static const char *toc_section_name = ".got";
69 static asection *toc_section = 0;
70
71 /* This is called before the input files are opened. We create a new
72 fake input file to hold the stub sections. */
73
74 static void
75 ppc_create_output_section_statements (void)
76 {
77 if (!(bfd_get_flavour (link_info.output_bfd) == bfd_target_elf_flavour
78 && elf_object_id (link_info.output_bfd) == PPC64_ELF_DATA))
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", link_info.output_bfd);
87 if (stub_file->the_bfd == NULL
88 || !bfd_set_arch_mach (stub_file->the_bfd,
89 bfd_get_arch (link_info.output_bfd),
90 bfd_get_mach (link_info.output_bfd)))
91 {
92 einfo (_("%F%P: can not create BFD: %E\n"));
93 return;
94 }
95
96 stub_file->the_bfd->flags |= BFD_LINKER_CREATED;
97 ldlang_add_file (stub_file);
98 params.stub_bfd = stub_file->the_bfd;
99 if (params.save_restore_funcs < 0)
100 params.save_restore_funcs = !bfd_link_relocatable (&link_info);
101 if (!ppc64_elf_init_stub_bfd (&link_info, &params))
102 einfo (_("%F%P: can not init BFD: %E\n"));
103 }
104
105 /* Called after opening files but before mapping sections. */
106
107 static void
108 ppc_after_open (void)
109 {
110 if (stub_file != NULL && link_info.relro && params.object_in_toc)
111 {
112 /* We have a .toc section that might be written to at run time.
113 Don't put .toc into the .got output section. */
114 lang_output_section_statement_type *got;
115
116 got = lang_output_section_find (".got");
117 if (got != NULL)
118 {
119 lang_statement_union_type *s;
120 for (s = got->children.head; s != NULL; s = s->header.next)
121 if (s->header.type == lang_wild_statement_enum
122 && s->wild_statement.filename == NULL)
123 {
124 struct wildcard_list **i = &s->wild_statement.section_list;
125 while (*i != NULL)
126 if (strcmp ((*i)->spec.name, ".toc") == 0)
127 *i = (*i)->next;
128 else
129 i = &(*i)->next;
130 }
131 /* Instead, .toc input sections will be mapped to the
132 read/write .toc output section. If user scripts don't
133 provide one then we'll lose toc sorting and multi-toc. */
134 toc_section_name = ".toc";
135 }
136 }
137 gld${EMULATION_NAME}_after_open ();
138 }
139
140 /* Move the input section statement at *U which happens to be on LIST
141 to be just before *TO. */
142
143 static void
144 move_input_section (lang_statement_list_type *list,
145 lang_statement_union_type **u,
146 lang_statement_union_type **to)
147 {
148 lang_statement_union_type *s = *u;
149 asection *i = s->input_section.section;
150 asection *p, *n;
151
152 /* Snip the input section from the statement list. If it was the
153 last statement, fix the list tail pointer. */
154 *u = s->header.next;
155 if (*u == NULL)
156 list->tail = u;
157 /* Add it back in the new position. */
158 s->header.next = *to;
159 *to = s;
160 if (list->tail == to)
161 list->tail = &s->header.next;
162
163 /* Trim I off the bfd map_head/map_tail doubly linked lists. */
164 n = i->map_head.s;
165 p = i->map_tail.s;
166 (p != NULL ? p : i->output_section)->map_head.s = n;
167 (n != NULL ? n : i->output_section)->map_tail.s = p;
168
169 /* Add I back on in its new position. */
170 if (s->header.next->header.type == lang_input_section_enum)
171 {
172 n = s->header.next->input_section.section;
173 p = n->map_tail.s;
174 }
175 else
176 {
177 /* If the next statement is not an input section statement then
178 TO must point at the previous input section statement
179 header.next field. */
180 lang_input_section_type *prev = (lang_input_section_type *)
181 ((char *) to - offsetof (lang_statement_union_type, header.next));
182
183 ASSERT (prev->header.type == lang_input_section_enum);
184 p = prev->section;
185 n = p->map_head.s;
186 }
187 i->map_head.s = n;
188 i->map_tail.s = p;
189 (p != NULL ? p : i->output_section)->map_head.s = i;
190 (n != NULL ? n : i->output_section)->map_tail.s = i;
191 }
192
193 /* Sort input section statements in the linker script tree rooted at
194 LIST so that those whose owning bfd happens to have a section
195 called .init or .fini are placed first. Place any TOC sections
196 referenced by small TOC relocs next, with TOC sections referenced
197 only by bigtoc relocs last. */
198
199 static void
200 sort_toc_sections (lang_statement_list_type *list,
201 lang_statement_union_type **ini,
202 lang_statement_union_type **small)
203 {
204 lang_statement_union_type *s, **u;
205 asection *i;
206
207 u = &list->head;
208 while ((s = *u) != NULL)
209 {
210 switch (s->header.type)
211 {
212 case lang_wild_statement_enum:
213 sort_toc_sections (&s->wild_statement.children, ini, small);
214 break;
215
216 case lang_group_statement_enum:
217 sort_toc_sections (&s->group_statement.children, ini, small);
218 break;
219
220 case lang_input_section_enum:
221 i = s->input_section.section;
222 /* Leave the stub_file .got where it is. We put the .got
223 header there. */
224 if (i->owner == stub_file->the_bfd)
225 break;
226 if (bfd_get_section_by_name (i->owner, ".init") != NULL
227 || bfd_get_section_by_name (i->owner, ".fini") != NULL)
228 {
229 if (ini != NULL && *ini != s)
230 {
231 move_input_section (list, u, ini);
232 if (small == ini)
233 small = &s->header.next;
234 ini = &s->header.next;
235 continue;
236 }
237 if (small == ini)
238 small = &s->header.next;
239 ini = &s->header.next;
240 break;
241 }
242 else if (ini == NULL)
243 ini = u;
244
245 if (ppc64_elf_has_small_toc_reloc (i))
246 {
247 if (small != NULL && *small != s)
248 {
249 move_input_section (list, u, small);
250 small = &s->header.next;
251 continue;
252 }
253 small = &s->header.next;
254 }
255 else if (small == NULL)
256 small = u;
257 break;
258
259 default:
260 break;
261 }
262 u = &s->header.next;
263 }
264 }
265
266 static void
267 prelim_size_sections (void)
268 {
269 if (expld.phase != lang_mark_phase_enum)
270 {
271 expld.phase = lang_mark_phase_enum;
272 expld.dataseg.phase = exp_seg_none;
273 one_lang_size_sections_pass (NULL, FALSE);
274 /* We must not cache anything from the preliminary sizing. */
275 lang_reset_memory_regions ();
276 }
277 }
278
279 static void
280 ppc_before_allocation (void)
281 {
282 if (stub_file != NULL)
283 {
284 if (!no_opd_opt
285 && !ppc64_elf_edit_opd (&link_info))
286 einfo (_("%X%P: can not edit %s: %E\n"), "opd");
287
288 if (!no_inline_opt
289 && !bfd_link_relocatable (&link_info))
290 {
291 prelim_size_sections ();
292
293 if (!ppc64_elf_inline_plt (&link_info))
294 einfo (_("%X%P: inline PLT: %E\n"));
295 }
296
297 if (ppc64_elf_tls_setup (&link_info)
298 && !no_tls_opt)
299 {
300 /* Size the sections. This is premature, but we want to know the
301 TLS segment layout so that certain optimizations can be done. */
302 prelim_size_sections ();
303
304 if (!ppc64_elf_tls_optimize (&link_info))
305 einfo (_("%X%P: TLS problem %E\n"));
306 }
307
308 if (!no_toc_opt
309 && !bfd_link_relocatable (&link_info))
310 {
311 prelim_size_sections ();
312
313 if (!ppc64_elf_edit_toc (&link_info))
314 einfo (_("%X%P: can not edit %s: %E\n"), "toc");
315 }
316
317 if (!no_toc_sort)
318 {
319 lang_output_section_statement_type *toc_os;
320
321 toc_os = lang_output_section_find (toc_section_name);
322 if (toc_os != NULL)
323 sort_toc_sections (&toc_os->children, NULL, NULL);
324 }
325 }
326
327 gld${EMULATION_NAME}_before_allocation ();
328 }
329
330 struct hook_stub_info
331 {
332 lang_statement_list_type add;
333 asection *input_section;
334 };
335
336 /* Traverse the linker tree to find the spot where the stub goes. */
337
338 static bfd_boolean
339 hook_in_stub (struct hook_stub_info *info, lang_statement_union_type **lp)
340 {
341 lang_statement_union_type *l;
342 bfd_boolean ret;
343
344 for (; (l = *lp) != NULL; lp = &l->header.next)
345 {
346 switch (l->header.type)
347 {
348 case lang_constructors_statement_enum:
349 ret = hook_in_stub (info, &constructor_list.head);
350 if (ret)
351 return ret;
352 break;
353
354 case lang_output_section_statement_enum:
355 ret = hook_in_stub (info,
356 &l->output_section_statement.children.head);
357 if (ret)
358 return ret;
359 break;
360
361 case lang_wild_statement_enum:
362 ret = hook_in_stub (info, &l->wild_statement.children.head);
363 if (ret)
364 return ret;
365 break;
366
367 case lang_group_statement_enum:
368 ret = hook_in_stub (info, &l->group_statement.children.head);
369 if (ret)
370 return ret;
371 break;
372
373 case lang_input_section_enum:
374 if (l->input_section.section == info->input_section)
375 {
376 /* We've found our section. Insert the stub immediately
377 before its associated input section. */
378 *lp = info->add.head;
379 *(info->add.tail) = l;
380 return TRUE;
381 }
382 break;
383
384 case lang_data_statement_enum:
385 case lang_reloc_statement_enum:
386 case lang_object_symbols_statement_enum:
387 case lang_output_statement_enum:
388 case lang_target_statement_enum:
389 case lang_input_statement_enum:
390 case lang_assignment_statement_enum:
391 case lang_padding_statement_enum:
392 case lang_address_statement_enum:
393 case lang_fill_statement_enum:
394 break;
395
396 default:
397 FAIL ();
398 break;
399 }
400 }
401 return FALSE;
402 }
403
404
405 /* Call-back for ppc64_elf_size_stubs. */
406
407 /* Create a new stub section, and arrange for it to be linked
408 immediately before INPUT_SECTION. */
409
410 static asection *
411 ppc_add_stub_section (const char *stub_sec_name, asection *input_section)
412 {
413 asection *stub_sec;
414 flagword flags;
415 asection *output_section;
416 lang_output_section_statement_type *os;
417 struct hook_stub_info info;
418
419 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_CODE
420 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_KEEP);
421 stub_sec = bfd_make_section_anyway_with_flags (stub_file->the_bfd,
422 stub_sec_name, flags);
423 if (stub_sec == NULL
424 || !bfd_set_section_alignment (stub_sec, (params.plt_stub_align > 5
425 ? params.plt_stub_align
426 : params.plt_stub_align < -5
427 ? -params.plt_stub_align
428 : 5)))
429 goto err_ret;
430
431 output_section = input_section->output_section;
432 os = lang_output_section_get (output_section);
433
434 info.input_section = input_section;
435 lang_list_init (&info.add);
436 lang_add_section (&info.add, stub_sec, NULL, os);
437
438 if (info.add.head == NULL)
439 goto err_ret;
440
441 if (hook_in_stub (&info, &os->children.head))
442 return stub_sec;
443
444 err_ret:
445 einfo (_("%X%P: can not make stub section: %E\n"));
446 return NULL;
447 }
448
449
450 /* Another call-back for ppc64_elf_size_stubs. */
451
452 static void
453 ppc_layout_sections_again (void)
454 {
455 /* If we have changed sizes of the stub sections, then we need
456 to recalculate all the section offsets. This may mean we need to
457 add even more stubs. */
458 ldelf_map_segments (TRUE);
459
460 if (!bfd_link_relocatable (&link_info))
461 ppc64_elf_set_toc (&link_info, link_info.output_bfd);
462
463 need_laying_out = -1;
464 }
465
466
467 static void
468 build_toc_list (lang_statement_union_type *statement)
469 {
470 if (statement->header.type == lang_input_section_enum)
471 {
472 asection *i = statement->input_section.section;
473
474 if (i->sec_info_type != SEC_INFO_TYPE_JUST_SYMS
475 && (i->flags & SEC_EXCLUDE) == 0
476 && i->output_section == toc_section)
477 {
478 if (!ppc64_elf_next_toc_section (&link_info, i))
479 einfo (_("%X%P: linker script separates .got and .toc\n"));
480 }
481 }
482 }
483
484
485 static void
486 build_section_lists (lang_statement_union_type *statement)
487 {
488 if (statement->header.type == lang_input_section_enum)
489 {
490 asection *i = statement->input_section.section;
491
492 if (!bfd_input_just_syms (i->owner)
493 && (i->flags & SEC_EXCLUDE) == 0
494 && i->output_section != NULL
495 && i->output_section->owner == link_info.output_bfd)
496 {
497 if (!ppc64_elf_next_input_section (&link_info, i))
498 einfo (_("%X%P: can not size stub section: %E\n"));
499 }
500 }
501 }
502
503
504 /* Call the back-end function to set TOC base after we have placed all
505 the sections. */
506 static void
507 gld${EMULATION_NAME}_after_allocation (void)
508 {
509 int ret;
510
511 /* If generating a relocatable output file, then we don't have any
512 stubs. */
513 if (stub_file != NULL && !bfd_link_relocatable (&link_info))
514 {
515 ret = ppc64_elf_setup_section_lists (&link_info);
516 if (ret < 0)
517 einfo (_("%X%P: can not size stub section: %E\n"));
518 else
519 {
520 ppc64_elf_start_multitoc_partition (&link_info);
521
522 if (!params.no_multi_toc)
523 {
524 toc_section = bfd_get_section_by_name (link_info.output_bfd,
525 toc_section_name);
526 if (toc_section != NULL)
527 lang_for_each_statement (build_toc_list);
528 }
529
530 if (ppc64_elf_layout_multitoc (&link_info)
531 && !params.no_multi_toc
532 && toc_section != NULL)
533 lang_for_each_statement (build_toc_list);
534
535 ppc64_elf_finish_multitoc_partition (&link_info);
536
537 lang_for_each_statement (build_section_lists);
538
539 if (!ppc64_elf_check_init_fini (&link_info))
540 einfo (_("%P: .init/.fini fragments use differing TOC pointers\n"));
541
542 /* Call into the BFD backend to do the real work. */
543 if (!ppc64_elf_size_stubs (&link_info))
544 einfo (_("%X%P: can not size stub section: %E\n"));
545 }
546 }
547
548 /* We can't parse and merge .eh_frame until the glink .eh_frame has
549 been generated. Otherwise the glink .eh_frame CIE won't be
550 merged with other CIEs, and worse, the glink .eh_frame FDEs won't
551 be listed in .eh_frame_hdr. */
552 ret = bfd_elf_discard_info (link_info.output_bfd, &link_info);
553 if (ret < 0)
554 {
555 einfo (_("%X%P: .eh_frame/.stab edit: %E\n"));
556 return;
557 }
558 else if (ret > 0)
559 need_laying_out = 1;
560
561 /* Call map_segments regardless of the state of need_laying_out.
562 need_laying_out set to -1 means we have just laid everything out,
563 but ppc64_elf_size_stubs strips .branch_lt and .eh_frame if
564 unneeded, after ppc_layout_sections_again. Another call removes
565 these sections from the segment map. Their presence is
566 innocuous except for confusing ELF_SECTION_IN_SEGMENT. */
567 ldelf_map_segments (need_laying_out > 0);
568
569 if (need_laying_out != -1 && !bfd_link_relocatable (&link_info))
570 ppc64_elf_set_toc (&link_info, link_info.output_bfd);
571 }
572
573
574 /* Final emulation specific call. */
575
576 static void
577 gld${EMULATION_NAME}_finish (void)
578 {
579 char *msg = NULL;
580 char *line, *endline;
581
582 /* e_entry on PowerPC64 points to the function descriptor for
583 _start. If _start is missing, default to the first function
584 descriptor in the .opd section. */
585 if (stub_file != NULL
586 && (elf_elfheader (link_info.output_bfd)->e_flags & EF_PPC64_ABI) == 1)
587 entry_section = ".opd";
588
589 if (params.emit_stub_syms < 0)
590 params.emit_stub_syms = 1;
591 if (stub_file != NULL
592 && !bfd_link_relocatable (&link_info)
593 && !ppc64_elf_build_stubs (&link_info, config.stats ? &msg : NULL))
594 einfo (_("%X%P: can not build stubs: %E\n"));
595
596 fflush (stdout);
597 for (line = msg; line != NULL; line = endline)
598 {
599 endline = strchr (line, '\n');
600 if (endline != NULL)
601 *endline++ = '\0';
602 fprintf (stderr, "%s: %s\n", program_name, line);
603 }
604 fflush (stderr);
605 free (msg);
606
607 finish_default ();
608 }
609
610
611 /* Add a pattern matching ".foo" for every "foo" in a version script.
612
613 The reason for doing this is that many shared library version
614 scripts export a selected set of functions or data symbols, forcing
615 others local. eg.
616
617 . VERS_1 {
618 . global:
619 . this; that; some; thing;
620 . local:
621 . *;
622 . };
623
624 To make the above work for PowerPC64, we need to export ".this",
625 ".that" and so on, otherwise only the function descriptor syms are
626 exported. Lack of an exported function code sym may cause a
627 definition to be pulled in from a static library. */
628
629 static struct bfd_elf_version_expr *
630 gld${EMULATION_NAME}_new_vers_pattern (struct bfd_elf_version_expr *entry)
631 {
632 struct bfd_elf_version_expr *dot_entry;
633 unsigned int len;
634 char *dot_pat;
635
636 if (!dotsyms
637 || entry->pattern[0] == '.'
638 || (!entry->literal && entry->pattern[0] == '*'))
639 return entry;
640
641 dot_entry = xmalloc (sizeof *dot_entry);
642 *dot_entry = *entry;
643 dot_entry->next = entry;
644 len = strlen (entry->pattern) + 2;
645 dot_pat = xmalloc (len);
646 dot_pat[0] = '.';
647 memcpy (dot_pat + 1, entry->pattern, len - 1);
648 dot_entry->pattern = dot_pat;
649 dot_entry->script = 1;
650 return dot_entry;
651 }
652
653 EOF
654
655 if grep -q 'ld_elf32_spu_emulation' ldemul-list.h; then
656 fragment <<EOF
657 /* Special handling for embedded SPU executables. */
658 extern bfd_boolean embedded_spu_file (lang_input_statement_type *, const char *);
659
660 static bfd_boolean
661 ppc64_recognized_file (lang_input_statement_type *entry)
662 {
663 if (embedded_spu_file (entry, "-m64"))
664 return TRUE;
665
666 return ldelf_load_symbols (entry);
667 }
668 EOF
669 LDEMUL_RECOGNIZED_FILE=ppc64_recognized_file
670 fi
671
672 # Define some shell vars to insert bits of code into the standard elf
673 # parse_args and list_options functions.
674 #
675 PARSE_AND_LIST_PROLOGUE=${PARSE_AND_LIST_PROLOGUE}'
676 enum ppc64_opt
677 {
678 OPTION_STUBGROUP_SIZE = 321,
679 OPTION_PLT_STATIC_CHAIN,
680 OPTION_NO_PLT_STATIC_CHAIN,
681 OPTION_PLT_THREAD_SAFE,
682 OPTION_NO_PLT_THREAD_SAFE,
683 OPTION_PLT_ALIGN,
684 OPTION_NO_PLT_ALIGN,
685 OPTION_PLT_LOCALENTRY,
686 OPTION_NO_PLT_LOCALENTRY,
687 OPTION_POWER10_STUBS,
688 OPTION_NO_POWER10_STUBS,
689 OPTION_STUBSYMS,
690 OPTION_NO_STUBSYMS,
691 OPTION_SAVRES,
692 OPTION_NO_SAVRES,
693 OPTION_DOTSYMS,
694 OPTION_NO_DOTSYMS,
695 OPTION_NO_TLS_OPT,
696 OPTION_TLS_GET_ADDR_OPT,
697 OPTION_NO_TLS_GET_ADDR_OPT,
698 OPTION_TLS_GET_ADDR_REGSAVE,
699 OPTION_NO_TLS_GET_ADDR_REGSAVE,
700 OPTION_NO_OPD_OPT,
701 OPTION_NO_INLINE_OPT,
702 OPTION_NO_TOC_OPT,
703 OPTION_NO_MULTI_TOC,
704 OPTION_NO_TOC_SORT,
705 OPTION_NON_OVERLAPPING_OPD
706 };
707 '
708
709 PARSE_AND_LIST_LONGOPTS=${PARSE_AND_LIST_LONGOPTS}'
710 { "stub-group-size", required_argument, NULL, OPTION_STUBGROUP_SIZE },
711 { "plt-static-chain", no_argument, NULL, OPTION_PLT_STATIC_CHAIN },
712 { "no-plt-static-chain", no_argument, NULL, OPTION_NO_PLT_STATIC_CHAIN },
713 { "plt-thread-safe", no_argument, NULL, OPTION_PLT_THREAD_SAFE },
714 { "no-plt-thread-safe", no_argument, NULL, OPTION_NO_PLT_THREAD_SAFE },
715 { "plt-align", optional_argument, NULL, OPTION_PLT_ALIGN },
716 { "no-plt-align", no_argument, NULL, OPTION_NO_PLT_ALIGN },
717 { "plt-localentry", optional_argument, NULL, OPTION_PLT_LOCALENTRY },
718 { "no-plt-localentry", no_argument, NULL, OPTION_NO_PLT_LOCALENTRY },
719 { "power10-stubs", no_argument, NULL, OPTION_POWER10_STUBS },
720 { "no-power10-stubs", no_argument, NULL, OPTION_NO_POWER10_STUBS },
721 { "emit-stub-syms", no_argument, NULL, OPTION_STUBSYMS },
722 { "no-emit-stub-syms", no_argument, NULL, OPTION_NO_STUBSYMS },
723 { "dotsyms", no_argument, NULL, OPTION_DOTSYMS },
724 { "no-dotsyms", no_argument, NULL, OPTION_NO_DOTSYMS },
725 { "save-restore-funcs", no_argument, NULL, OPTION_SAVRES },
726 { "no-save-restore-funcs", no_argument, NULL, OPTION_NO_SAVRES },
727 { "no-tls-optimize", no_argument, NULL, OPTION_NO_TLS_OPT },
728 { "tls-get-addr-optimize", no_argument, NULL, OPTION_TLS_GET_ADDR_OPT },
729 { "no-tls-get-addr-optimize", no_argument, NULL, OPTION_NO_TLS_GET_ADDR_OPT },
730 { "tls-get-addr-regsave", no_argument, NULL, OPTION_TLS_GET_ADDR_REGSAVE },
731 { "no-tls-get-addr-regsave", no_argument, NULL, OPTION_NO_TLS_GET_ADDR_REGSAVE},
732 { "no-opd-optimize", no_argument, NULL, OPTION_NO_OPD_OPT },
733 { "no-inline-optimize", no_argument, NULL, OPTION_NO_INLINE_OPT },
734 { "no-toc-optimize", no_argument, NULL, OPTION_NO_TOC_OPT },
735 { "no-multi-toc", no_argument, NULL, OPTION_NO_MULTI_TOC },
736 { "no-toc-sort", no_argument, NULL, OPTION_NO_TOC_SORT },
737 { "non-overlapping-opd", no_argument, NULL, OPTION_NON_OVERLAPPING_OPD },
738 '
739
740 PARSE_AND_LIST_OPTIONS=${PARSE_AND_LIST_OPTIONS}'
741 fprintf (file, _("\
742 --stub-group-size=N Maximum size of a group of input sections that\n\
743 can be handled by one stub section. A negative\n\
744 value locates all stubs before their branches\n\
745 (with a group size of -N), while a positive\n\
746 value allows two groups of input sections, one\n\
747 before, and one after each stub section.\n\
748 Values of +/-1 indicate the linker should\n\
749 choose suitable defaults.\n"
750 ));
751 fprintf (file, _("\
752 --plt-static-chain PLT call stubs should load r11'${DEFAULT_PLT_STATIC_CHAIN- (default)}'\n"
753 ));
754 fprintf (file, _("\
755 --no-plt-static-chain PLT call stubs should not load r11'${DEFAULT_PLT_STATIC_CHAIN+ (default)}'\n"
756 ));
757 fprintf (file, _("\
758 --plt-thread-safe PLT call stubs with load-load barrier\n"
759 ));
760 fprintf (file, _("\
761 --no-plt-thread-safe PLT call stubs without barrier\n"
762 ));
763 fprintf (file, _("\
764 --plt-align [=<align>] Align PLT call stubs to fit cache lines\n"
765 ));
766 fprintf (file, _("\
767 --no-plt-align Dont'\''t align individual PLT call stubs\n"
768 ));
769 fprintf (file, _("\
770 --plt-localentry Optimize calls to ELFv2 localentry:0 functions\n"
771 ));
772 fprintf (file, _("\
773 --no-plt-localentry Don'\''t optimize ELFv2 calls\n"
774 ));
775 fprintf (file, _("\
776 --power10-stubs Use Power10 PLT call stubs (default auto)\n"
777 ));
778 fprintf (file, _("\
779 --no-power10-stubs Don'\''t use Power10 PLT call stubs\n"
780 ));
781 fprintf (file, _("\
782 --emit-stub-syms Label linker stubs with a symbol\n"
783 ));
784 fprintf (file, _("\
785 --no-emit-stub-syms Don'\''t label linker stubs with a symbol\n"
786 ));
787 fprintf (file, _("\
788 --dotsyms For every version pattern \"foo\" in a version\n\
789 script, add \".foo\" so that function code\n\
790 symbols are treated the same as function\n\
791 descriptor symbols. Defaults to on.\n"
792 ));
793 fprintf (file, _("\
794 --no-dotsyms Don'\''t do anything special in version scripts\n"
795 ));
796 fprintf (file, _("\
797 --save-restore-funcs Provide register save and restore routines used\n\
798 by gcc -Os code. Defaults to on for normal\n\
799 final link, off for ld -r.\n"
800 ));
801 fprintf (file, _("\
802 --no-save-restore-funcs Don'\''t provide these routines\n"
803 ));
804 fprintf (file, _("\
805 --no-tls-optimize Don'\''t try to optimize TLS accesses\n"
806 ));
807 fprintf (file, _("\
808 --tls-get-addr-optimize Force use of special __tls_get_addr call\n"
809 ));
810 fprintf (file, _("\
811 --no-tls-get-addr-optimize Don'\''t use a special __tls_get_addr call\n"
812 ));
813 fprintf (file, _("\
814 --tls-get-addr-regsave Force register save __tls_get_addr stub\n"
815 ));
816 fprintf (file, _("\
817 --no-tls-get-addr-regsave Don'\''t use register save __tls_get_addr stub\n"
818 ));
819 fprintf (file, _("\
820 --no-opd-optimize Don'\''t optimize the OPD section\n"
821 ));
822 fprintf (file, _("\
823 --no-inline-optimize Don'\''t convert inline PLT to direct calls\n"
824 ));
825 fprintf (file, _("\
826 --no-toc-optimize Don'\''t optimize the TOC section\n"
827 ));
828 fprintf (file, _("\
829 --no-multi-toc Disallow automatic multiple toc sections\n"
830 ));
831 fprintf (file, _("\
832 --no-toc-sort Don'\''t sort TOC and GOT sections\n"
833 ));
834 fprintf (file, _("\
835 --non-overlapping-opd Canonicalize .opd, so that there are no\n\
836 overlapping .opd entries\n"
837 ));
838 '
839
840 PARSE_AND_LIST_ARGS_CASES=${PARSE_AND_LIST_ARGS_CASES}'
841 case OPTION_STUBGROUP_SIZE:
842 {
843 const char *end;
844 params.group_size = bfd_scan_vma (optarg, &end, 0);
845 if (*end)
846 einfo (_("%F%P: invalid number `%s'\''\n"), optarg);
847 }
848 break;
849
850 case OPTION_PLT_STATIC_CHAIN:
851 params.plt_static_chain = 1;
852 break;
853
854 case OPTION_NO_PLT_STATIC_CHAIN:
855 params.plt_static_chain = 0;
856 break;
857
858 case OPTION_PLT_THREAD_SAFE:
859 params.plt_thread_safe = 1;
860 break;
861
862 case OPTION_NO_PLT_THREAD_SAFE:
863 params.plt_thread_safe = 0;
864 break;
865
866 case OPTION_PLT_ALIGN:
867 if (optarg != NULL)
868 {
869 char *end;
870 long val = strtol (optarg, &end, 0);
871 if (*end || (unsigned long) val + 8 > 16)
872 einfo (_("%F%P: invalid --plt-align `%s'\''\n"), optarg);
873 params.plt_stub_align = val;
874 }
875 else
876 params.plt_stub_align = 5;
877 break;
878
879 case OPTION_NO_PLT_ALIGN:
880 params.plt_stub_align = 0;
881 break;
882
883 case OPTION_PLT_LOCALENTRY:
884 params.plt_localentry0 = 1;
885 break;
886
887 case OPTION_NO_PLT_LOCALENTRY:
888 params.plt_localentry0 = 0;
889 break;
890
891 case OPTION_POWER10_STUBS:
892 params.power10_stubs = 1;
893 break;
894
895 case OPTION_NO_POWER10_STUBS:
896 params.power10_stubs = 0;
897 break;
898
899 case OPTION_STUBSYMS:
900 params.emit_stub_syms = 1;
901 break;
902
903 case OPTION_NO_STUBSYMS:
904 params.emit_stub_syms = 0;
905 break;
906
907 case OPTION_DOTSYMS:
908 dotsyms = 1;
909 break;
910
911 case OPTION_NO_DOTSYMS:
912 dotsyms = 0;
913 break;
914
915 case OPTION_SAVRES:
916 params.save_restore_funcs = 1;
917 break;
918
919 case OPTION_NO_SAVRES:
920 params.save_restore_funcs = 0;
921 break;
922
923 case OPTION_NO_TLS_OPT:
924 no_tls_opt = 1;
925 break;
926
927 case OPTION_TLS_GET_ADDR_OPT:
928 params.tls_get_addr_opt = 1;
929 break;
930
931 case OPTION_NO_TLS_GET_ADDR_OPT:
932 params.tls_get_addr_opt = 0;
933 break;
934
935 case OPTION_TLS_GET_ADDR_REGSAVE:
936 params.no_tls_get_addr_regsave = 0;
937 break;
938
939 case OPTION_NO_TLS_GET_ADDR_REGSAVE:
940 params.no_tls_get_addr_regsave = 1;
941 break;
942
943 case OPTION_NO_OPD_OPT:
944 no_opd_opt = 1;
945 break;
946
947 case OPTION_NO_INLINE_OPT:
948 no_inline_opt = 1;
949 break;
950
951 case OPTION_NO_TOC_OPT:
952 no_toc_opt = 1;
953 break;
954
955 case OPTION_NO_MULTI_TOC:
956 params.no_multi_toc = 1;
957 break;
958
959 case OPTION_NO_TOC_SORT:
960 no_toc_sort = 1;
961 break;
962
963 case OPTION_NON_OVERLAPPING_OPD:
964 params.non_overlapping_opd = 1;
965 break;
966
967 case OPTION_TRADITIONAL_FORMAT:
968 no_tls_opt = 1;
969 params.tls_get_addr_opt = 0;
970 no_opd_opt = 1;
971 no_toc_opt = 1;
972 params.no_multi_toc = 1;
973 no_toc_sort = 1;
974 params.plt_static_chain = 1;
975 return FALSE;
976 '
977
978 # Put these extra ppc64elf routines in ld_${EMULATION_NAME}_emulation
979 #
980 LDEMUL_NEW_VERS_PATTERN=gld${EMULATION_NAME}_new_vers_pattern
981 LDEMUL_CREATE_OUTPUT_SECTION_STATEMENTS=ppc_create_output_section_statements
982 LDEMUL_AFTER_OPEN=ppc_after_open
983 LDEMUL_BEFORE_ALLOCATION=ppc_before_allocation
984 LDEMUL_AFTER_ALLOCATION=gld${EMULATION_NAME}_after_allocation
985 LDEMUL_FINISH=gld${EMULATION_NAME}_finish