blob: 273502dd802335f62b6aa8c45101497aa5933a5d [file] [log] [blame]
# This shell script emits a C file. -*- C -*-
# Copyright 2023 Free Software Foundation, Inc.
#
# This file is part of GLD, the Gnu Linker.
#
# 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 2 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 elf.em, and defines extra Neutrino
# specific routines.
# NTO templates aims to refine the default ${ARCH}elf.em template.
. "${srcdir}/emultempl/${ARCH}elf.em"
cat >>e${EMULATION_NAME}.c <<EOF
#include "elf/internal.h"
#include "elf/common.h"
#include "elf-bfd.h"
#include "../bfd/libbfd.h"
bool nto_lazy_stack = false;
struct nto_stack_note
{
unsigned char stacksize[4];
unsigned char stackalloc[4];
unsigned char execstack[4];
};
static asection*
nto_create_QNX_note_section(int type)
{
asection *note_sec;
flagword flags;
Elf_External_Note *e_note;
bfd_size_type size;
/* As ${ARCH}elf.em is imported and ${ARCH}_elf_create_output_section_statements
is called before this function, stub_file should already be defined. */
if (!stub_file)
{
einfo (_("%F%P: cannot create .note section in stub BFD.\n"));
return NULL;
}
flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_HAS_CONTENTS
| SEC_IN_MEMORY | SEC_LINKER_CREATED);
note_sec = bfd_make_section_anyway_with_flags (stub_file->the_bfd, ".note", flags);
if (! note_sec)
{
einfo (_("%F%P: failed to create .note section\n"));
return NULL;
}
size = offsetof (Elf_External_Note, name[sizeof "QNX"]);
size = (size + 3) & -(bfd_size_type) 4;
size += sizeof (struct nto_stack_note);
note_sec->size = size;
elf_section_type (note_sec) = SHT_NOTE;
note_sec->contents = xmalloc (note_sec->size);
e_note = (Elf_External_Note *) note_sec->contents;
bfd_h_put_32 (stub_file->the_bfd, sizeof "QNX", &e_note->namesz);
bfd_h_put_32 (stub_file->the_bfd, sizeof (struct nto_stack_note), &e_note->descsz);
bfd_h_put_32 (stub_file->the_bfd, type, &e_note->type);
memcpy (e_note->name, "QNX", sizeof "QNX");
return note_sec;
}
/* Lookup for a section holding a QNX note or create a new section. */
static asection*
nto_lookup_QNX_note_section(int type)
{
asection *stack_note_sec = NULL;
bfd *abfd;
bool duplicated_notes_detected = false;
for (abfd = link_info.input_bfds; abfd != NULL; abfd = abfd->link.next)
{
Elf_External_Note *e_note;
asection *sec;
/* QNX notes are held under a note section simply named ".note". */
sec = bfd_get_section_by_name (abfd, ".note");
if (!sec)
continue;
/* Verify that this is a QNX note of the expected type. */
sec->contents = xmalloc(sec->size);
if (!bfd_get_section_contents (sec->owner, sec, sec->contents, (file_ptr) 0,
sec->size))
einfo (_("%F%P: %pB: can't read contents of section .note: %E\n"),
sec->owner);
e_note = (Elf_External_Note *) sec->contents;
if (! strcmp("QNX", e_note->name) && *e_note->type == type)
{
if (stack_note_sec)
{
if (!duplicated_notes_detected)
{
einfo (_("%P: %pB: warning: duplicated QNX stack .note detected\n"),
stack_note_sec->owner);
duplicated_notes_detected = true;
}
einfo (_("%P: %pB: warning: duplicated QNX stack .note detected\n"),
sec->owner);
}
else
{
stack_note_sec = sec;
/* Allow modification of this .note content. */
stack_note_sec->flags |= SEC_IN_MEMORY;
}
}
}
if (stack_note_sec)
return stack_note_sec;
else
return nto_create_QNX_note_section(type);
}
/* Generate the QNX stack .note section. */
static void
nto_add_note_section (void) {
asection *note_sec;
struct nto_stack_note *n_note;
bfd_size_type h_size;
bool is_update = false;
if (nto_lazy_stack && !link_info.stacksize)
{
einfo (_("%F%P: error: --lazy-stack must follow -zstack-size=<size>\n"));
return;
}
/* Don't create a note if none of the stack parameter have to be modified. */
if (link_info.stacksize <= 0 && (link_info.execstack == link_info.noexecstack))
return;
note_sec = nto_lookup_QNX_note_section(QNT_STACK);
if (! note_sec)
return;
/* Update QNX stack note content. */
h_size = note_sec->size - sizeof(struct nto_stack_note);
n_note = (struct nto_stack_note *) (note_sec->contents + h_size);
is_update = note_sec->owner != stub_file->the_bfd;
if (link_info.stacksize > 0)
bfd_h_put_32 (note_sec->owner, link_info.stacksize, &n_note->stacksize);
else if (!is_update)
bfd_h_put_32 (note_sec->owner, 0, &n_note->stacksize);
if (nto_lazy_stack || (!is_update && link_info.stacksize <= 0))
bfd_h_put_32 (note_sec->owner, 4096, &n_note->stackalloc);
else if (link_info.stacksize > 0)
bfd_h_put_32 (note_sec->owner, link_info.stacksize, &n_note->stackalloc);
if (link_info.execstack)
bfd_h_put_32 (note_sec->owner, 0, &n_note->execstack);
else if (!is_update || link_info.noexecstack)
bfd_h_put_32 (note_sec->owner, 1, &n_note->execstack);
}
static void
nto_after_open (void)
{
nto_add_note_section();
gld${EMULATION_NAME}_after_open ();
}
EOF
# Define some shell vars to insert bits of code into the standard elf
# parse_args and list_options functions.
#
PARSE_AND_LIST_PROLOGUE=${PARSE_AND_LIST_PROLOGUE}'
enum nto_options
{
OPTION_STACK = 500,
OPTION_LAZY_STACK,
};
'
PARSE_AND_LIST_LONGOPTS=${PARSE_AND_LIST_LONGOPTS}'
{ "stack", required_argument, NULL, OPTION_STACK },
{ "lazy-stack", no_argument, NULL, OPTION_LAZY_STACK },
'
PARSE_AND_LIST_OPTIONS=${PARSE_AND_LIST_OPTIONS}'
fprintf (file, _("\
--stack <size> Set size of the initial stack\n\
--lazy-stack Set lazy allocation of stack\n\
"));
'
PARSE_AND_LIST_ARGS_CASES=${PARSE_AND_LIST_ARGS_CASES}'
case OPTION_STACK:
{
char *end;
link_info.stacksize = strtoul (optarg, &end, 0);
if (*end || link_info.stacksize < 0)
einfo (_("%F%P: invalid stack size `%s'\''\n"), optarg + 11);
if (!link_info.stacksize)
/* Use -1 for explicit no-stack, because zero means
'default'. */
link_info.stacksize = -1;
break;
}
case OPTION_LAZY_STACK:
nto_lazy_stack = true;
break;
'
# Put these extra Neutrino routines in ld_${EMULATION_NAME}_emulation
#
LDEMUL_AFTER_OPEN=nto_after_open