/* ELF object file format

   Copyright (C) 1992-2025 Free Software Foundation, Inc.

   This file is part of GAS, the GNU Assembler.

   GAS 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 3,

   or (at your option) any later version.

   GAS 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 GAS; see the file COPYING.  If not, write to the Free

   Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA

   02110-1301, USA.  */

#define OBJ_HEADER "obj-elf.h"

#include "as.h"

#include "safe-ctype.h"

#include "subsegs.h"

#include "obstack.h"

#include "dwarf2dbg.h"

#include "ginsn.h"

#ifndef ECOFF_DEBUGGING

#define ECOFF_DEBUGGING 0

#else

#define NEED_ECOFF_DEBUG

#endif

#ifdef NEED_ECOFF_DEBUG

#include "ecoff.h"

#include "bfd/ecoff-bfd.h"

#endif

#ifdef TC_ALPHA

#include "elf/alpha.h"

#endif

#ifdef TC_MIPS

#include "elf/mips.h"

#endif

#ifdef TC_PPC

#include "elf/ppc.h"

#endif

#ifdef TC_I386

#include "elf/x86-64.h"

#endif

#ifdef TC_MEP

#include "elf/mep.h"

#endif

#ifdef TC_PRU

#include "elf/pru.h"

#endif

static void obj_elf_line (int);

static void obj_elf_size (int);

static void obj_elf_type (int);

static void obj_elf_ident (int);

static void obj_elf_weak (int);

static void obj_elf_local (int);

static void obj_elf_visibility (int);

static void obj_elf_symver (int);

static void obj_elf_subsection (int);

static void obj_elf_popsection (int);

static void obj_elf_gnu_attribute (int);

static void obj_elf_tls_common (int);

static void obj_elf_lcomm (int);

static void obj_elf_struct (int);

static void obj_elf_attach_to_group (int);

static const pseudo_typeS elf_pseudo_table[] =

{

  {"attach_to_group", obj_elf_attach_to_group, 0},

  {"comm", obj_elf_common, 0},

  {"common", obj_elf_common, 1},

  {"ident", obj_elf_ident, 0},

  {"lcomm", obj_elf_lcomm, 0},

  {"local", obj_elf_local, 0},

  {"previous", obj_elf_previous, 0},

  {"section", obj_elf_section, 0},

  {"section.s", obj_elf_section, 0},

  {"sect", obj_elf_section, 0},

  {"sect.s", obj_elf_section, 0},

  {"pushsection", obj_elf_section, 1},

  {"popsection", obj_elf_popsection, 0},

  {"size", obj_elf_size, 0},

  {"type", obj_elf_type, 0},

  {"version", obj_elf_version, 0},

  {"weak", obj_elf_weak, 0},

  /* These define symbol visibility.  */

  {"internal", obj_elf_visibility, STV_INTERNAL},

  {"hidden", obj_elf_visibility, STV_HIDDEN},

  {"protected", obj_elf_visibility, STV_PROTECTED},

  /* These are used for stabs-in-elf configurations.  */

  {"line", obj_elf_line, 0},

  /* This is a GNU extension to handle symbol versions.  */

  {"symver", obj_elf_symver, 0},

  /* A GNU extension to change subsection only.  */

  {"subsection", obj_elf_subsection, 0},

  /* These are GNU extensions to aid in garbage collecting C++ vtables.  */

  {"vtable_inherit", obj_elf_vtable_inherit, 0},

  {"vtable_entry", obj_elf_vtable_entry, 0},

  /* A GNU extension for object attributes.  */

  {"gnu_attribute", obj_elf_gnu_attribute, 0},

  /* These are used for dwarf2.  */

  { "file", dwarf2_directive_file, 0 },

  { "loc",  dwarf2_directive_loc,  0 },

  { "loc_mark_labels", dwarf2_directive_loc_mark_labels, 0 },

  /* We need to trap the section changing calls to handle .previous.  */

  {"data", obj_elf_data, 0},

  {"offset", obj_elf_struct, 0},

  {"struct", obj_elf_struct, 0},

  {"text", obj_elf_text, 0},

  {"bss", obj_elf_bss, 0},

  {"tls_common", obj_elf_tls_common, 0},

  /* End sentinel.  */

  {NULL, NULL, 0},

};

static const pseudo_typeS ecoff_debug_pseudo_table[] =

{

#ifdef NEED_ECOFF_DEBUG

  /* COFF style debugging information for ECOFF. .ln is not used; .loc

     is used instead.  */

  { "def",  ecoff_directive_def,  0 },

  { "dim",  ecoff_directive_dim,  0 },

  { "endef",  ecoff_directive_endef,  0 },

  { "file", ecoff_directive_file, 0 },

  { "scl",  ecoff_directive_scl,  0 },

  { "tag",  ecoff_directive_tag,  0 },

  { "val",  ecoff_directive_val,  0 },

  /* COFF debugging requires pseudo-ops .size and .type, but ELF

     already has meanings for those.  We use .esize and .etype

     instead.  These are only generated by gcc anyhow.  */

  { "esize",  ecoff_directive_size, 0 },

  { "etype",  ecoff_directive_type, 0 },

  /* ECOFF specific debugging information.  */

  { "aent", ecoff_directive_ent,  1 },

  { "begin",  ecoff_directive_begin,  0 },

  { "bend", ecoff_directive_bend, 0 },

  { "end",  ecoff_directive_end,  0 },

  { "ent",  ecoff_directive_ent,  0 },

  { "fmask",  ecoff_directive_fmask,  0 },

  { "frame",  ecoff_directive_frame,  0 },

  { "loc",  ecoff_directive_loc,  0 },

  { "mask", ecoff_directive_mask, 0 },

  /* Other ECOFF directives.  */

  { "extern", ecoff_directive_extern, 0 },

  /* These are used on Irix.  I don't know how to implement them.  */

  { "alias",  s_ignore,   0 },

  { "bgnb", s_ignore,   0 },

  { "endb", s_ignore,   0 },

  { "lab",  s_ignore,   0 },

  { "noalias",  s_ignore,   0 },

  { "verstamp", s_ignore,   0 },

  { "vreg", s_ignore,   0 },

#endif

  {NULL, NULL, 0}     /* end sentinel */

};

#undef NO_RELOC

#include "aout/aout64.h"

asection *elf_com_section_ptr;

void

elf_pop_insert (void)

{

  pop_insert (elf_pseudo_table);

  if (ECOFF_DEBUGGING)

    pop_insert (ecoff_debug_pseudo_table);

}

void

elf_file_symbol (const char *s)

{

  asymbol *bsym;

  symbolS *sym = symbol_new (s, absolute_section, &zero_address_frag, 0);

  size_t name_length = strlen (s);

  if (name_length > strlen (S_GET_NAME (sym)))

    {

      obstack_grow (&notes, s, name_length + 1);

      S_SET_NAME (sym, (const char *) obstack_finish (&notes));

    }

  else

    strcpy ((char *) S_GET_NAME (sym), s);

  symbol_get_bfdsym (sym)->flags |= BSF_FILE;

  if (symbol_rootP != sym

      && ((bsym = symbol_get_bfdsym (symbol_rootP)) == NULL

    || (bsym->flags & BSF_FILE) == 0))

    {

      symbol_remove (sym, &symbol_rootP, &symbol_lastP);

      symbol_insert (sym, symbol_rootP, &symbol_rootP, &symbol_lastP);

    }

#ifdef DEBUG

  verify_symbol_chain (symbol_rootP, symbol_lastP);

#endif

#ifdef NEED_ECOFF_DEBUG

  ecoff_new_file (s);

#endif

}

/* Called from read.c:s_comm after we've parsed .comm symbol, size.

   Parse a possible alignment value.  */

symbolS *

elf_common_parse (int ignore ATTRIBUTE_UNUSED, symbolS *symbolP, addressT size)

{

  addressT align = 0;

  int is_local = symbol_get_obj (symbolP)->local;

  if (*input_line_pointer == ',')

    {

      char *save = input_line_pointer;

      input_line_pointer++;

      SKIP_WHITESPACE ();

      if (*input_line_pointer == '"')

  {

    /* For sparc.  Accept .common symbol, length, "bss"  */

    input_line_pointer++;

    /* Some use the dot, some don't.  */

    if (*input_line_pointer == '.')

      input_line_pointer++;

    /* Some say data, some say bss.  */

    if (startswith (input_line_pointer, "bss\""))

      input_line_pointer += 4;

    else if (startswith (input_line_pointer, "data\""))

      input_line_pointer += 5;

    else

      {

        char *p = input_line_pointer;

        char c;

        while (*--p != '"')

    ;

        while (!is_end_of_stmt (*input_line_pointer))

    if (*input_line_pointer++ == '"')

      break;

        c = *input_line_pointer;

        *input_line_pointer = '\0';

        as_bad (_("bad .common segment %s"), p);

        *input_line_pointer = c;

        ignore_rest_of_line ();

        return NULL;

      }

    /* ??? Don't ask me why these are always global.  */

    is_local = 0;

  }

      else

  {

    input_line_pointer = save;

    align = parse_align (is_local);

    if (align == (addressT) -1)

      return NULL;

  }

    }

  if (is_local)

    {

      bss_alloc (symbolP, size, align);

      S_CLEAR_EXTERNAL (symbolP);

    }

  else

    {

      S_SET_VALUE (symbolP, size);

      S_SET_ALIGN (symbolP, align);

      S_SET_EXTERNAL (symbolP);

      S_SET_SEGMENT (symbolP, elf_com_section_ptr);

    }

  symbol_get_bfdsym (symbolP)->flags |= BSF_OBJECT;

  return symbolP;

}

void

obj_elf_common (int is_common)

{

  if (flag_mri && is_common)

    s_mri_common (0);

  else

    s_comm_internal (0, elf_common_parse);

}

static void

obj_elf_tls_common (int ignore ATTRIBUTE_UNUSED)

{

  symbolS *symbolP = s_comm_internal (0, elf_common_parse);

  if (symbolP)

    symbol_get_bfdsym (symbolP)->flags |= BSF_THREAD_LOCAL;

}

static void

obj_elf_lcomm (int ignore ATTRIBUTE_UNUSED)

{

  symbolS *symbolP = s_comm_internal (0, s_lcomm_internal);

  if (symbolP)

    symbol_get_bfdsym (symbolP)->flags |= BSF_OBJECT;

}

static symbolS *

get_sym_from_input_line_and_check (void)

{

  char *name;

  char c;

  symbolS *sym;

  c = get_symbol_name (& name);

  sym = symbol_find_or_make (name);

  restore_line_pointer (c);

  SKIP_WHITESPACE ();

  /* There is no symbol name if input_line_pointer has not moved.  */

  if (name == input_line_pointer)

    as_bad (_("Missing symbol name in directive"));

  return sym;

}

static void

obj_elf_local (int ignore ATTRIBUTE_UNUSED)

{

  int c;

  symbolS *symbolP;

  do

    {

      symbolP = get_sym_from_input_line_and_check ();

      c = *input_line_pointer;

      S_CLEAR_EXTERNAL (symbolP);

      symbol_get_obj (symbolP)->local = 1;

      if (c == ',')

  {

    input_line_pointer++;

    SKIP_WHITESPACE ();

    if (*input_line_pointer == '\n')

      c = '\n';

  }

    }

  while (c == ',');

  demand_empty_rest_of_line ();

}

static void

obj_elf_weak (int ignore ATTRIBUTE_UNUSED)

{

  int c;

  symbolS *symbolP;

  do

    {

      symbolP = get_sym_from_input_line_and_check ();

      c = *input_line_pointer;

      S_SET_WEAK (symbolP);

      if (c == ',')

  {

    input_line_pointer++;

    SKIP_WHITESPACE ();

    if (*input_line_pointer == '\n')

      c = '\n';

  }

    }

  while (c == ',');

  demand_empty_rest_of_line ();

}

static void

obj_elf_visibility (int visibility)

{

  int c;

  symbolS *symbolP;

  asymbol *bfdsym;

  elf_symbol_type *elfsym;

  do

    {

      symbolP = get_sym_from_input_line_and_check ();

      bfdsym = symbol_get_bfdsym (symbolP);

      elfsym = elf_symbol_from (bfdsym);

      gas_assert (elfsym);

      elfsym->internal_elf_sym.st_other &= ~3;

      elfsym->internal_elf_sym.st_other |= visibility;

      c = *input_line_pointer;

      if (c == ',')

  {

    input_line_pointer ++;

    SKIP_WHITESPACE ();

    if (*input_line_pointer == '\n')

      c = '\n';

  }

    }

  while (c == ',');

  demand_empty_rest_of_line ();

}

static segT previous_section;

static int previous_subsection;

struct section_stack

{

  struct section_stack *next;

  segT seg, prev_seg;

  int subseg, prev_subseg;

};

static struct section_stack *section_stack;

/* ELF section flags for unique sections.  */

#define SEC_ASSEMBLER_SHF_MASK SHF_GNU_RETAIN

struct group_list

{

  asection **head;    /* Section lists.  */

  unsigned int num_group; /* Number of lists.  */

  htab_t indexes; /* Maps group name to index in head array.  */

};

static struct group_list groups;

static bool

match_section (const asection *sec, const struct elf_section_match *match)

{

  const char *linked_to_symbol_name = sec->map_head.linked_to_symbol_name;

  unsigned int sh_info = elf_section_data (sec)->this_hdr.sh_info;

  bfd_vma sh_flags = (elf_section_data (sec)->this_hdr.sh_flags

          & SEC_ASSEMBLER_SHF_MASK);

  return (sh_info == match->sh_info

    && sh_flags == match->sh_flags

    && ((bfd_section_flags (sec) & SEC_ASSEMBLER_SECTION_ID)

         == (match->flags & SEC_ASSEMBLER_SECTION_ID))

    && sec->section_id == match->section_id

    && (linked_to_symbol_name == match->linked_to_symbol_name

        || (linked_to_symbol_name != NULL

      && match->linked_to_symbol_name != NULL

      && strcmp (linked_to_symbol_name,

           match->linked_to_symbol_name) == 0)));

}

/* Return TRUE iff SEC matches the section info INF.  */

static bool

get_section_by_match (bfd *abfd ATTRIBUTE_UNUSED, asection *sec, void *inf)

{

  struct elf_section_match *match = (struct elf_section_match *) inf;

  const char *gname = match->group_name;

  const char *group_name = elf_group_name (sec);

  return ((group_name == gname

     || (group_name != NULL

         && gname != NULL

         && strcmp (group_name, gname) == 0))

    && match_section (sec, match));

}

/* Go look in section lists kept per group for SEC_NAME with

   properties given by MATCH.  If info for the group named by

   MATCH->GROUP_NAME has been initialised, set GROUP_IDX.  */

static asection *

group_section_find (const struct elf_section_match *match,

        const char *sec_name,

        unsigned int *group_idx)

{

  if (!groups.indexes)

    {

      groups.num_group = 0;

      groups.head = NULL;

      groups.indexes = htab_create_alloc (16, hash_string_tuple, eq_string_tuple,

            NULL, notes_calloc, NULL);

      *group_idx = ~0u;

      return NULL;

    }

  *group_idx = str_hash_find_int (groups.indexes, match->group_name);

  if (*group_idx == ~0u)

    return NULL;

  asection *s;

  for (s = groups.head[*group_idx]; s != NULL; s = elf_next_in_group (s))

    if ((s->name == sec_name

   || strcmp (s->name, sec_name) == 0)

  && match_section (s, match))

      break;

  return s;

}

/* Insert SEC into section lists kept per group.  MATCH and GROUP_IDX

   must be from a prior call to group_section_find.  */

static void

group_section_insert (const struct elf_section_match *match,

          asection *sec,

          unsigned int *group_idx)

{

  if (*group_idx != ~0u)

    {

      elf_next_in_group (sec) = groups.head[*group_idx];

      groups.head[*group_idx] = sec;

      return;

    }

  unsigned int i = groups.num_group;

  if ((i & 127) == 0)

    groups.head = XRESIZEVEC (asection *, groups.head, i + 128);

  groups.head[i] = sec;

  groups.num_group += 1;

  /* We keep the index into groups.head rather than the entry address

     because groups.head may be realloc'd.  */

  str_hash_insert_int (groups.indexes, match->group_name, i, 0);

}

/* Handle the .section pseudo-op.  This code supports two different

   syntaxes.

   The first is found on Solaris, and looks like

       .section ".sec1",#alloc,#execinstr,#write

   Here the names after '#' are the SHF_* flags to turn on for the

   section.  I'm not sure how it determines the SHT_* type (BFD

   doesn't really give us control over the type, anyhow).

   The second format is found on UnixWare, and probably most SVR4

   machines, and looks like

       .section .sec1,"a",@progbits

   The quoted string may contain any combination of a, w, x, and

   represents the SHF_* flags to turn on for the section.  The string

   beginning with '@' can be progbits or nobits.  There should be

   other possibilities, but I don't know what they are.  In any case,

   BFD doesn't really let us set the section type.  */

static void

change_section (const char *name,

    unsigned int type,

    bfd_vma attr,

    int entsize,

    struct elf_section_match *match_p,

    bool linkonce,

    bool push,

    subsegT new_subsection)

{

  asection *old_sec;

  segT sec;

  flagword flags;

  const struct elf_backend_data *bed;

  const struct bfd_elf_special_section *ssect;

  if (match_p == NULL)

    {

      static struct elf_section_match unused_match;

      match_p = &unused_match;

    }

#ifdef md_flush_pending_output

  md_flush_pending_output ();

#endif

  /* Switch to the section, creating it if necessary.  */

  if (push)

    {

      struct section_stack *elt;

      elt = XNEW (struct section_stack);

      elt->next = section_stack;

      elt->seg = now_seg;

      elt->prev_seg = previous_section;

      elt->subseg = now_subseg;

      elt->prev_subseg = previous_subsection;

      section_stack = elt;

    }

  obj_elf_section_change_hook ();

  unsigned int group_idx = ~0u;

  if (match_p->group_name)

    old_sec = group_section_find (match_p, name, &group_idx);

  else

    old_sec = bfd_get_section_by_name_if (stdoutput, name, get_section_by_match,

            (void *) match_p);

  if (old_sec)

    {

      sec = old_sec;

      subseg_set (sec, new_subsection);

    }

  else

    {

      sec = subseg_force_new (name, new_subsection);

      if (match_p->group_name)

  group_section_insert (match_p, sec, &group_idx);

    }

  bed = get_elf_backend_data (stdoutput);

  ssect = (*bed->get_sec_type_attr) (stdoutput, sec);

  if (ssect != NULL)

    {

      bool override = false;

      if (type == SHT_NULL)

  type = ssect->type;

      else if (type != ssect->type)

  {

    if (old_sec == NULL

        /* Some older versions of gcc will emit

     .section .init_array,"aw",@progbits

     for __attribute__ ((section (".init_array"))).

     "@progbits" is incorrect.  Also for x86-64 large bss

     sections, some older versions of gcc will emit

     .section .lbss,"aw",@progbits

     "@progbits" is incorrect.  */

#ifdef TC_I386

        && (bed->s->arch_size != 64

      || !(ssect->attr & SHF_X86_64_LARGE))

#endif

        && ssect->type != SHT_INIT_ARRAY

        && ssect->type != SHT_FINI_ARRAY

        && ssect->type != SHT_PREINIT_ARRAY)

      {

        /* We allow to specify any type for a .note section.  */

        if (ssect->type != SHT_NOTE

      /* Processor and application defined types are allowed too.  */

      && type < SHT_LOPROC)

    as_warn (_("setting incorrect section type for %s"),

       name);

      }

    else

      {

        as_warn (_("ignoring incorrect section type for %s"),

           name);

        type = ssect->type;

      }

  }

      if (old_sec == NULL && ((attr & ~(SHF_LINK_ORDER

          | SHF_MASKOS

          | SHF_MASKPROC))

            & ~ssect->attr) != 0)

  {

    /* Strip SHF_GNU_RETAIN.  */

    bfd_vma generic_attr = attr;

    if (elf_tdata (stdoutput)->has_gnu_osabi)

      generic_attr &= ~SHF_GNU_RETAIN;

    /* As a GNU extension, we permit a .note section to be

       allocatable.  If the linker sees an allocatable .note

       section, it will create a PT_NOTE segment in the output

       file.  We also allow "x" for .note.GNU-stack.  */

    if (ssect->type == SHT_NOTE

        && (generic_attr == SHF_ALLOC

      || generic_attr == SHF_EXECINSTR))

      ;

    /* Allow different SHF_MERGE and SHF_STRINGS if we have

       something like .rodata.str.  */

    else if (ssect->suffix_length == -2

       && name[ssect->prefix_length] == '.'

       && (generic_attr

           & ~ssect->attr

           & ~SHF_MERGE

           & ~SHF_STRINGS) == 0)

      ;

    /* .interp, .strtab and .symtab can have SHF_ALLOC.  */

    else if (generic_attr == SHF_ALLOC

       && (strcmp (name, ".interp") == 0

           || strcmp (name, ".strtab") == 0

           || strcmp (name, ".symtab") == 0))

      override = true;

    /* .note.GNU-stack can have SHF_EXECINSTR.  */

    else if (generic_attr == SHF_EXECINSTR

       && strcmp (name, ".note.GNU-stack") == 0)

      override = true;

#ifdef TC_ALPHA

    /* A section on Alpha may have SHF_ALPHA_GPREL.  */

    else if ((generic_attr & ~ssect->attr) == SHF_ALPHA_GPREL)

      override = true;

#endif

#ifdef TC_RX

    else if (generic_attr == (SHF_EXECINSTR | SHF_WRITE | SHF_ALLOC)

       && (ssect->type == SHT_INIT_ARRAY

           || ssect->type == SHT_FINI_ARRAY

           || ssect->type == SHT_PREINIT_ARRAY))

      /* RX init/fini arrays can and should have the "awx" attributes set.  */

      ;

#endif

    else

      {

        if (match_p->group_name == NULL)

    as_warn (_("setting incorrect section attributes for %s"),

       name);

        override = true;

      }

  }

      if (!override && old_sec == NULL)

  attr |= ssect->attr;

    }

  /* Convert ELF type and flags to BFD flags.  */

  flags = (SEC_RELOC

     | ((attr & SHF_WRITE) ? 0 : SEC_READONLY)

     | ((attr & SHF_ALLOC) ? SEC_ALLOC : 0)

     | (((attr & SHF_ALLOC) && type != SHT_NOBITS) ? SEC_LOAD : 0)

     | ((attr & SHF_EXECINSTR) ? SEC_CODE : 0)

     | ((attr & SHF_MERGE) ? SEC_MERGE : 0)

     | ((attr & SHF_STRINGS) ? SEC_STRINGS : 0)

     | ((attr & SHF_EXCLUDE) ? SEC_EXCLUDE: 0)

     | ((attr & SHF_TLS) ? SEC_THREAD_LOCAL : 0));

#ifdef md_elf_section_flags

  flags = md_elf_section_flags (flags, attr, type);

#endif

  if (linkonce)

    flags |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD;

  /* PR 28054: Set the SEC_ELF_OCTETS flag for debugging sections.

     Based on the code in bfd/elf.c:_bfd_elf_make_section_from_shdr().

     FIXME: We do not set the SEC_DEBUGGING flag because that causes

     problems for the FT32 and MSP430 targets.  Investigate and fix.  */

  if ((flags & SEC_ALLOC) == 0 && name [0] == '.')

    {

      if (   startswith (name, ".debug")

    || startswith (name, ".zdebug")

    || startswith (name, ".gnu.debuglto_.debug_")

    || startswith (name, ".gnu.linkonce.wi.")

    || startswith (name, GNU_BUILD_ATTRS_SECTION_NAME)

    || startswith (name, ".note.gnu"))

  flags |= SEC_ELF_OCTETS;

    }

  if (old_sec == NULL)

    {

      symbolS *secsym;

      if (type == SHT_NULL)

  type = bfd_elf_get_default_section_type (flags);

      elf_section_type (sec) = type;

      elf_section_flags (sec) = attr;

      elf_section_data (sec)->this_hdr.sh_info = match_p->sh_info;

      /* Prevent SEC_HAS_CONTENTS from being inadvertently set.  */

      if (type == SHT_NOBITS)

  seg_info (sec)->bss = 1;

      /* Set the section ID and flags.  */

      sec->section_id = match_p->section_id;

      flags |= match_p->flags;

      /* Set the linked-to symbol name.  */

      sec->map_head.linked_to_symbol_name

  = match_p->linked_to_symbol_name;

      bfd_set_section_flags (sec, flags);

      if (flags & (SEC_MERGE | SEC_STRINGS))

  sec->entsize = entsize;

      elf_group_name (sec) = match_p->group_name;

      /* Add a symbol for this section to the symbol table.  */

      secsym = symbol_find (name);

      if (secsym != NULL)

  {

    /* We could be repurposing an undefined symbol here: make sure we

       reset sy_value to look like other section symbols in order to avoid

       trying to incorrectly resolve this section symbol later on.  */

    static const expressionS exp = { .X_op = O_constant };

    symbol_set_value_expression (secsym, &exp);

    symbol_set_bfdsym (secsym, sec->symbol);

  }

      else

  symbol_table_insert (section_symbol (sec));

    }

  else

    {

      if (type != SHT_NULL

    && (unsigned) type != elf_section_type (old_sec))

  {

    if (ssect != NULL)

      /* This is a special section with known type.  User

         assembly might get the section type wrong; Even high

         profile projects like glibc have done so in the past.

         So don't error in this case.  */

      as_warn (_("ignoring changed section type for %s"), name);

    else

      /* Do error when assembly isn't self-consistent.  */

      as_bad (_("changed section type for %s"), name);

  }

      if (attr != 0)

  {

    /* If section attributes are specified the second time we see a

       particular section, then check that they are the same as we

       saw the first time.  */

    if (((old_sec->flags ^ flags)

         & (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_CODE

      | SEC_EXCLUDE | SEC_SORT_ENTRIES | SEC_MERGE | SEC_STRINGS

      | SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD

      | SEC_THREAD_LOCAL)))

      {

        if (ssect != NULL)

    as_warn (_("ignoring changed section attributes for %s"), name);

        else

    as_bad (_("changed section attributes for %s"), name);

      }

    else

      /* FIXME: Maybe we should consider removing a previously set

         processor or application specific attribute as suspicious?  */

      elf_section_flags (sec) = attr;

    if ((flags & (SEC_MERGE | SEC_STRINGS))

        && old_sec->entsize != (unsigned) entsize)

      as_bad (_("changed section entity size for %s"), name);

  }

    }

#ifdef md_elf_section_change_hook

  md_elf_section_change_hook ();

#endif

}

void

obj_elf_change_section (const char *name,

      unsigned int type,

      bfd_vma attr,

      int entsize,

      struct elf_section_match *match_p,

      bool linkonce)

{

  change_section (name, type, attr, entsize, match_p, linkonce, false, 0);

}

static bfd_vma

obj_elf_parse_section_letters (char *str, size_t len,

             bool *is_clone, int *inherit, bfd_vma *gnu_attr)

{

  bfd_vma attr = 0;

  *is_clone = false;

  *inherit = 0;

  while (len > 0)

    {

      switch (*str)

  {

  case 'a':

    attr |= SHF_ALLOC;

    /* Compatibility.  */

    if (len > 1 && str[1] == 'm')

      {

        attr |= SHF_MERGE;

        str++, len--;

        if (len > 1 && str[1] == 's')

    {

      attr |= SHF_STRINGS;

      str++, len--;

    }

      }

    break;

  case 'e':

    attr |= SHF_EXCLUDE;

    break;

  case 'o':

    attr |= SHF_LINK_ORDER;

    break;

  case 'w':

    attr |= SHF_WRITE;

    break;

  case 'x':

    attr |= SHF_EXECINSTR;

    break;

  case 'M':

    attr |= SHF_MERGE;

    break;

  case 'S':

    attr |= SHF_STRINGS;

    break;

  case 'G':

    attr |= SHF_GROUP;

    break;

  case 'T':

    attr |= SHF_TLS;

    break;

  case 'd':

    *gnu_attr |= SHF_GNU_MBIND;

    break;

  case 'R':

    *gnu_attr |= SHF_GNU_RETAIN;

    break;

  case '?':

    *is_clone = true;

    break;

  default:

    {

      const char *bad_msg = _("unrecognized .section attribute:"

            " want a,e,o,w,x,M,S,G,T or number");

#ifdef md_elf_section_letter

      bfd_vma md_attr = md_elf_section_letter (*str, &bad_msg);

      if (md_attr != (bfd_vma) -1)

        attr |= md_attr;

      else

#endif

        if (ISDIGIT (*str))

    {

      char * end;

      struct elf_backend_data *bed;

      bfd_vma numeric_flags = strtoul (str, &end, 0);

      attr |= numeric_flags;

      bed = (struct elf_backend_data *)

        get_elf_backend_data (stdoutput);

      if (bed->elf_osabi == ELFOSABI_NONE

          || bed->elf_osabi == ELFOSABI_STANDALONE

          || bed->elf_osabi == ELFOSABI_GNU

          || bed->elf_osabi == ELFOSABI_FREEBSD)

        {

          /* Add flags in the SHF_MASKOS range to gnu_attr for

       OSABIs that support those flags.

       Also adding the flags for ELFOSABI_{NONE,STANDALONE}

       allows them to be validated later in obj_elf_section.

       We can't just always set these bits in gnu_attr for

       all OSABIs, since Binutils does not recognize all

       SHF_MASKOS bits for non-GNU OSABIs.  It's therefore

       possible that numeric flags are being used to set bits

       in the SHF_MASKOS range for those targets, and we

       don't want assembly to fail in those situations.  */

          *gnu_attr |= (numeric_flags & SHF_MASKOS);

        }

      /* Update str and len, allowing for the fact that

         we will execute str++ and len-- below.  */

      end --;

      len -= (end - str);

      str = end;

    }

        else if (!attr && !*gnu_attr && (*str == '+' || *str == '-'))

    *inherit = *str == '+' ? 1 : -1;

        else

    as_fatal ("%s", bad_msg);

    }

    break;