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