# This shell script emits a C file. -*- C -*-
-# Copyright 2001, 2002, 2003, 2004, 2006, 2007, 2008
-# Free Software Foundation, Inc.
+# Copyright (C) 2001-2020 Free Software Foundation, Inc.
#
# This file is part of the GNU Binutils.
#
fragment <<EOF
/* Need to have this macro defined before mmix-elfnmmo, which uses the
name for the before_allocation function, defined in ldemul.c (for
- the mmo "emulation") or in elf32.em (for the elf64mmix
+ the mmo "emulation") or in elf.em (for the elf64mmix
"emulation"). */
#define gldmmo_before_allocation before_allocation_default
/* We include this header *not* because we expect to handle ELF here
- but because we re-use the map_segments function in elf-generic.em,
- a file which is rightly somewhat ELF-centric. But this is only to
+ but because we use the map_segments function. But this is only to
get a weird testcase right; ld-mmix/bpo-22, forcing ELF to be
output from the mmo emulation: -m mmo --oformat elf64-mmix! */
-#include "elf-bfd.h"
+#include "ldelfgen.h"
+
+static void gld${EMULATION_NAME}_after_allocation (void);
EOF
source_em ${srcdir}/emultempl/elf-generic.em
/* Place an orphan section. We use this to put random SEC_CODE or
SEC_READONLY sections right after MMO_TEXT_SECTION_NAME. Much borrowed
- from elf32.em. */
+ from elf.em. */
static lang_output_section_statement_type *
mmo_place_orphan (asection *s,
const char *secname,
int constraint ATTRIBUTE_UNUSED)
{
- static struct orphan_save hold_text =
- {
- MMO_TEXT_SECTION_NAME,
- SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_CODE,
- 0, 0, 0, 0
- };
- struct orphan_save *place;
+ static struct
+ {
+ flagword nonzero_flags;
+ struct orphan_save orphansave;
+ } holds[] =
+ {
+ {
+ SEC_CODE | SEC_READONLY,
+ {
+ MMO_TEXT_SECTION_NAME,
+ SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_CODE,
+ 0, 0, 0, 0
+ }
+ },
+ {
+ SEC_LOAD | SEC_DATA,
+ {
+ MMO_DATA_SECTION_NAME,
+ SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_DATA,
+ 0, 0, 0, 0
+ }
+ },
+ {
+ SEC_ALLOC,
+ {
+ ".bss",
+ SEC_ALLOC,
+ 0, 0, 0, 0
+ }
+ }
+ };
+
+ struct orphan_save *place = NULL;
lang_output_section_statement_type *after;
lang_output_section_statement_type *os;
-
- /* We have nothing to say for anything other than a final link. */
- if (link_info.relocatable
- || (s->flags & (SEC_EXCLUDE | SEC_LOAD)) != SEC_LOAD)
+ size_t i;
+ flagword flags;
+ asection *nexts;
+
+ /* We have nothing to say for anything other than a final link or
+ for sections that are excluded. */
+ if (bfd_link_relocatable (&link_info)
+ || (s->flags & SEC_EXCLUDE) != 0)
return NULL;
- /* Only care for sections we're going to load. */
os = lang_output_section_find (secname);
/* We have an output section by this name. Place the section inside it
(regardless of whether the linker script lists it as input). */
if (os != NULL)
{
- lang_add_section (&os->children, s, os);
+ lang_add_section (&os->children, s, NULL, os);
return os;
}
- /* If this section does not have .text-type section flags or there's no
- MMO_TEXT_SECTION_NAME, we don't have anything to say. */
- if ((s->flags & (SEC_CODE | SEC_READONLY)) == 0)
- return NULL;
+ flags = s->flags;
+ if (!bfd_link_relocatable (&link_info))
+ {
+ nexts = s;
+ while ((nexts = bfd_get_next_section_by_name (nexts->owner, nexts))
+ != NULL)
+ if (nexts->output_section == NULL
+ && (nexts->flags & SEC_EXCLUDE) == 0
+ && ((nexts->flags ^ flags) & (SEC_LOAD | SEC_ALLOC)) == 0
+ && (nexts->owner->flags & DYNAMIC) == 0
+ && !bfd_input_just_syms (nexts->owner))
+ flags = (((flags ^ SEC_READONLY) | (nexts->flags ^ SEC_READONLY))
+ ^ SEC_READONLY);
+ }
- if (hold_text.os == NULL)
- hold_text.os = lang_output_section_find (hold_text.name);
+ /* Check for matching section type flags for sections we care about.
+ A section without contents can have SEC_LOAD == 0, but we still
+ want it attached to a sane section so the symbols appear as
+ expected. */
- place = &hold_text;
- if (hold_text.os != NULL)
- after = hold_text.os;
- else
- after = &lang_output_section_statement.head->output_section_statement;
+ if ((flags & (SEC_ALLOC | SEC_READONLY)) != SEC_READONLY)
+ for (i = 0; i < sizeof (holds) / sizeof (holds[0]); i++)
+ if ((flags & holds[i].nonzero_flags) != 0)
+ {
+ place = &holds[i].orphansave;
+ if (place->os == NULL)
+ place->os = lang_output_section_find (place->name);
+ break;
+ }
- /* If there's an output section by this name, we'll use it, regardless
- of section flags, in contrast to what's done in elf32.em. */
- os = lang_insert_orphan (s, secname, 0, after, place, NULL, NULL);
+ if (place == NULL)
+ {
+ /* For other combinations, we have to give up, except we make
+ sure not to place the orphan section after the
+ linker-generated register section; that'd make it continue
+ the reg section and we never want that to happen for orphan
+ sections. */
+ lang_output_section_statement_type *before;
+ lang_output_section_statement_type *lookup;
+ static struct orphan_save hold_nonreg =
+ {
+ NULL,
+ SEC_READONLY,
+ 0, 0, 0, 0
+ };
+
+ if (hold_nonreg.os == NULL)
+ {
+ before = lang_output_section_find (MMIX_REG_CONTENTS_SECTION_NAME);
- /* We need an output section for .text as a root, so if there was none
- (might happen with a peculiar linker script such as in "map
- addresses", map-address.exp), we grab the output section created
- above. */
- if (hold_text.os == NULL)
- hold_text.os = os;
+ /* If we have no such section, all fine; we don't care where
+ it's placed. */
+ if (before == NULL)
+ return NULL;
+
+ /* We have to find the oss before this one, so we can use that as
+ "after". */
+ for (lookup = (void *) lang_os_list.head;
+ lookup != NULL && lookup->next != before;
+ lookup = lookup->next)
+ ;
+
+ hold_nonreg.os = lookup;
+ }
+
+ place = &hold_nonreg;
+ }
+
+ after = place->os;
+ if (after == NULL)
+ return NULL;
+
+ /* If there's an output section by *this* name, we'll use it, regardless
+ of actual section flags, in contrast to what's done in elf.em. */
+ os = lang_insert_orphan (s, secname, 0, after, place, NULL, NULL);
return os;
}
paper over the bug similarly. */
static void
-mmo_wipe_sec_reloc_flag (bfd *abfd, asection *sec, void *ptr ATTRIBUTE_UNUSED)
+mmo_wipe_sec_reloc_flag (bfd *abfd ATTRIBUTE_UNUSED, asection *sec,
+ void *ptr ATTRIBUTE_UNUSED)
{
- bfd_set_section_flags (abfd, sec,
- bfd_get_section_flags (abfd, sec) & ~SEC_RELOC);
+ bfd_set_section_flags (sec, bfd_section_flags (sec) & ~SEC_RELOC);
}
/* Iterate with bfd_map_over_sections over mmo_wipe_sec_reloc_flag... */
static void
-mmo_finish (void)
+gld${EMULATION_NAME}_after_allocation (void)
{
bfd_map_over_sections (link_info.output_bfd, mmo_wipe_sec_reloc_flag, NULL);
- gld${EMULATION_NAME}_map_segments (FALSE);
- finish_default ();
+ ldelf_map_segments (FALSE);
}
\f
/* To get on-demand global register allocation right, we need to parse the
{
if (bfd_get_flavour (is->the_bfd) == bfd_target_elf_flavour
&& !_bfd_mmix_check_all_relocs (is->the_bfd, &link_info))
- einfo ("%X%P: Internal problems scanning %B after opening it",
+ einfo (_("%X%P: internal problems scanning %pB after opening it"),
is->the_bfd);
}
}
+ after_open_default ();
}
EOF
LDEMUL_PLACE_ORPHAN=mmo_place_orphan
-LDEMUL_FINISH=mmo_finish
LDEMUL_AFTER_OPEN=mmo_after_open
projects / deliverable / binutils-gdb.git / blobdiff