Adds support for following CPUs to the ARM and Aarch64 assemblers: Cortex-A77, Cortex...
[external/binutils.git] / bfd / section.c
1 /* Object file "section" support for the BFD library.
2    Copyright (C) 1990-2019 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 }