Merge GDB 7.5.1

bfd/section.c

 /* Object file "section" support for the BFD library.
    Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
-   2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
+   2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011,
+   2012
    Free Software Foundation, Inc.
    Written by Cygnus Support.
 
    This file is part of BFD, the Binary File Descriptor library.
 
    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 3 of the License, or
    (at your option) any later version.
 
@@ skipping 361 matching lines @@
 .#define COMPRESS_SECTION_DONE    1
 .#define DECOMPRESS_SECTION_SIZED 2
 .
 .  {* The following flags are used by the ELF linker. *}
 .
 .  {* Mark sections which have been allocated to segments.  *}
 .  unsigned int segment_mark : 1;
 .
 .  {* Type of sec_info information.  *}
 .  unsigned int sec_info_type:3;
-.#define ELF_INFO_TYPE_NONE      0
-.#define ELF_INFO_TYPE_STABS     1
-.#define ELF_INFO_TYPE_MERGE     2
-.#define ELF_INFO_TYPE_EH_FRAME  3
-.#define ELF_INFO_TYPE_JUST_SYMS 4
+.#define SEC_INFO_TYPE_NONE      0
+.#define SEC_INFO_TYPE_STABS     1
+.#define SEC_INFO_TYPE_MERGE     2
+.#define SEC_INFO_TYPE_EH_FRAME  3
+.#define SEC_INFO_TYPE_JUST_SYMS 4
 .
 .  {* Nonzero if this section uses RELA relocations, rather than REL.  *}
 .  unsigned int use_rela_p:1;
 .
 .  {* Bits used by various backends.  The generic code doesn't touch
 .     these fields.  *}
 .
 .  unsigned int sec_flg0:1;
 .  unsigned int sec_flg1:1;
 .  unsigned int sec_flg2:1;
@@ skipping 109 matching lines @@
 .
 .  void *used_by_bfd;
 .
 .  {* If this is a constructor section then here is a list of the
 .     relocations created to relocate items within it.  *}
 .  struct relent_chain *constructor_chain;
 .
 .  {* The BFD which owns the section.  *}
 .  bfd *owner;
 .
-.  {* INPUT_SECTION_FLAGS if specified in the linker script.  *}
-.  struct flag_info *section_flag_info;
-.
 .  {* A symbol which points at this section only.  *}
 .  struct bfd_symbol *symbol;
 .  struct bfd_symbol **symbol_ptr_ptr;
 .
 .  {* Early in the link process, map_head and map_tail are used to build
 .     a list of input sections attached to an output section.  Later,
 .     output sections use these fields for a list of bfd_link_order
 .     structs.  *}
 .  union {
 .    struct bfd_link_order *link_order;
 .    struct bfd_section *s;
 .  } map_head, map_tail;
 .} asection;
 .
 .{* Relax table contains information about instructions which can
 .   be removed by relaxation -- replacing a long address with a 
 .   short address.  *}
 .struct relax_table {
 .  {* Address where bytes may be deleted. *}
 .  bfd_vma addr;
 .  
 .  {* Number of bytes to be deleted.  *}
 .  int size;
 .};
 .
 .{* These sections are global, and are managed by BFD.  The application
 .   and target back end are not permitted to change the values in
-.   these sections.  New code should use the section_ptr macros rather
-.   than referring directly to the const sections.  The const sections
-.   may eventually vanish.  *}
+.   these sections.  *}
+.extern asection std_section[4];
+.
 .#define BFD_ABS_SECTION_NAME "*ABS*"
 .#define BFD_UND_SECTION_NAME "*UND*"
 .#define BFD_COM_SECTION_NAME "*COM*"
 .#define BFD_IND_SECTION_NAME "*IND*"
 .
-.{* The absolute section.  *}
-.extern asection bfd_abs_section;
-.#define bfd_abs_section_ptr ((asection *) &bfd_abs_section)
+.{* Pointer to the common section.  *}
+.#define bfd_com_section_ptr (&std_section[0])
+.{* Pointer to the undefined section.  *}
+.#define bfd_und_section_ptr (&std_section[1])
+.{* Pointer to the absolute section.  *}
+.#define bfd_abs_section_ptr (&std_section[2])
+.{* Pointer to the indirect section.  *}
+.#define bfd_ind_section_ptr (&std_section[3])
+.
+.#define bfd_is_und_section(sec) ((sec) == bfd_und_section_ptr)
 .#define bfd_is_abs_section(sec) ((sec) == bfd_abs_section_ptr)
-.{* Pointer to the undefined section.  *}
-.extern asection bfd_und_section;
-.#define bfd_und_section_ptr ((asection *) &bfd_und_section)
-.#define bfd_is_und_section(sec) ((sec) == bfd_und_section_ptr)
-.{* Pointer to the common section.  *}
-.extern asection bfd_com_section;
-.#define bfd_com_section_ptr ((asection *) &bfd_com_section)
-.{* Pointer to the indirect section.  *}
-.extern asection bfd_ind_section;
-.#define bfd_ind_section_ptr ((asection *) &bfd_ind_section)
 .#define bfd_is_ind_section(sec) ((sec) == bfd_ind_section_ptr)
 .
 .#define bfd_is_const_section(SEC)              \
 . (   ((SEC) == bfd_abs_section_ptr)            \
 .  || ((SEC) == bfd_und_section_ptr)            \
 .  || ((SEC) == bfd_com_section_ptr)            \
 .  || ((SEC) == bfd_ind_section_ptr))
 .
 .{* Macros to handle insertion and deletion of a bfd's sections.  These
 .   only handle the list pointers, ie. do not adjust section_count,
@@ skipping 94 matching lines @@
 .                                                                       \
 .  {* segment_mark, sec_info_type, use_rela_p,                      *}  \
 .     0,            0,             0,                                   \
 .                                                                       \
 .  {* sec_flg0, sec_flg1, sec_flg2, sec_flg3, sec_flg4, sec_flg5,   *}  \
 .     0,        0,        0,        0,        0,        0,              \
 .                                                                       \
 .  {* vma, lma, size, rawsize, compressed_size, relax, relax_count, *}  \
 .     0,   0,   0,    0,       0,               0,     0,               \
 .                                                                       \
-.  {* output_offset, output_section,              alignment_power,  *}  \
-.     0,             (struct bfd_section *) &SEC, 0,                    \
+.  {* output_offset, output_section, alignment_power,               *}  \
+.     0,             &SEC,           0,                                 \
 .                                                                       \
 .  {* relocation, orelocation, reloc_count, filepos, rel_filepos,   *}  \
 .     NULL,       NULL,        0,           0,       0,                 \
 .                                                                       \
 .  {* line_filepos, userdata, contents, lineno, lineno_count,       *}  \
 .     0,            NULL,     NULL,     NULL,   0,                      \
 .                                                                       \
 .  {* entsize, kept_section, moving_line_filepos,                    *} \
 .     0,       NULL,          0,                                        \
 .                                                                       \
 .  {* target_index, used_by_bfd, constructor_chain, owner,          *}  \
 .     0,            NULL,        NULL,              NULL,               \
 .                                                                       \
-.  {* flag_info,                                                    *}  \
-.     NULL,                                                             \
-.                                                                       \
 .  {* symbol,                    symbol_ptr_ptr,                    *}  \
 .     (struct bfd_symbol *) SYM, &SEC.symbol,                           \
 .                                                                       \
 .  {* map_head, map_tail                                            *}  \
 .     { NULL }, { NULL }                                                \
 .    }
 .
 */
 
 /* We use a macro to initialize the static asymbol structures because
    traditional C does not permit us to initialize a union member while
    gcc warns if we don't initialize it.  */
  /* the_bfd, name, value, attr, section [, udata] */
 #ifdef __STDC__
 #define GLOBAL_SYM_INIT(NAME, SECTION) \
-  { 0, NAME, 0, BSF_SECTION_SYM, (asection *) SECTION, { 0 }}
+  { 0, NAME, 0, BSF_SECTION_SYM, SECTION, { 0 }}
 #else
 #define GLOBAL_SYM_INIT(NAME, SECTION) \
-  { 0, NAME, 0, BSF_SECTION_SYM, (asection *) SECTION }
+  { 0, NAME, 0, BSF_SECTION_SYM, SECTION }
 #endif
 
 /* These symbols are global, not specific to any BFD.  Therefore, anything
    that tries to change them is broken, and should be repaired.  */
 
 static const asymbol global_syms[] =
 {
-  GLOBAL_SYM_INIT (BFD_COM_SECTION_NAME, &bfd_com_section),
-  GLOBAL_SYM_INIT (BFD_UND_SECTION_NAME, &bfd_und_section),
-  GLOBAL_SYM_INIT (BFD_ABS_SECTION_NAME, &bfd_abs_section),
-  GLOBAL_SYM_INIT (BFD_IND_SECTION_NAME, &bfd_ind_section)
+  GLOBAL_SYM_INIT (BFD_COM_SECTION_NAME, bfd_com_section_ptr),
+  GLOBAL_SYM_INIT (BFD_UND_SECTION_NAME, bfd_und_section_ptr),
+  GLOBAL_SYM_INIT (BFD_ABS_SECTION_NAME, bfd_abs_section_ptr),
+  GLOBAL_SYM_INIT (BFD_IND_SECTION_NAME, bfd_ind_section_ptr)
 };
 
-#define STD_SECTION(SEC, FLAGS, NAME, IDX)                              \
-  asection SEC = BFD_FAKE_SECTION(SEC, FLAGS, &global_syms[IDX],        \
-                                  NAME, IDX)
+#define STD_SECTION(NAME, IDX, FLAGS) \
+  BFD_FAKE_SECTION(std_section[IDX], FLAGS, &global_syms[IDX], NAME, IDX)
 
-STD_SECTION (bfd_com_section, SEC_IS_COMMON, BFD_COM_SECTION_NAME, 0);
-STD_SECTION (bfd_und_section, 0, BFD_UND_SECTION_NAME, 1);
-STD_SECTION (bfd_abs_section, 0, BFD_ABS_SECTION_NAME, 2);
-STD_SECTION (bfd_ind_section, 0, BFD_IND_SECTION_NAME, 3);
+asection std_section[] = {
+  STD_SECTION (BFD_COM_SECTION_NAME, 0, SEC_IS_COMMON),
+  STD_SECTION (BFD_UND_SECTION_NAME, 1, 0),
+  STD_SECTION (BFD_ABS_SECTION_NAME, 2, 0),
+  STD_SECTION (BFD_IND_SECTION_NAME, 3, 0)
+};
 #undef STD_SECTION
 
 /* Initialize an entry in the section hash table.  */
 
 struct bfd_hash_entry *
 bfd_section_hash_newfunc (struct bfd_hash_entry *entry,
                           struct bfd_hash_table *table,
                           const char *string)
 {
   /* Allocate the structure if it has not already been allocated by a
@@ skipping 92 matching lines @@
 }
 
 /*
 FUNCTION
         bfd_get_section_by_name
 
 SYNOPSIS
         asection *bfd_get_section_by_name (bfd *abfd, const char *name);
 
 DESCRIPTION
-        Run through @var{abfd} and return the one of the
-        <<asection>>s whose name matches @var{name}, otherwise <<NULL>>.
-        @xref{Sections}, for more information.
-
-        This should only be used in special cases; the normal way to process
-        all sections of a given name is to use <<bfd_map_over_sections>> and
-        <<strcmp>> on the name (or better yet, base it on the section flags
-        or something else) for each section.
+        Return the most recently created section attached to @var{abfd}
+        named @var{name}.  Return NULL if no such section exists.
 */
 
 asection *
 bfd_get_section_by_name (bfd *abfd, const char *name)
 {
   struct section_hash_entry *sh;
 
   sh = section_hash_lookup (&abfd->section_htab, name, FALSE, FALSE);
   if (sh != NULL)
     return &sh->section;
 
   return NULL;
 }
 
 /*
 FUNCTION
+       bfd_get_next_section_by_name
+
+SYNOPSIS
+       asection *bfd_get_next_section_by_name (asection *sec);
+
+DESCRIPTION
+       Given @var{sec} is a section returned by @code{bfd_get_section_by_name},
+       return the next most recently created section attached to the same
+       BFD with the same name.  Return NULL if no such section exists.
+*/
+
+asection *
+bfd_get_next_section_by_name (asection *sec)
+{
+  struct section_hash_entry *sh;
+  const char *name;
+  unsigned long hash;
+
+  sh = ((struct section_hash_entry *)
+        ((char *) sec - offsetof (struct section_hash_entry, section)));
+
+  hash = sh->root.hash;
+  name = sec->name;
+  for (sh = (struct section_hash_entry *) sh->root.next;
+       sh != NULL;
+       sh = (struct section_hash_entry *) sh->root.next)
+    if (sh->root.hash == hash
+       && strcmp (sh->root.string, name) == 0)
+      return &sh->section;
+
+  return NULL;
+}
+
+/*
+FUNCTION
+        bfd_get_linker_section
+
+SYNOPSIS
+        asection *bfd_get_linker_section (bfd *abfd, const char *name);
+
+DESCRIPTION
+        Return the linker created section attached to @var{abfd}
+        named @var{name}.  Return NULL if no such section exists.
+*/
+
+asection *
+bfd_get_linker_section (bfd *abfd, const char *name)
+{
+  asection *sec = bfd_get_section_by_name (abfd, name);
+
+  while (sec != NULL && (sec->flags & SEC_LINKER_CREATED) == 0)
+    sec = bfd_get_next_section_by_name (sec);
+  return sec;
+}
+
+/*
+FUNCTION
         bfd_get_section_by_name_if
 
 SYNOPSIS
         asection *bfd_get_section_by_name_if
           (bfd *abfd,
            const char *name,
            bfd_boolean (*func) (bfd *abfd, asection *sect, void *obj),
            void *obj);
 
 DESCRIPTION
@@ skipping 690 matching lines @@
 DESCRIPTION
         Remove all members of @var{group} from the output.
 */
 
 bfd_boolean
 bfd_generic_discard_group (bfd *abfd ATTRIBUTE_UNUSED,
                            asection *group ATTRIBUTE_UNUSED)
 {
   return TRUE;
 }