bfd/section.c

   1 /* Object file "section" support for the BFD library.
   2    Copyright (C) 1990-2018 Free Software Foundation, Inc.
   3    Written by Cygnus Support.
   4
   5    This file is part of BFD, the Binary File Descriptor library.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
  20    MA 02110-1301, USA.  */
  21
  22 /*
  23 SECTION
  24         Sections
  25
  26         The raw data contained within a BFD is maintained through the
  27         section abstraction.  A single BFD may have any number of
  28         sections.  It keeps hold of them by pointing to the first;
  29         each one points to the next in the list.
  30
  31         Sections are supported in BFD in <<section.c>>.
  32
  33 @menu
  34 @* Section Input::
  35 @* Section Output::
  36 @* typedef asection::
  37 @* section prototypes::
  38 @end menu
  39
  40 INODE
  41 Section Input, Section Output, Sections, Sections
  42 SUBSECTION
  43         Section input
  44
  45         When a BFD is opened for reading, the section structures are
  46         created and attached to the BFD.
  47
  48         Each section has a name which describes the section in the
  49         outside world---for example, <<a.out>> would contain at least
  50         three sections, called <<.text>>, <<.data>> and <<.bss>>.
  51
  52         Names need not be unique; for example a COFF file may have several
  53         sections named <<.data>>.
  54
  55         Sometimes a BFD will contain more than the ``natural'' number of
  56         sections. A back end may attach other sections containing
  57         constructor data, or an application may add a section (using
  58         <<bfd_make_section>>) to the sections attached to an already open
  59         BFD. For example, the linker creates an extra section
  60         <<COMMON>> for each input file's BFD to hold information about
  61         common storage.
  62
  63         The raw data is not necessarily read in when
  64         the section descriptor is created. Some targets may leave the
  65         data in place until a <<bfd_get_section_contents>> call is
  66         made. Other back ends may read in all the data at once.  For
  67         example, an S-record file has to be read once to determine the
  68         size of the data.
  69
  70 INODE
  71 Section Output, typedef asection, Section Input, Sections
  72
  73 SUBSECTION
  74         Section output
  75
  76         To write a new object style BFD, the various sections to be
  77         written have to be created. They are attached to the BFD in
  78         the same way as input sections; data is written to the
  79         sections using <<bfd_set_section_contents>>.
  80
  81         Any program that creates or combines sections (e.g., the assembler
  82         and linker) must use the <<asection>> fields <<output_section>> and
  83         <<output_offset>> to indicate the file sections to which each
  84         section must be written.  (If the section is being created from
  85         scratch, <<output_section>> should probably point to the section
  86         itself and <<output_offset>> should probably be zero.)
  87
  88         The data to be written comes from input sections attached
  89         (via <<output_section>> pointers) to
  90         the output sections.  The output section structure can be
  91         considered a filter for the input section: the output section
  92         determines the vma of the output data and the name, but the
  93         input section determines the offset into the output section of
  94         the data to be written.
  95
  96         E.g., to create a section "O", starting at 0x100, 0x123 long,
  97         containing two subsections, "A" at offset 0x0 (i.e., at vma
  98         0x100) and "B" at offset 0x20 (i.e., at vma 0x120) the <<asection>>
  99         structures would look like:
 100
 101 |   section name          "A"
 102 |     output_offset   0x00
 103 |     size            0x20
 104 |     output_section ----------->  section name    "O"
 105 |                             |    vma             0x100
 106 |   section name          "B" |    size            0x123
 107 |     output_offset   0x20    |
 108 |     size            0x103   |
 109 |     output_section  --------|
 110
 111 SUBSECTION
 112         Link orders
 113
 114         The data within a section is stored in a @dfn{link_order}.
 115         These are much like the fixups in <<gas>>.  The link_order
 116         abstraction allows a section to grow and shrink within itself.
 117
 118         A link_order knows how big it is, and which is the next
 119         link_order and where the raw data for it is; it also points to
 120         a list of relocations which apply to it.
 121
 122         The link_order is used by the linker to perform relaxing on
 123         final code.  The compiler creates code which is as big as
 124         necessary to make it work without relaxing, and the user can
 125         select whether to relax.  Sometimes relaxing takes a lot of
 126         time.  The linker runs around the relocations to see if any
 127         are attached to data which can be shrunk, if so it does it on
 128         a link_order by link_order basis.
 129
 130 */
 131
 132 #include "sysdep.h"
 133 #include "bfd.h"
 134 #include "libbfd.h"
 135 #include "bfdlink.h"
 136
 137 /*
 138 DOCDD
 139 INODE
 140 typedef asection, section prototypes, Section Output, Sections
 141 SUBSECTION
 142         typedef asection
 143
 144         Here is the section structure:
 145
 146 CODE_FRAGMENT
 147 .
 148 .typedef struct bfd_section
 149 .{
 150 .  {* The name of the section; the name isn't a copy, the pointer is
 151 .     the same as that passed to bfd_make_section.  *}
 152 .  const char *name;
 153 .
 154 .  {* A unique sequence number.  *}
 155 .  unsigned int id;
 156 .
 157 .  {* Which section in the bfd; 0..n-1 as sections are created in a bfd.  *}
 158 .  unsigned int index;
 159 .
 160 .  {* The next section in the list belonging to the BFD, or NULL.  *}
 161 .  struct bfd_section *next;
 162 .
 163 .  {* The previous section in the list belonging to the BFD, or NULL.  *}
 164 .  struct bfd_section *prev;
 165 .
 166 .  {* The field flags contains attributes of the section. Some
 167 .     flags are read in from the object file, and some are
 168 .     synthesized from other information.  *}
 169 .  flagword flags;
 170 .
 171 .#define SEC_NO_FLAGS                      0x0
 172 .
 173 .  {* Tells the OS to allocate space for this section when loading.
 174 .     This is clear for a section containing debug information only.  *}
 175 .#define SEC_ALLOC                         0x1
 176 .
 177 .  {* Tells the OS to load the section from the file when loading.
 178 .     This is clear for a .bss section.  *}
 179 .#define SEC_LOAD                          0x2
 180 .
 181 .  {* The section contains data still to be relocated, so there is
 182 .     some relocation information too.  *}
 183 .#define SEC_RELOC                         0x4
 184 .
 185 .  {* A signal to the OS that the section contains read only data.  *}
 186 .#define SEC_READONLY                      0x8
 187 .
 188 .  {* The section contains code only.  *}
 189 .#define SEC_CODE                         0x10
 190 .
 191 .  {* The section contains data only.  *}
 192 .#define SEC_DATA                         0x20
 193 .
 194 .  {* The section will reside in ROM.  *}
 195 .#define SEC_ROM                          0x40
 196 .
 197 .  {* The section contains constructor information. This section
 198 .     type is used by the linker to create lists of constructors and
 199 .     destructors used by <<g++>>. When a back end sees a symbol
 200 .     which should be used in a constructor list, it creates a new
 201 .     section for the type of name (e.g., <<__CTOR_LIST__>>), attaches
 202 .     the symbol to it, and builds a relocation. To build the lists
 203 .     of constructors, all the linker has to do is catenate all the
 204 .     sections called <<__CTOR_LIST__>> and relocate the data
 205 .     contained within - exactly the operations it would peform on
 206 .     standard data.  *}
 207 .#define SEC_CONSTRUCTOR                  0x80
 208 .
 209 .  {* The section has contents - a data section could be
 210 .     <<SEC_ALLOC>> | <<SEC_HAS_CONTENTS>>; a debug section could be
 211 .     <<SEC_HAS_CONTENTS>>  *}
 212 .#define SEC_HAS_CONTENTS                0x100
 213 .
 214 .  {* An instruction to the linker to not output the section
 215 .     even if it has information which would normally be written.  *}
 216 .#define SEC_NEVER_LOAD                  0x200
 217 .
 218 .  {* The section contains thread local data.  *}
 219 .#define SEC_THREAD_LOCAL                0x400
 220 .
 221 .  {* The section's size is fixed.  Generic linker code will not
 222 .     recalculate it and it is up to whoever has set this flag to
 223 .     get the size right.  *}
 224 .#define SEC_FIXED_SIZE                  0x800
 225 .
 226 .  {* The section contains common symbols (symbols may be defined
 227 .     multiple times, the value of a symbol is the amount of
 228 .     space it requires, and the largest symbol value is the one
 229 .     used).  Most targets have exactly one of these (which we
 230 .     translate to bfd_com_section_ptr), but ECOFF has two.  *}
 231 .#define SEC_IS_COMMON                  0x1000
 232 .
 233 .  {* The section contains only debugging information.  For
 234 .     example, this is set for ELF .debug and .stab sections.
 235 .     strip tests this flag to see if a section can be
 236 .     discarded.  *}
 237 .#define SEC_DEBUGGING                  0x2000
 238 .
 239 .  {* The contents of this section are held in memory pointed to
 240 .     by the contents field.  This is checked by bfd_get_section_contents,
 241 .     and the data is retrieved from memory if appropriate.  *}
 242 .#define SEC_IN_MEMORY                  0x4000
 243 .
 244 .  {* The contents of this section are to be excluded by the
 245 .     linker for executable and shared objects unless those
 246 .     objects are to be further relocated.  *}
 247 .#define SEC_EXCLUDE                    0x8000
 248 .
 249 .  {* The contents of this section are to be sorted based on the sum of
 250 .     the symbol and addend values specified by the associated relocation
 251 .     entries.  Entries without associated relocation entries will be
 252 .     appended to the end of the section in an unspecified order.  *}
 253 .#define SEC_SORT_ENTRIES              0x10000
 254 .
 255 .  {* When linking, duplicate sections of the same name should be
 256 .     discarded, rather than being combined into a single section as
 257 .     is usually done.  This is similar to how common symbols are
 258 .     handled.  See SEC_LINK_DUPLICATES below.  *}
 259 .#define SEC_LINK_ONCE                 0x20000
 260 .
 261 .  {* If SEC_LINK_ONCE is set, this bitfield describes how the linker
 262 .     should handle duplicate sections.  *}
 263 .#define SEC_LINK_DUPLICATES           0xc0000
 264 .
 265 .  {* This value for SEC_LINK_DUPLICATES means that duplicate
 266 .     sections with the same name should simply be discarded.  *}
 267 .#define SEC_LINK_DUPLICATES_DISCARD       0x0
 268 .
 269 .  {* This value for SEC_LINK_DUPLICATES means that the linker
 270 .     should warn if there are any duplicate sections, although
 271 .     it should still only link one copy.  *}
 272 .#define SEC_LINK_DUPLICATES_ONE_ONLY  0x40000
 273 .
 274 .  {* This value for SEC_LINK_DUPLICATES means that the linker
 275 .     should warn if any duplicate sections are a different size.  *}
 276 .#define SEC_LINK_DUPLICATES_SAME_SIZE 0x80000
 277 .
 278 .  {* This value for SEC_LINK_DUPLICATES means that the linker
 279 .     should warn if any duplicate sections contain different
 280 .     contents.  *}
 281 .#define SEC_LINK_DUPLICATES_SAME_CONTENTS \
 282 .  (SEC_LINK_DUPLICATES_ONE_ONLY | SEC_LINK_DUPLICATES_SAME_SIZE)
 283 .
 284 .  {* This section was created by the linker as part of dynamic
 285 .     relocation or other arcane processing.  It is skipped when
 286 .     going through the first-pass output, trusting that someone
 287 .     else up the line will take care of it later.  *}
 288 .#define SEC_LINKER_CREATED           0x100000
 289 .
 290 .  {* This section should not be subject to garbage collection.
 291 .     Also set to inform the linker that this section should not be
 292 .     listed in the link map as discarded.  *}
 293 .#define SEC_KEEP                     0x200000
 294 .
 295 .  {* This section contains "short" data, and should be placed
 296 .     "near" the GP.  *}
 297 .#define SEC_SMALL_DATA               0x400000
 298 .
 299 .  {* Attempt to merge identical entities in the section.
 300 .     Entity size is given in the entsize field.  *}
 301 .#define SEC_MERGE                    0x800000
 302 .
 303 .  {* If given with SEC_MERGE, entities to merge are zero terminated
 304 .     strings where entsize specifies character size instead of fixed
 305 .     size entries.  *}
 306 .#define SEC_STRINGS                 0x1000000
 307 .
 308 .  {* This section contains data about section groups.  *}
 309 .#define SEC_GROUP                   0x2000000
 310 .
 311 .  {* The section is a COFF shared library section.  This flag is
 312 .     only for the linker.  If this type of section appears in
 313 .     the input file, the linker must copy it to the output file
 314 .     without changing the vma or size.  FIXME: Although this
 315 .     was originally intended to be general, it really is COFF
 316 .     specific (and the flag was renamed to indicate this).  It
 317 .     might be cleaner to have some more general mechanism to
 318 .     allow the back end to control what the linker does with
 319 .     sections.  *}
 320 .#define SEC_COFF_SHARED_LIBRARY     0x4000000
 321 .
 322 .  {* This input section should be copied to output in reverse order
 323 .     as an array of pointers.  This is for ELF linker internal use
 324 .     only.  *}
 325 .#define SEC_ELF_REVERSE_COPY        0x4000000
 326 .
 327 .  {* This section contains data which may be shared with other
 328 .     executables or shared objects. This is for COFF only.  *}
 329 .#define SEC_COFF_SHARED             0x8000000
 330 .
 331 .  {* This section should be compressed.  This is for ELF linker
 332 .     internal use only.  *}
 333 .#define SEC_ELF_COMPRESS            0x8000000
 334 .
 335 .  {* When a section with this flag is being linked, then if the size of
 336 .     the input section is less than a page, it should not cross a page
 337 .     boundary.  If the size of the input section is one page or more,
 338 .     it should be aligned on a page boundary.  This is for TI
 339 .     TMS320C54X only.  *}
 340 .#define SEC_TIC54X_BLOCK           0x10000000
 341 .
 342 .  {* This section should be renamed.  This is for ELF linker
 343 .     internal use only.  *}
 344 .#define SEC_ELF_RENAME             0x10000000
 345 .
 346 .  {* Conditionally link this section; do not link if there are no
 347 .     references found to any symbol in the section.  This is for TI
 348 .     TMS320C54X only.  *}
 349 .#define SEC_TIC54X_CLINK           0x20000000
 350 .
 351 .  {* This section contains vliw code.  This is for Toshiba MeP only.  *}
 352 .#define SEC_MEP_VLIW               0x20000000
 353 .
 354 .  {* Indicate that section has the no read flag set. This happens
 355 .     when memory read flag isn't set. *}
 356 .#define SEC_COFF_NOREAD            0x40000000
 357 .
 358 .  {* Indicate that section has the purecode flag set.  *}
 359 .#define SEC_ELF_PURECODE           0x80000000
 360 .
 361 .  {*  End of section flags.  *}
 362 .
 363 .  {* Some internal packed boolean fields.  *}
 364 .
 365 .  {* See the vma field.  *}
 366 .  unsigned int user_set_vma : 1;
 367 .
 368 .  {* A mark flag used by some of the linker backends.  *}
 369 .  unsigned int linker_mark : 1;
 370 .
 371 .  {* Another mark flag used by some of the linker backends.  Set for
 372 .     output sections that have an input section.  *}
 373 .  unsigned int linker_has_input : 1;
 374 .
 375 .  {* Mark flag used by some linker backends for garbage collection.  *}
 376 .  unsigned int gc_mark : 1;
 377 .
 378 .  {* Section compression status.  *}
 379 .  unsigned int compress_status : 2;
 380 .#define COMPRESS_SECTION_NONE    0
 381 .#define COMPRESS_SECTION_DONE    1
 382 .#define DECOMPRESS_SECTION_SIZED 2
 383 .
 384 .  {* The following flags are used by the ELF linker. *}
 385 .
 386 .  {* Mark sections which have been allocated to segments.  *}
 387 .  unsigned int segment_mark : 1;
 388 .
 389 .  {* Type of sec_info information.  *}
 390 .  unsigned int sec_info_type:3;
 391 .#define SEC_INFO_TYPE_NONE      0
 392 .#define SEC_INFO_TYPE_STABS     1
 393 .#define SEC_INFO_TYPE_MERGE     2
 394 .#define SEC_INFO_TYPE_EH_FRAME  3
 395 .#define SEC_INFO_TYPE_JUST_SYMS 4
 396 .#define SEC_INFO_TYPE_TARGET    5
 397 .#define SEC_INFO_TYPE_EH_FRAME_ENTRY 6
 398 .
 399 .  {* Nonzero if this section uses RELA relocations, rather than REL.  *}
 400 .  unsigned int use_rela_p:1;
 401 .
 402 .  {* Bits used by various backends.  The generic code doesn't touch
 403 .     these fields.  *}
 404 .
 405 .  unsigned int sec_flg0:1;
 406 .  unsigned int sec_flg1:1;
 407 .  unsigned int sec_flg2:1;
 408 .  unsigned int sec_flg3:1;
 409 .  unsigned int sec_flg4:1;
 410 .  unsigned int sec_flg5:1;
 411 .
 412 .  {* End of internal packed boolean fields.  *}
 413 .
 414 .  {*  The virtual memory address of the section - where it will be
 415 .      at run time.  The symbols are relocated against this.  The
 416 .      user_set_vma flag is maintained by bfd; if it's not set, the
 417 .      backend can assign addresses (for example, in <<a.out>>, where
 418 .      the default address for <<.data>> is dependent on the specific
 419 .      target and various flags).  *}
 420 .  bfd_vma vma;
 421 .
 422 .  {*  The load address of the section - where it would be in a
 423 .      rom image; really only used for writing section header
 424 .      information.  *}
 425 .  bfd_vma lma;
 426 .
 427 .  {* The size of the section in *octets*, as it will be output.
 428 .     Contains a value even if the section has no contents (e.g., the
 429 .     size of <<.bss>>).  *}
 430 .  bfd_size_type size;
 431 .
 432 .  {* For input sections, the original size on disk of the section, in
 433 .     octets.  This field should be set for any section whose size is
 434 .     changed by linker relaxation.  It is required for sections where
 435 .     the linker relaxation scheme doesn't cache altered section and
 436 .     reloc contents (stabs, eh_frame, SEC_MERGE, some coff relaxing
 437 .     targets), and thus the original size needs to be kept to read the
 438 .     section multiple times.  For output sections, rawsize holds the
 439 .     section size calculated on a previous linker relaxation pass.  *}
 440 .  bfd_size_type rawsize;
 441 .
 442 .  {* The compressed size of the section in octets.  *}
 443 .  bfd_size_type compressed_size;
 444 .
 445 .  {* Relaxation table. *}
 446 .  struct relax_table *relax;
 447 .
 448 .  {* Count of used relaxation table entries. *}
 449 .  int relax_count;
 450 .
 451 .
 452 .  {* If this section is going to be output, then this value is the
 453 .     offset in *bytes* into the output section of the first byte in the
 454 .     input section (byte ==> smallest addressable unit on the
 455 .     target).  In most cases, if this was going to start at the
 456 .     100th octet (8-bit quantity) in the output section, this value
 457 .     would be 100.  However, if the target byte size is 16 bits
 458 .     (bfd_octets_per_byte is "2"), this value would be 50.  *}
 459 .  bfd_vma output_offset;
 460 .
 461 .  {* The output section through which to map on output.  *}
 462 .  struct bfd_section *output_section;
 463 .
 464 .  {* The alignment requirement of the section, as an exponent of 2 -
 465 .     e.g., 3 aligns to 2^3 (or 8).  *}
 466 .  unsigned int alignment_power;
 467 .
 468 .  {* If an input section, a pointer to a vector of relocation
 469 .     records for the data in this section.  *}
 470 .  struct reloc_cache_entry *relocation;
 471 .
 472 .  {* If an output section, a pointer to a vector of pointers to
 473 .     relocation records for the data in this section.  *}
 474 .  struct reloc_cache_entry **orelocation;
 475 .
 476 .  {* The number of relocation records in one of the above.  *}
 477 .  unsigned reloc_count;
 478 .
 479 .  {* Information below is back end specific - and not always used
 480 .     or updated.  *}
 481 .
 482 .  {* File position of section data.  *}
 483 .  file_ptr filepos;
 484 .
 485 .  {* File position of relocation info.  *}
 486 .  file_ptr rel_filepos;
 487 .
 488 .  {* File position of line data.  *}
 489 .  file_ptr line_filepos;
 490 .
 491 .  {* Pointer to data for applications.  *}
 492 .  void *userdata;
 493 .
 494 .  {* If the SEC_IN_MEMORY flag is set, this points to the actual
 495 .     contents.  *}
 496 .  unsigned char *contents;
 497 .
 498 .  {* Attached line number information.  *}
 499 .  alent *lineno;
 500 .
 501 .  {* Number of line number records.  *}
 502 .  unsigned int lineno_count;
 503 .
 504 .  {* Entity size for merging purposes.  *}
 505 .  unsigned int entsize;
 506 .
 507 .  {* Points to the kept section if this section is a link-once section,
 508 .     and is discarded.  *}
 509 .  struct bfd_section *kept_section;
 510 .
 511 .  {* When a section is being output, this value changes as more
 512 .     linenumbers are written out.  *}
 513 .  file_ptr moving_line_filepos;
 514 .
 515 .  {* What the section number is in the target world.  *}
 516 .  int target_index;
 517 .
 518 .  void *used_by_bfd;
 519 .
 520 .  {* If this is a constructor section then here is a list of the
 521 .     relocations created to relocate items within it.  *}
 522 .  struct relent_chain *constructor_chain;
 523 .
 524 .  {* The BFD which owns the section.  *}
 525 .  bfd *owner;
 526 .
 527 .  {* A symbol which points at this section only.  *}
 528 .  struct bfd_symbol *symbol;
 529 .  struct bfd_symbol **symbol_ptr_ptr;
 530 .
 531 .  {* Early in the link process, map_head and map_tail are used to build
 532 .     a list of input sections attached to an output section.  Later,
 533 .     output sections use these fields for a list of bfd_link_order
 534 .     structs.  *}
 535 .  union {
 536 .    struct bfd_link_order *link_order;
 537 .    struct bfd_section *s;
 538 .  } map_head, map_tail;
 539 .} asection;
 540 .
 541 .{* Relax table contains information about instructions which can
 542 .   be removed by relaxation -- replacing a long address with a
 543 .   short address.  *}
 544 .struct relax_table {
 545 .  {* Address where bytes may be deleted. *}
 546 .  bfd_vma addr;
 547 .
 548 .  {* Number of bytes to be deleted.  *}
 549 .  int size;
 550 .};
 551 .
 552 .{* Note: the following are provided as inline functions rather than macros
 553 .   because not all callers use the return value.  A macro implementation
 554 .   would use a comma expression, eg: "((ptr)->foo = val, TRUE)" and some
 555 .   compilers will complain about comma expressions that have no effect.  *}
 556 .static inline bfd_boolean
 557 .bfd_set_section_userdata (bfd * abfd ATTRIBUTE_UNUSED, asection * ptr,
 558 .                          void * val)
 559 .{
 560 .  ptr->userdata = val;
 561 .  return TRUE;
 562 .}
 563 .
 564 .static inline bfd_boolean
 565 .bfd_set_section_vma (bfd * abfd ATTRIBUTE_UNUSED, asection * ptr, bfd_vma val)
 566 .{
 567 .  ptr->vma = ptr->lma = val;
 568 .  ptr->user_set_vma = TRUE;
 569 .  return TRUE;
 570 .}
 571 .
 572 .static inline bfd_boolean
 573 .bfd_set_section_alignment (bfd * abfd ATTRIBUTE_UNUSED, asection * ptr,
 574 .                           unsigned int val)
 575 .{
 576 .  ptr->alignment_power = val;
 577 .  return TRUE;
 578 .}
 579 .
 580 .{* These sections are global, and are managed by BFD.  The application
 581 .   and target back end are not permitted to change the values in
 582 .   these sections.  *}
 583 .extern asection _bfd_std_section[4];
 584 .
 585 .#define BFD_ABS_SECTION_NAME "*ABS*"
 586 .#define BFD_UND_SECTION_NAME "*UND*"
 587 .#define BFD_COM_SECTION_NAME "*COM*"
 588 .#define BFD_IND_SECTION_NAME "*IND*"
 589 .
 590 .{* Pointer to the common section.  *}
 591 .#define bfd_com_section_ptr (&_bfd_std_section[0])
 592 .{* Pointer to the undefined section.  *}
 593 .#define bfd_und_section_ptr (&_bfd_std_section[1])
 594 .{* Pointer to the absolute section.  *}
 595 .#define bfd_abs_section_ptr (&_bfd_std_section[2])
 596 .{* Pointer to the indirect section.  *}
 597 .#define bfd_ind_section_ptr (&_bfd_std_section[3])
 598 .
 599 .#define bfd_is_und_section(sec) ((sec) == bfd_und_section_ptr)
 600 .#define bfd_is_abs_section(sec) ((sec) == bfd_abs_section_ptr)
 601 .#define bfd_is_ind_section(sec) ((sec) == bfd_ind_section_ptr)
 602 .
 603 .#define bfd_is_const_section(SEC)              \
 604 . (   ((SEC) == bfd_abs_section_ptr)            \
 605 .  || ((SEC) == bfd_und_section_ptr)            \
 606 .  || ((SEC) == bfd_com_section_ptr)            \
 607 .  || ((SEC) == bfd_ind_section_ptr))
 608 .
 609 .{* Macros to handle insertion and deletion of a bfd's sections.  These
 610 .   only handle the list pointers, ie. do not adjust section_count,
 611 .   target_index etc.  *}
 612 .#define bfd_section_list_remove(ABFD, S) \
 613 .  do                                                   \
 614 .    {                                                  \
 615 .      asection *_s = S;                                \
 616 .      asection *_next = _s->next;                      \
 617 .      asection *_prev = _s->prev;                      \
 618 .      if (_prev)                                       \
 619 .        _prev->next = _next;                           \
 620 .      else                                             \
 621 .        (ABFD)->sections = _next;                      \
 622 .      if (_next)                                       \
 623 .        _next->prev = _prev;                           \
 624 .      else                                             \
 625 .        (ABFD)->section_last = _prev;                  \
 626 .    }                                                  \
 627 .  while (0)
 628 .#define bfd_section_list_append(ABFD, S) \
 629 .  do                                                   \
 630 .    {                                                  \
 631 .      asection *_s = S;                                \
 632 .      bfd *_abfd = ABFD;                               \
 633 .      _s->next = NULL;                                 \
 634 .      if (_abfd->section_last)                         \
 635 .        {                                              \
 636 .          _s->prev = _abfd->section_last;              \
 637 .          _abfd->section_last->next = _s;              \
 638 .        }                                              \
 639 .      else                                             \
 640 .        {                                              \
 641 .          _s->prev = NULL;                             \
 642 .          _abfd->sections = _s;                        \
 643 .        }                                              \
 644 .      _abfd->section_last = _s;                        \
 645 .    }                                                  \
 646 .  while (0)
 647 .#define bfd_section_list_prepend(ABFD, S) \
 648 .  do                                                   \
 649 .    {                                                  \
 650 .      asection *_s = S;                                \
 651 .      bfd *_abfd = ABFD;                               \
 652 .      _s->prev = NULL;                                 \
 653 .      if (_abfd->sections)                             \
 654 .        {                                              \
 655 .          _s->next = _abfd->sections;                  \
 656 .          _abfd->sections->prev = _s;                  \
 657 .        }                                              \
 658 .      else                                             \
 659 .        {                                              \
 660 .          _s->next = NULL;                             \
 661 .          _abfd->section_last = _s;                    \
 662 .        }                                              \
 663 .      _abfd->sections = _s;                            \
 664 .    }                                                  \
 665 .  while (0)
 666 .#define bfd_section_list_insert_after(ABFD, A, S) \
 667 .  do                                                   \
 668 .    {                                                  \
 669 .      asection *_a = A;                                \
 670 .      asection *_s = S;                                \
 671 .      asection *_next = _a->next;                      \
 672 .      _s->next = _next;                                \
 673 .      _s->prev = _a;                                   \
 674 .      _a->next = _s;                                   \
 675 .      if (_next)                                       \
 676 .        _next->prev = _s;                              \
 677 .      else                                             \
 678 .        (ABFD)->section_last = _s;                     \
 679 .    }                                                  \
 680 .  while (0)
 681 .#define bfd_section_list_insert_before(ABFD, B, S) \
 682 .  do                                                   \
 683 .    {                                                  \
 684 .      asection *_b = B;                                \
 685 .      asection *_s = S;                                \
 686 .      asection *_prev = _b->prev;                      \
 687 .      _s->prev = _prev;                                \
 688 .      _s->next = _b;                                   \
 689 .      _b->prev = _s;                                   \
 690 .      if (_prev)                                       \
 691 .        _prev->next = _s;                              \
 692 .      else                                             \
 693 .        (ABFD)->sections = _s;                         \
 694 .    }                                                  \
 695 .  while (0)
 696 .#define bfd_section_removed_from_list(ABFD, S) \
 697 .  ((S)->next == NULL ? (ABFD)->section_last != (S) : (S)->next->prev != (S))
 698 .
 699 .#define BFD_FAKE_SECTION(SEC, SYM, NAME, IDX, FLAGS)                   \
 700 .  {* name, id,  index, next, prev, flags, user_set_vma,            *}  \
 701 .  {  NAME, IDX, 0,     NULL, NULL, FLAGS, 0,                           \
 702 .                                                                       \
 703 .  {* linker_mark, linker_has_input, gc_mark, decompress_status,    *}  \
 704 .     0,           0,                1,       0,                        \
 705 .                                                                       \
 706 .  {* segment_mark, sec_info_type, use_rela_p,                      *}  \
 707 .     0,            0,             0,                                   \
 708 .                                                                       \
 709 .  {* sec_flg0, sec_flg1, sec_flg2, sec_flg3, sec_flg4, sec_flg5,   *}  \
 710 .     0,        0,        0,        0,        0,        0,              \
 711 .                                                                       \
 712 .  {* vma, lma, size, rawsize, compressed_size, relax, relax_count, *}  \
 713 .     0,   0,   0,    0,       0,               0,     0,               \
 714 .                                                                       \
 715 .  {* output_offset, output_section, alignment_power,               *}  \
 716 .     0,             &SEC,           0,                                 \
 717 .                                                                       \
 718 .  {* relocation, orelocation, reloc_count, filepos, rel_filepos,   *}  \
 719 .     NULL,       NULL,        0,           0,       0,                 \
 720 .                                                                       \
 721 .  {* line_filepos, userdata, contents, lineno, lineno_count,       *}  \
 722 .     0,            NULL,     NULL,     NULL,   0,                      \
 723 .                                                                       \
 724 .  {* entsize, kept_section, moving_line_filepos,                    *} \
 725 .     0,       NULL,          0,                                        \
 726 .                                                                       \
 727 .  {* target_index, used_by_bfd, constructor_chain, owner,          *}  \
 728 .     0,            NULL,        NULL,              NULL,               \
 729 .                                                                       \
 730 .  {* symbol,                    symbol_ptr_ptr,                    *}  \
 731 .     (struct bfd_symbol *) SYM, &SEC.symbol,                           \
 732 .                                                                       \
 733 .  {* map_head, map_tail                                            *}  \
 734 .     { NULL }, { NULL }                                                \
 735 .    }
 736 .
 737 .{* We use a macro to initialize the static asymbol structures because
 738 .   traditional C does not permit us to initialize a union member while
 739 .   gcc warns if we don't initialize it.
 740 .   the_bfd, name, value, attr, section [, udata]  *}
 741 .#ifdef __STDC__
 742 .#define GLOBAL_SYM_INIT(NAME, SECTION) \
 743 .  { 0, NAME, 0, BSF_SECTION_SYM, SECTION, { 0 }}
 744 .#else
 745 .#define GLOBAL_SYM_INIT(NAME, SECTION) \
 746 .  { 0, NAME, 0, BSF_SECTION_SYM, SECTION }
 747 .#endif
 748 .
 749 */
 750
 751 /* These symbols are global, not specific to any BFD.  Therefore, anything
 752    that tries to change them is broken, and should be repaired.  */
 753
 754 static const asymbol global_syms[] =
 755 {
 756   GLOBAL_SYM_INIT (BFD_COM_SECTION_NAME, bfd_com_section_ptr),
 757   GLOBAL_SYM_INIT (BFD_UND_SECTION_NAME, bfd_und_section_ptr),
 758   GLOBAL_SYM_INIT (BFD_ABS_SECTION_NAME, bfd_abs_section_ptr),
 759   GLOBAL_SYM_INIT (BFD_IND_SECTION_NAME, bfd_ind_section_ptr)
 760 };
 761
 762 #define STD_SECTION(NAME, IDX, FLAGS) \
 763   BFD_FAKE_SECTION(_bfd_std_section[IDX], &global_syms[IDX], NAME, IDX, FLAGS)
 764
 765 asection _bfd_std_section[] = {
 766   STD_SECTION (BFD_COM_SECTION_NAME, 0, SEC_IS_COMMON),
 767   STD_SECTION (BFD_UND_SECTION_NAME, 1, 0),
 768   STD_SECTION (BFD_ABS_SECTION_NAME, 2, 0),
 769   STD_SECTION (BFD_IND_SECTION_NAME, 3, 0)
 770 };
 771 #undef STD_SECTION
 772
 773 /* Initialize an entry in the section hash table.  */
 774
 775 struct bfd_hash_entry *
 776 bfd_section_hash_newfunc (struct bfd_hash_entry *entry,
 777                           struct bfd_hash_table *table,
 778                           const char *string)
 779 {
 780   /* Allocate the structure if it has not already been allocated by a
 781      subclass.  */
 782   if (entry == NULL)
 783     {
 784       entry = (struct bfd_hash_entry *)
 785         bfd_hash_allocate (table, sizeof (struct section_hash_entry));
 786       if (entry == NULL)
 787         return entry;
 788     }
 789
 790   /* Call the allocation method of the superclass.  */
 791   entry = bfd_hash_newfunc (entry, table, string);
 792   if (entry != NULL)
 793     memset (&((struct section_hash_entry *) entry)->section, 0,
 794             sizeof (asection));
 795
 796   return entry;
 797 }
 798
 799 #define section_hash_lookup(table, string, create, copy) \
 800   ((struct section_hash_entry *) \
 801    bfd_hash_lookup ((table), (string), (create), (copy)))
 802
 803 /* Create a symbol whose only job is to point to this section.  This
 804    is useful for things like relocs which are relative to the base
 805    of a section.  */
 806
 807 bfd_boolean
 808 _bfd_generic_new_section_hook (bfd *abfd, asection *newsect)
 809 {
 810   newsect->symbol = bfd_make_empty_symbol (abfd);
 811   if (newsect->symbol == NULL)
 812     return FALSE;
 813
 814   newsect->symbol->name = newsect->name;
 815   newsect->symbol->value = 0;
 816   newsect->symbol->section = newsect;
 817   newsect->symbol->flags = BSF_SECTION_SYM;
 818
 819   newsect->symbol_ptr_ptr = &newsect->symbol;
 820   return TRUE;
 821 }
 822
 823 unsigned int _bfd_section_id = 0x10;  /* id 0 to 3 used by STD_SECTION.  */
 824
 825 /* Initializes a new section.  NEWSECT->NAME is already set.  */
 826
 827 static asection *
 828 bfd_section_init (bfd *abfd, asection *newsect)
 829 {
 830   newsect->id = _bfd_section_id;
 831   newsect->index = abfd->section_count;
 832   newsect->owner = abfd;
 833
 834   if (! BFD_SEND (abfd, _new_section_hook, (abfd, newsect)))
 835     return NULL;
 836
 837   _bfd_section_id++;
 838   abfd->section_count++;
 839   bfd_section_list_append (abfd, newsect);
 840   return newsect;
 841 }
 842
 843 /*
 844 DOCDD
 845 INODE
 846 section prototypes,  , typedef asection, Sections
 847 SUBSECTION
 848         Section prototypes
 849
 850 These are the functions exported by the section handling part of BFD.
 851 */
 852
 853 /*
 854 FUNCTION
 855         bfd_section_list_clear
 856
 857 SYNOPSIS
 858         void bfd_section_list_clear (bfd *);
 859
 860 DESCRIPTION
 861         Clears the section list, and also resets the section count and
 862         hash table entries.
 863 */
 864
 865 void
 866 bfd_section_list_clear (bfd *abfd)
 867 {
 868   abfd->sections = NULL;
 869   abfd->section_last = NULL;
 870   abfd->section_count = 0;
 871   memset (abfd->section_htab.table, 0,
 872           abfd->section_htab.size * sizeof (struct bfd_hash_entry *));
 873   abfd->section_htab.count = 0;
 874 }
 875
 876 /*
 877 FUNCTION
 878         bfd_get_section_by_name
 879
 880 SYNOPSIS
 881         asection *bfd_get_section_by_name (bfd *abfd, const char *name);
 882
 883 DESCRIPTION
 884         Return the most recently created section attached to @var{abfd}
 885         named @var{name}.  Return NULL if no such section exists.
 886 */
 887
 888 asection *
 889 bfd_get_section_by_name (bfd *abfd, const char *name)
 890 {
 891   struct section_hash_entry *sh;
 892
 893   sh = section_hash_lookup (&abfd->section_htab, name, FALSE, FALSE);
 894   if (sh != NULL)
 895     return &sh->section;
 896
 897   return NULL;
 898 }
 899
 900 /*
 901 FUNCTION
 902        bfd_get_next_section_by_name
 903
 904 SYNOPSIS
 905        asection *bfd_get_next_section_by_name (bfd *ibfd, asection *sec);
 906
 907 DESCRIPTION
 908        Given @var{sec} is a section returned by @code{bfd_get_section_by_name},
 909        return the next most recently created section attached to the same
 910        BFD with the same name, or if no such section exists in the same BFD and
 911        IBFD is non-NULL, the next section with the same name in any input
 912        BFD following IBFD.  Return NULL on finding no section.
 913 */
 914
 915 asection *
 916 bfd_get_next_section_by_name (bfd *ibfd, asection *sec)
 917 {
 918   struct section_hash_entry *sh;
 919   const char *name;
 920   unsigned long hash;
 921
 922   sh = ((struct section_hash_entry *)
 923         ((char *) sec - offsetof (struct section_hash_entry, section)));
 924
 925   hash = sh->root.hash;
 926   name = sec->name;
 927   for (sh = (struct section_hash_entry *) sh->root.next;
 928        sh != NULL;
 929        sh = (struct section_hash_entry *) sh->root.next)
 930     if (sh->root.hash == hash
 931        && strcmp (sh->root.string, name) == 0)
 932       return &sh->section;
 933
 934   if (ibfd != NULL)
 935     {
 936       while ((ibfd = ibfd->link.next) != NULL)
 937         {
 938           asection *s = bfd_get_section_by_name (ibfd, name);
 939           if (s != NULL)
 940             return s;
 941         }
 942     }
 943
 944   return NULL;
 945 }
 946
 947 /*
 948 FUNCTION
 949         bfd_get_linker_section
 950
 951 SYNOPSIS
 952         asection *bfd_get_linker_section (bfd *abfd, const char *name);
 953
 954 DESCRIPTION
 955         Return the linker created section attached to @var{abfd}
 956         named @var{name}.  Return NULL if no such section exists.
 957 */
 958
 959 asection *
 960 bfd_get_linker_section (bfd *abfd, const char *name)
 961 {
 962   asection *sec = bfd_get_section_by_name (abfd, name);
 963
 964   while (sec != NULL && (sec->flags & SEC_LINKER_CREATED) == 0)
 965     sec = bfd_get_next_section_by_name (NULL, sec);
 966   return sec;
 967 }
 968
 969 /*
 970 FUNCTION
 971         bfd_get_section_by_name_if
 972
 973 SYNOPSIS
 974         asection *bfd_get_section_by_name_if
 975           (bfd *abfd,
 976            const char *name,
 977            bfd_boolean (*func) (bfd *abfd, asection *sect, void *obj),
 978            void *obj);
 979
 980 DESCRIPTION
 981         Call the provided function @var{func} for each section
 982         attached to the BFD @var{abfd} whose name matches @var{name},
 983         passing @var{obj} as an argument. The function will be called
 984         as if by
 985
 986 |       func (abfd, the_section, obj);
 987
 988         It returns the first section for which @var{func} returns true,
 989         otherwise <<NULL>>.
 990
 991 */
 992
 993 asection *
 994 bfd_get_section_by_name_if (bfd *abfd, const char *name,
 995                             bfd_boolean (*operation) (bfd *,
 996                                                       asection *,
 997                                                       void *),
 998                             void *user_storage)
 999 {
1000   struct section_hash_entry *sh;
1001   unsigned long hash;
1002
1003   sh = section_hash_lookup (&abfd->section_htab, name, FALSE, FALSE);
1004   if (sh == NULL)
1005     return NULL;
1006
1007   hash = sh->root.hash;
1008   for (; sh != NULL; sh = (struct section_hash_entry *) sh->root.next)
1009     if (sh->root.hash == hash
1010         && strcmp (sh->root.string, name) == 0
1011         && (*operation) (abfd, &sh->section, user_storage))
1012       return &sh->section;
1013
1014   return NULL;
1015 }
1016
1017 /*
1018 FUNCTION
1019         bfd_get_unique_section_name
1020
1021 SYNOPSIS
1022         char *bfd_get_unique_section_name
1023           (bfd *abfd, const char *templat, int *count);
1024
1025 DESCRIPTION
1026         Invent a section name that is unique in @var{abfd} by tacking
1027         a dot and a digit suffix onto the original @var{templat}.  If
1028         @var{count} is non-NULL, then it specifies the first number
1029         tried as a suffix to generate a unique name.  The value
1030         pointed to by @var{count} will be incremented in this case.
1031 */
1032
1033 char *
1034 bfd_get_unique_section_name (bfd *abfd, const char *templat, int *count)
1035 {
1036   int num;
1037   unsigned int len;
1038   char *sname;
1039
1040   len = strlen (templat);
1041   sname = (char *) bfd_malloc (len + 8);
1042   if (sname == NULL)
1043     return NULL;
1044   memcpy (sname, templat, len);
1045   num = 1;
1046   if (count != NULL)
1047     num = *count;
1048
1049   do
1050     {
1051       /* If we have a million sections, something is badly wrong.  */
1052       if (num > 999999)
1053         abort ();
1054       sprintf (sname + len, ".%d", num++);
1055     }
1056   while (section_hash_lookup (&abfd->section_htab, sname, FALSE, FALSE));
1057
1058   if (count != NULL)
1059     *count = num;
1060   return sname;
1061 }
1062
1063 /*
1064 FUNCTION
1065         bfd_make_section_old_way
1066
1067 SYNOPSIS
1068         asection *bfd_make_section_old_way (bfd *abfd, const char *name);
1069
1070 DESCRIPTION
1071         Create a new empty section called @var{name}
1072         and attach it to the end of the chain of sections for the
1073         BFD @var{abfd}. An attempt to create a section with a name which
1074         is already in use returns its pointer without changing the
1075         section chain.
1076
1077         It has the funny name since this is the way it used to be
1078         before it was rewritten....
1079
1080         Possible errors are:
1081         o <<bfd_error_invalid_operation>> -
1082         If output has already started for this BFD.
1083         o <<bfd_error_no_memory>> -
1084         If memory allocation fails.
1085
1086 */
1087
1088 asection *
1089 bfd_make_section_old_way (bfd *abfd, const char *name)
1090 {
1091   asection *newsect;
1092
1093   if (abfd->output_has_begun)
1094     {
1095       bfd_set_error (bfd_error_invalid_operation);
1096       return NULL;
1097     }
1098
1099   if (strcmp (name, BFD_ABS_SECTION_NAME) == 0)
1100     newsect = bfd_abs_section_ptr;
1101   else if (strcmp (name, BFD_COM_SECTION_NAME) == 0)
1102     newsect = bfd_com_section_ptr;
1103   else if (strcmp (name, BFD_UND_SECTION_NAME) == 0)
1104     newsect = bfd_und_section_ptr;
1105   else if (strcmp (name, BFD_IND_SECTION_NAME) == 0)
1106     newsect = bfd_ind_section_ptr;
1107   else
1108     {
1109       struct section_hash_entry *sh;
1110
1111       sh = section_hash_lookup (&abfd->section_htab, name, TRUE, FALSE);
1112       if (sh == NULL)
1113         return NULL;
1114
1115       newsect = &sh->section;
1116       if (newsect->name != NULL)
1117         {
1118           /* Section already exists.  */
1119           return newsect;
1120         }
1121
1122       newsect->name = name;
1123       return bfd_section_init (abfd, newsect);
1124     }
1125
1126   /* Call new_section_hook when "creating" the standard abs, com, und
1127      and ind sections to tack on format specific section data.
1128      Also, create a proper section symbol.  */
1129   if (! BFD_SEND (abfd, _new_section_hook, (abfd, newsect)))
1130     return NULL;
1131   return newsect;
1132 }
1133
1134 /*
1135 FUNCTION
1136         bfd_make_section_anyway_with_flags
1137
1138 SYNOPSIS
1139         asection *bfd_make_section_anyway_with_flags
1140           (bfd *abfd, const char *name, flagword flags);
1141
1142 DESCRIPTION
1143    Create a new empty section called @var{name} and attach it to the end of
1144    the chain of sections for @var{abfd}.  Create a new section even if there
1145    is already a section with that name.  Also set the attributes of the
1146    new section to the value @var{flags}.
1147
1148    Return <<NULL>> and set <<bfd_error>> on error; possible errors are:
1149    o <<bfd_error_invalid_operation>> - If output has already started for @var{abfd}.
1150    o <<bfd_error_no_memory>> - If memory allocation fails.
1151 */
1152
1153 sec_ptr
1154 bfd_make_section_anyway_with_flags (bfd *abfd, const char *name,
1155                                     flagword flags)
1156 {
1157   struct section_hash_entry *sh;
1158   asection *newsect;
1159
1160   if (abfd->output_has_begun)
1161     {
1162       bfd_set_error (bfd_error_invalid_operation);
1163       return NULL;
1164     }
1165
1166   sh = section_hash_lookup (&abfd->section_htab, name, TRUE, FALSE);
1167   if (sh == NULL)
1168     return NULL;
1169
1170   newsect = &sh->section;
1171   if (newsect->name != NULL)
1172     {
1173       /* We are making a section of the same name.  Put it in the
1174          section hash table.  Even though we can't find it directly by a
1175          hash lookup, we'll be able to find the section by traversing
1176          sh->root.next quicker than looking at all the bfd sections.  */
1177       struct section_hash_entry *new_sh;
1178       new_sh = (struct section_hash_entry *)
1179         bfd_section_hash_newfunc (NULL, &abfd->section_htab, name);
1180       if (new_sh == NULL)
1181         return NULL;
1182
1183       new_sh->root = sh->root;
1184       sh->root.next = &new_sh->root;
1185       newsect = &new_sh->section;
1186     }
1187
1188   newsect->flags = flags;
1189   newsect->name = name;
1190   return bfd_section_init (abfd, newsect);
1191 }
1192
1193 /*
1194 FUNCTION
1195         bfd_make_section_anyway
1196
1197 SYNOPSIS
1198         asection *bfd_make_section_anyway (bfd *abfd, const char *name);
1199
1200 DESCRIPTION
1201    Create a new empty section called @var{name} and attach it to the end of
1202    the chain of sections for @var{abfd}.  Create a new section even if there
1203    is already a section with that name.
1204
1205    Return <<NULL>> and set <<bfd_error>> on error; possible errors are:
1206    o <<bfd_error_invalid_operation>> - If output has already started for @var{abfd}.
1207    o <<bfd_error_no_memory>> - If memory allocation fails.
1208 */
1209
1210 sec_ptr
1211 bfd_make_section_anyway (bfd *abfd, const char *name)
1212 {
1213   return bfd_make_section_anyway_with_flags (abfd, name, 0);
1214 }
1215
1216 /*
1217 FUNCTION
1218         bfd_make_section_with_flags
1219
1220 SYNOPSIS
1221         asection *bfd_make_section_with_flags
1222           (bfd *, const char *name, flagword flags);
1223
1224 DESCRIPTION
1225    Like <<bfd_make_section_anyway>>, but return <<NULL>> (without calling
1226    bfd_set_error ()) without changing the section chain if there is already a
1227    section named @var{name}.  Also set the attributes of the new section to
1228    the value @var{flags}.  If there is an error, return <<NULL>> and set
1229    <<bfd_error>>.
1230 */
1231
1232 asection *
1233 bfd_make_section_with_flags (bfd *abfd, const char *name,
1234                              flagword flags)
1235 {
1236   struct section_hash_entry *sh;
1237   asection *newsect;
1238
1239   if (abfd == NULL || name == NULL || abfd->output_has_begun)
1240     {
1241       bfd_set_error (bfd_error_invalid_operation);
1242       return NULL;
1243     }
1244
1245   if (strcmp (name, BFD_ABS_SECTION_NAME) == 0
1246       || strcmp (name, BFD_COM_SECTION_NAME) == 0
1247       || strcmp (name, BFD_UND_SECTION_NAME) == 0
1248       || strcmp (name, BFD_IND_SECTION_NAME) == 0)
1249     return NULL;
1250
1251   sh = section_hash_lookup (&abfd->section_htab, name, TRUE, FALSE);
1252   if (sh == NULL)
1253     return NULL;
1254
1255   newsect = &sh->section;
1256   if (newsect->name != NULL)
1257     {
1258       /* Section already exists.  */
1259       return NULL;
1260     }
1261
1262   newsect->name = name;
1263   newsect->flags = flags;
1264   return bfd_section_init (abfd, newsect);
1265 }
1266
1267 /*
1268 FUNCTION
1269         bfd_make_section
1270
1271 SYNOPSIS
1272         asection *bfd_make_section (bfd *, const char *name);
1273
1274 DESCRIPTION
1275    Like <<bfd_make_section_anyway>>, but return <<NULL>> (without calling
1276    bfd_set_error ()) without changing the section chain if there is already a
1277    section named @var{name}.  If there is an error, return <<NULL>> and set
1278    <<bfd_error>>.
1279 */
1280
1281 asection *
1282 bfd_make_section (bfd *abfd, const char *name)
1283 {
1284   return bfd_make_section_with_flags (abfd, name, 0);
1285 }
1286
1287 /*
1288 FUNCTION
1289         bfd_set_section_flags
1290
1291 SYNOPSIS
1292         bfd_boolean bfd_set_section_flags
1293           (bfd *abfd, asection *sec, flagword flags);
1294
1295 DESCRIPTION
1296         Set the attributes of the section @var{sec} in the BFD
1297         @var{abfd} to the value @var{flags}. Return <<TRUE>> on success,
1298         <<FALSE>> on error. Possible error returns are:
1299
1300         o <<bfd_error_invalid_operation>> -
1301         The section cannot have one or more of the attributes
1302         requested. For example, a .bss section in <<a.out>> may not
1303         have the <<SEC_HAS_CONTENTS>> field set.
1304
1305 */
1306
1307 bfd_boolean
1308 bfd_set_section_flags (bfd *abfd ATTRIBUTE_UNUSED,
1309                        sec_ptr section,
1310                        flagword flags)
1311 {
1312   section->flags = flags;
1313   return TRUE;
1314 }
1315
1316 /*
1317 FUNCTION
1318         bfd_rename_section
1319
1320 SYNOPSIS
1321         void bfd_rename_section
1322           (bfd *abfd, asection *sec, const char *newname);
1323
1324 DESCRIPTION
1325         Rename section @var{sec} in @var{abfd} to @var{newname}.
1326 */
1327
1328 void
1329 bfd_rename_section (bfd *abfd, sec_ptr sec, const char *newname)
1330 {
1331   struct section_hash_entry *sh;
1332
1333   sh = (struct section_hash_entry *)
1334     ((char *) sec - offsetof (struct section_hash_entry, section));
1335   sh->section.name = newname;
1336   bfd_hash_rename (&abfd->section_htab, newname, &sh->root);
1337 }
1338
1339 /*
1340 FUNCTION
1341         bfd_map_over_sections
1342
1343 SYNOPSIS
1344         void bfd_map_over_sections
1345           (bfd *abfd,
1346            void (*func) (bfd *abfd, asection *sect, void *obj),
1347            void *obj);
1348
1349 DESCRIPTION
1350         Call the provided function @var{func} for each section
1351         attached to the BFD @var{abfd}, passing @var{obj} as an
1352         argument. The function will be called as if by
1353
1354 |       func (abfd, the_section, obj);
1355
1356         This is the preferred method for iterating over sections; an
1357         alternative would be to use a loop:
1358
1359 |          asection *p;
1360 |          for (p = abfd->sections; p != NULL; p = p->next)
1361 |             func (abfd, p, ...)
1362
1363 */
1364
1365 void
1366 bfd_map_over_sections (bfd *abfd,
1367                        void (*operation) (bfd *, asection *, void *),
1368                        void *user_storage)
1369 {
1370   asection *sect;
1371   unsigned int i = 0;
1372
1373   for (sect = abfd->sections; sect != NULL; i++, sect = sect->next)
1374     (*operation) (abfd, sect, user_storage);
1375
1376   if (i != abfd->section_count) /* Debugging */
1377     abort ();
1378 }
1379
1380 /*
1381 FUNCTION
1382         bfd_sections_find_if
1383
1384 SYNOPSIS
1385         asection *bfd_sections_find_if
1386           (bfd *abfd,
1387            bfd_boolean (*operation) (bfd *abfd, asection *sect, void *obj),
1388            void *obj);
1389
1390 DESCRIPTION
1391         Call the provided function @var{operation} for each section
1392         attached to the BFD @var{abfd}, passing @var{obj} as an
1393         argument. The function will be called as if by
1394
1395 |       operation (abfd, the_section, obj);
1396
1397         It returns the first section for which @var{operation} returns true.
1398
1399 */
1400
1401 asection *
1402 bfd_sections_find_if (bfd *abfd,
1403                       bfd_boolean (*operation) (bfd *, asection *, void *),
1404                       void *user_storage)
1405 {
1406   asection *sect;
1407
1408   for (sect = abfd->sections; sect != NULL; sect = sect->next)
1409     if ((*operation) (abfd, sect, user_storage))
1410       break;
1411
1412   return sect;
1413 }
1414
1415 /*
1416 FUNCTION
1417         bfd_set_section_size
1418
1419 SYNOPSIS
1420         bfd_boolean bfd_set_section_size
1421           (bfd *abfd, asection *sec, bfd_size_type val);
1422
1423 DESCRIPTION
1424         Set @var{sec} to the size @var{val}. If the operation is
1425         ok, then <<TRUE>> is returned, else <<FALSE>>.
1426
1427         Possible error returns:
1428         o <<bfd_error_invalid_operation>> -
1429         Writing has started to the BFD, so setting the size is invalid.
1430
1431 */
1432
1433 bfd_boolean
1434 bfd_set_section_size (bfd *abfd, sec_ptr ptr, bfd_size_type val)
1435 {
1436   /* Once you've started writing to any section you cannot create or change
1437      the size of any others.  */
1438
1439   if (abfd->output_has_begun)
1440     {
1441       bfd_set_error (bfd_error_invalid_operation);
1442       return FALSE;
1443     }
1444
1445   ptr->size = val;
1446   return TRUE;
1447 }
1448
1449 /*
1450 FUNCTION
1451         bfd_set_section_contents
1452
1453 SYNOPSIS
1454         bfd_boolean bfd_set_section_contents
1455           (bfd *abfd, asection *section, const void *data,
1456            file_ptr offset, bfd_size_type count);
1457
1458 DESCRIPTION
1459         Sets the contents of the section @var{section} in BFD
1460         @var{abfd} to the data starting in memory at @var{location}.
1461         The data is written to the output section starting at offset
1462         @var{offset} for @var{count} octets.
1463
1464         Normally <<TRUE>> is returned, but <<FALSE>> is returned if
1465         there was an error.  Possible error returns are:
1466         o <<bfd_error_no_contents>> -
1467         The output section does not have the <<SEC_HAS_CONTENTS>>
1468         attribute, so nothing can be written to it.
1469         o <<bfd_error_bad_value>> -
1470         The section is unable to contain all of the data.
1471         o <<bfd_error_invalid_operation>> -
1472         The BFD is not writeable.
1473         o and some more too.
1474
1475         This routine is front end to the back end function
1476         <<_bfd_set_section_contents>>.
1477
1478 */
1479
1480 bfd_boolean
1481 bfd_set_section_contents (bfd *abfd,
1482                           sec_ptr section,
1483                           const void *location,
1484                           file_ptr offset,
1485                           bfd_size_type count)
1486 {
1487   bfd_size_type sz;
1488
1489   if (!(bfd_get_section_flags (abfd, section) & SEC_HAS_CONTENTS))
1490     {
1491       bfd_set_error (bfd_error_no_contents);
1492       return FALSE;
1493     }
1494
1495   sz = section->size;
1496   if ((bfd_size_type) offset > sz
1497       || count > sz
1498       || offset + count > sz
1499       || count != (size_t) count)
1500     {
1501       bfd_set_error (bfd_error_bad_value);
1502       return FALSE;
1503     }
1504
1505   if (!bfd_write_p (abfd))
1506     {
1507       bfd_set_error (bfd_error_invalid_operation);
1508       return FALSE;
1509     }
1510
1511   /* Record a copy of the data in memory if desired.  */
1512   if (section->contents
1513       && location != section->contents + offset)
1514     memcpy (section->contents + offset, location, (size_t) count);
1515
1516   if (BFD_SEND (abfd, _bfd_set_section_contents,
1517                 (abfd, section, location, offset, count)))
1518     {
1519       abfd->output_has_begun = TRUE;
1520       return TRUE;
1521     }
1522
1523   return FALSE;
1524 }
1525
1526 /*
1527 FUNCTION
1528         bfd_get_section_contents
1529
1530 SYNOPSIS
1531         bfd_boolean bfd_get_section_contents
1532           (bfd *abfd, asection *section, void *location, file_ptr offset,
1533            bfd_size_type count);
1534
1535 DESCRIPTION
1536         Read data from @var{section} in BFD @var{abfd}
1537         into memory starting at @var{location}. The data is read at an
1538         offset of @var{offset} from the start of the input section,
1539         and is read for @var{count} bytes.
1540
1541         If the contents of a constructor with the <<SEC_CONSTRUCTOR>>
1542         flag set are requested or if the section does not have the
1543         <<SEC_HAS_CONTENTS>> flag set, then the @var{location} is filled
1544         with zeroes. If no errors occur, <<TRUE>> is returned, else
1545         <<FALSE>>.
1546
1547 */
1548 bfd_boolean
1549 bfd_get_section_contents (bfd *abfd,
1550                           sec_ptr section,
1551                           void *location,
1552                           file_ptr offset,
1553                           bfd_size_type count)
1554 {
1555   bfd_size_type sz;
1556
1557   if (section->flags & SEC_CONSTRUCTOR)
1558     {
1559       memset (location, 0, (size_t) count);
1560       return TRUE;
1561     }
1562
1563   if (abfd->direction != write_direction && section->rawsize != 0)
1564     sz = section->rawsize;
1565   else
1566     sz = section->size;
1567   if ((bfd_size_type) offset > sz
1568       || count > sz
1569       || offset + count > sz
1570       || count != (size_t) count)
1571     {
1572       bfd_set_error (bfd_error_bad_value);
1573       return FALSE;
1574     }
1575
1576   if (count == 0)
1577     /* Don't bother.  */
1578     return TRUE;
1579
1580   if ((section->flags & SEC_HAS_CONTENTS) == 0)
1581     {
1582       memset (location, 0, (size_t) count);
1583       return TRUE;
1584     }
1585
1586   if ((section->flags & SEC_IN_MEMORY) != 0)
1587     {
1588       if (section->contents == NULL)
1589         {
1590           /* This can happen because of errors earlier on in the linking process.
1591              We do not want to seg-fault here, so clear the flag and return an
1592              error code.  */
1593           section->flags &= ~ SEC_IN_MEMORY;
1594           bfd_set_error (bfd_error_invalid_operation);
1595           return FALSE;
1596         }
1597
1598       memmove (location, section->contents + offset, (size_t) count);
1599       return TRUE;
1600     }
1601
1602   return BFD_SEND (abfd, _bfd_get_section_contents,
1603                    (abfd, section, location, offset, count));
1604 }
1605
1606 /*
1607 FUNCTION
1608         bfd_malloc_and_get_section
1609
1610 SYNOPSIS
1611         bfd_boolean bfd_malloc_and_get_section
1612           (bfd *abfd, asection *section, bfd_byte **buf);
1613
1614 DESCRIPTION
1615         Read all data from @var{section} in BFD @var{abfd}
1616         into a buffer, *@var{buf}, malloc'd by this function.
1617 */
1618
1619 bfd_boolean
1620 bfd_malloc_and_get_section (bfd *abfd, sec_ptr sec, bfd_byte **buf)
1621 {
1622   *buf = NULL;
1623   return bfd_get_full_section_contents (abfd, sec, buf);
1624 }
1625 /*
1626 FUNCTION
1627         bfd_copy_private_section_data
1628
1629 SYNOPSIS
1630         bfd_boolean bfd_copy_private_section_data
1631           (bfd *ibfd, asection *isec, bfd *obfd, asection *osec);
1632
1633 DESCRIPTION
1634         Copy private section information from @var{isec} in the BFD
1635         @var{ibfd} to the section @var{osec} in the BFD @var{obfd}.
1636         Return <<TRUE>> on success, <<FALSE>> on error.  Possible error
1637         returns are:
1638
1639         o <<bfd_error_no_memory>> -
1640         Not enough memory exists to create private data for @var{osec}.
1641
1642 .#define bfd_copy_private_section_data(ibfd, isection, obfd, osection) \
1643 .       BFD_SEND (obfd, _bfd_copy_private_section_data, \
1644 .                 (ibfd, isection, obfd, osection))
1645 */
1646
1647 /*
1648 FUNCTION
1649         bfd_generic_is_group_section
1650
1651 SYNOPSIS
1652         bfd_boolean bfd_generic_is_group_section (bfd *, const asection *sec);
1653
1654 DESCRIPTION
1655         Returns TRUE if @var{sec} is a member of a group.
1656 */
1657
1658 bfd_boolean
1659 bfd_generic_is_group_section (bfd *abfd ATTRIBUTE_UNUSED,
1660                               const asection *sec ATTRIBUTE_UNUSED)
1661 {
1662   return FALSE;
1663 }
1664
1665 /*
1666 FUNCTION
1667         bfd_generic_discard_group
1668
1669 SYNOPSIS
1670         bfd_boolean bfd_generic_discard_group (bfd *abfd, asection *group);
1671
1672 DESCRIPTION
1673         Remove all members of @var{group} from the output.
1674 */
1675
1676 bfd_boolean
1677 bfd_generic_discard_group (bfd *abfd ATTRIBUTE_UNUSED,
1678                            asection *group ATTRIBUTE_UNUSED)
1679 {
1680   return TRUE;
1681 }
1682
1683 bfd_boolean
1684 _bfd_nowrite_set_section_contents (bfd *abfd,
1685                                    sec_ptr section ATTRIBUTE_UNUSED,
1686                                    const void *location ATTRIBUTE_UNUSED,
1687                                    file_ptr offset ATTRIBUTE_UNUSED,
1688                                    bfd_size_type count ATTRIBUTE_UNUSED)
1689 {
1690   return _bfd_bool_bfd_false_error (abfd);
1691 }