PR binutils/12058
[deliverable/binutils-gdb.git] / bfd / section.c
CommitLineData
252b5132 1/* Object file "section" support for the BFD library.
7898deda 2 Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
5c8a75eb 3 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
252b5132
RH
4 Free Software Foundation, Inc.
5 Written by Cygnus Support.
6
cd123cb7
NC
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. */
252b5132
RH
23
24/*
25SECTION
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
42INODE
43Section Input, Section Output, Sections, Sections
44SUBSECTION
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
75INODE
76Section Output, typedef asection, Section Input, Sections
77
78SUBSECTION
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
252b5132
RH
116SUBSECTION
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
252b5132 137#include "sysdep.h"
3db64b00 138#include "bfd.h"
252b5132
RH
139#include "libbfd.h"
140#include "bfdlink.h"
141
142/*
143DOCDD
144INODE
145typedef asection, section prototypes, Section Output, Sections
146SUBSECTION
147 typedef asection
148
149 Here is the section structure:
150
151CODE_FRAGMENT
152.
198beae2 153.typedef struct bfd_section
252b5132 154.{
52b219b5
AM
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. *}
52b219b5
AM
157. const char *name;
158.
159. {* A unique sequence number. *}
52b219b5 160. int id;
252b5132 161.
dbb410c3 162. {* Which section in the bfd; 0..n-1 as sections are created in a bfd. *}
52b219b5 163. int index;
252b5132 164.
52b219b5 165. {* The next section in the list belonging to the BFD, or NULL. *}
198beae2 166. struct bfd_section *next;
252b5132 167.
5daa8fe7
L
168. {* The previous section in the list belonging to the BFD, or NULL. *}
169. struct bfd_section *prev;
170.
52b219b5
AM
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. *}
52b219b5 174. flagword flags;
252b5132
RH
175.
176.#define SEC_NO_FLAGS 0x000
177.
52b219b5
AM
178. {* Tells the OS to allocate space for this section when loading.
179. This is clear for a section containing debug information only. *}
252b5132
RH
180.#define SEC_ALLOC 0x001
181.
52b219b5
AM
182. {* Tells the OS to load the section from the file when loading.
183. This is clear for a .bss section. *}
252b5132
RH
184.#define SEC_LOAD 0x002
185.
52b219b5
AM
186. {* The section contains data still to be relocated, so there is
187. some relocation information too. *}
252b5132
RH
188.#define SEC_RELOC 0x004
189.
52b219b5 190. {* A signal to the OS that the section contains read only data. *}
ebe372c1 191.#define SEC_READONLY 0x008
252b5132 192.
52b219b5 193. {* The section contains code only. *}
ebe372c1 194.#define SEC_CODE 0x010
252b5132 195.
52b219b5 196. {* The section contains data only. *}
ebe372c1 197.#define SEC_DATA 0x020
252b5132 198.
52b219b5 199. {* The section will reside in ROM. *}
ebe372c1 200.#define SEC_ROM 0x040
252b5132 201.
52b219b5
AM
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. *}
ebe372c1 212.#define SEC_CONSTRUCTOR 0x080
252b5132 213.
52b219b5
AM
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>> *}
ebe372c1 217.#define SEC_HAS_CONTENTS 0x100
252b5132 218.
52b219b5
AM
219. {* An instruction to the linker to not output the section
220. even if it has information which would normally be written. *}
ebe372c1 221.#define SEC_NEVER_LOAD 0x200
252b5132 222.
13ae64f3 223. {* The section contains thread local data. *}
ebe372c1 224.#define SEC_THREAD_LOCAL 0x400
13ae64f3 225.
1bd91689
AM
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. *}
ebe372c1 232.#define SEC_HAS_GOT_REF 0x800
1bd91689 233.
52b219b5
AM
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. *}
ebe372c1 239.#define SEC_IS_COMMON 0x1000
252b5132 240.
52b219b5
AM
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. *}
ebe372c1 245.#define SEC_DEBUGGING 0x2000
252b5132 246.
52b219b5
AM
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. *}
ebe372c1 250.#define SEC_IN_MEMORY 0x4000
252b5132 251.
52b219b5
AM
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. *}
ebe372c1 255.#define SEC_EXCLUDE 0x8000
252b5132 256.
dbb410c3
AM
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. *}
ebe372c1 261.#define SEC_SORT_ENTRIES 0x10000
252b5132 262.
52b219b5
AM
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. *}
ebe372c1 267.#define SEC_LINK_ONCE 0x20000
252b5132 268.
52b219b5
AM
269. {* If SEC_LINK_ONCE is set, this bitfield describes how the linker
270. should handle duplicate sections. *}
f856272b 271.#define SEC_LINK_DUPLICATES 0xc0000
252b5132 272.
52b219b5
AM
273. {* This value for SEC_LINK_DUPLICATES means that duplicate
274. sections with the same name should simply be discarded. *}
252b5132
RH
275.#define SEC_LINK_DUPLICATES_DISCARD 0x0
276.
52b219b5
AM
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. *}
f856272b 280.#define SEC_LINK_DUPLICATES_ONE_ONLY 0x40000
252b5132 281.
52b219b5
AM
282. {* This value for SEC_LINK_DUPLICATES means that the linker
283. should warn if any duplicate sections are a different size. *}
f856272b 284.#define SEC_LINK_DUPLICATES_SAME_SIZE 0x80000
252b5132 285.
52b219b5
AM
286. {* This value for SEC_LINK_DUPLICATES means that the linker
287. should warn if any duplicate sections contain different
288. contents. *}
ebe372c1
L
289.#define SEC_LINK_DUPLICATES_SAME_CONTENTS \
290. (SEC_LINK_DUPLICATES_ONE_ONLY | SEC_LINK_DUPLICATES_SAME_SIZE)
252b5132 291.
52b219b5
AM
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. *}
f856272b 296.#define SEC_LINKER_CREATED 0x100000
252b5132 297.
a14a5de3
AM
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. *}
f856272b 301.#define SEC_KEEP 0x200000
252b5132 302.
52b219b5
AM
303. {* This section contains "short" data, and should be placed
304. "near" the GP. *}
f856272b 305.#define SEC_SMALL_DATA 0x400000
34cbe64e 306.
2dd439c5
L
307. {* Attempt to merge identical entities in the section.
308. Entity size is given in the entsize field. *}
f856272b 309.#define SEC_MERGE 0x800000
2dd439c5
L
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. *}
f856272b 314.#define SEC_STRINGS 0x1000000
2dd439c5 315.
dbb410c3 316. {* This section contains data about section groups. *}
f856272b 317.#define SEC_GROUP 0x2000000
ebe372c1
L
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. *}
f856272b 328.#define SEC_COFF_SHARED_LIBRARY 0x4000000
ebe372c1
L
329.
330. {* This section contains data which may be shared with other
331. executables or shared objects. This is for COFF only. *}
f856272b 332.#define SEC_COFF_SHARED 0x8000000
ebe372c1
L
333.
334. {* When a section with this flag is being linked, then if the size of
335. the input section is less than a page, it should not cross a page
336. boundary. If the size of the input section is one page or more,
337. it should be aligned on a page boundary. This is for TI
338. TMS320C54X only. *}
f856272b 339.#define SEC_TIC54X_BLOCK 0x10000000
ebe372c1
L
340.
341. {* Conditionally link this section; do not link if there are no
342. references found to any symbol in the section. This is for TI
343. TMS320C54X only. *}
f856272b 344.#define SEC_TIC54X_CLINK 0x20000000
dbb410c3 345.
156621f3
KT
346. {* Indicate that section has the no read flag set. This happens
347. when memory read flag isn't set. *}
348.#define SEC_COFF_NOREAD 0x40000000
349.
52b219b5 350. {* End of section flags. *}
252b5132 351.
52b219b5 352. {* Some internal packed boolean fields. *}
252b5132 353.
52b219b5
AM
354. {* See the vma field. *}
355. unsigned int user_set_vma : 1;
252b5132 356.
52b219b5
AM
357. {* A mark flag used by some of the linker backends. *}
358. unsigned int linker_mark : 1;
252b5132 359.
d1778b88 360. {* Another mark flag used by some of the linker backends. Set for
08da05b0 361. output sections that have an input section. *}
d1778b88
AM
362. unsigned int linker_has_input : 1;
363.
9d0a14d3 364. {* Mark flag used by some linker backends for garbage collection. *}
52b219b5 365. unsigned int gc_mark : 1;
252b5132 366.
68bfbfcc
AM
367. {* The following flags are used by the ELF linker. *}
368.
369. {* Mark sections which have been allocated to segments. *}
bc67d8a6
NC
370. unsigned int segment_mark : 1;
371.
68bfbfcc
AM
372. {* Type of sec_info information. *}
373. unsigned int sec_info_type:3;
374.#define ELF_INFO_TYPE_NONE 0
375.#define ELF_INFO_TYPE_STABS 1
376.#define ELF_INFO_TYPE_MERGE 2
377.#define ELF_INFO_TYPE_EH_FRAME 3
378.#define ELF_INFO_TYPE_JUST_SYMS 4
379.
380. {* Nonzero if this section uses RELA relocations, rather than REL. *}
381. unsigned int use_rela_p:1;
382.
4c52953f
AM
383. {* Bits used by various backends. The generic code doesn't touch
384. these fields. *}
68bfbfcc 385.
b0dddeec
AM
386. unsigned int sec_flg0:1;
387. unsigned int sec_flg1:1;
388. unsigned int sec_flg2:1;
389. unsigned int sec_flg3:1;
390. unsigned int sec_flg4:1;
391. unsigned int sec_flg5:1;
68bfbfcc 392.
52b219b5 393. {* End of internal packed boolean fields. *}
252b5132 394.
52b219b5
AM
395. {* The virtual memory address of the section - where it will be
396. at run time. The symbols are relocated against this. The
397. user_set_vma flag is maintained by bfd; if it's not set, the
398. backend can assign addresses (for example, in <<a.out>>, where
399. the default address for <<.data>> is dependent on the specific
400. target and various flags). *}
52b219b5 401. bfd_vma vma;
252b5132 402.
52b219b5
AM
403. {* The load address of the section - where it would be in a
404. rom image; really only used for writing section header
b5f79c76 405. information. *}
52b219b5 406. bfd_vma lma;
252b5132 407.
52b219b5
AM
408. {* The size of the section in octets, as it will be output.
409. Contains a value even if the section has no contents (e.g., the
eea6121a
AM
410. size of <<.bss>>). *}
411. bfd_size_type size;
412.
1a23a9e6 413. {* For input sections, the original size on disk of the section, in
73c5c7a8
BW
414. octets. This field should be set for any section whose size is
415. changed by linker relaxation. It is required for sections where
416. the linker relaxation scheme doesn't cache altered section and
417. reloc contents (stabs, eh_frame, SEC_MERGE, some coff relaxing
418. targets), and thus the original size needs to be kept to read the
419. section multiple times. For output sections, rawsize holds the
420. section size calculated on a previous linker relaxation pass. *}
eea6121a 421. bfd_size_type rawsize;
252b5132 422.
7ba29e2a
NC
423. {* Relaxation table. *}
424. struct relax_table *relax;
425.
426. {* Count of used relaxation table entries. *}
427. int relax_count;
428.
429.
52b219b5
AM
430. {* If this section is going to be output, then this value is the
431. offset in *bytes* into the output section of the first byte in the
432. input section (byte ==> smallest addressable unit on the
433. target). In most cases, if this was going to start at the
434. 100th octet (8-bit quantity) in the output section, this value
435. would be 100. However, if the target byte size is 16 bits
436. (bfd_octets_per_byte is "2"), this value would be 50. *}
52b219b5 437. bfd_vma output_offset;
252b5132 438.
52b219b5 439. {* The output section through which to map on output. *}
198beae2 440. struct bfd_section *output_section;
252b5132 441.
52b219b5
AM
442. {* The alignment requirement of the section, as an exponent of 2 -
443. e.g., 3 aligns to 2^3 (or 8). *}
52b219b5 444. unsigned int alignment_power;
252b5132 445.
52b219b5
AM
446. {* If an input section, a pointer to a vector of relocation
447. records for the data in this section. *}
52b219b5 448. struct reloc_cache_entry *relocation;
252b5132 449.
52b219b5
AM
450. {* If an output section, a pointer to a vector of pointers to
451. relocation records for the data in this section. *}
52b219b5 452. struct reloc_cache_entry **orelocation;
252b5132 453.
b5f79c76 454. {* The number of relocation records in one of the above. *}
52b219b5 455. unsigned reloc_count;
252b5132 456.
52b219b5
AM
457. {* Information below is back end specific - and not always used
458. or updated. *}
252b5132 459.
52b219b5 460. {* File position of section data. *}
52b219b5 461. file_ptr filepos;
252b5132 462.
52b219b5 463. {* File position of relocation info. *}
52b219b5 464. file_ptr rel_filepos;
252b5132 465.
52b219b5 466. {* File position of line data. *}
52b219b5 467. file_ptr line_filepos;
252b5132 468.
52b219b5 469. {* Pointer to data for applications. *}
c58b9523 470. void *userdata;
252b5132 471.
52b219b5
AM
472. {* If the SEC_IN_MEMORY flag is set, this points to the actual
473. contents. *}
474. unsigned char *contents;
252b5132 475.
52b219b5 476. {* Attached line number information. *}
52b219b5 477. alent *lineno;
252b5132 478.
52b219b5 479. {* Number of line number records. *}
52b219b5 480. unsigned int lineno_count;
252b5132 481.
2dd439c5 482. {* Entity size for merging purposes. *}
2dd439c5
L
483. unsigned int entsize;
484.
f97b9cb8
L
485. {* Points to the kept section if this section is a link-once section,
486. and is discarded. *}
198beae2 487. struct bfd_section *kept_section;
f97b9cb8 488.
52b219b5
AM
489. {* When a section is being output, this value changes as more
490. linenumbers are written out. *}
52b219b5 491. file_ptr moving_line_filepos;
252b5132 492.
52b219b5 493. {* What the section number is in the target world. *}
52b219b5 494. int target_index;
252b5132 495.
c58b9523 496. void *used_by_bfd;
252b5132 497.
52b219b5
AM
498. {* If this is a constructor section then here is a list of the
499. relocations created to relocate items within it. *}
52b219b5 500. struct relent_chain *constructor_chain;
252b5132 501.
52b219b5 502. {* The BFD which owns the section. *}
52b219b5 503. bfd *owner;
252b5132 504.
b5f79c76 505. {* A symbol which points at this section only. *}
fc0a2244
AC
506. struct bfd_symbol *symbol;
507. struct bfd_symbol **symbol_ptr_ptr;
252b5132 508.
8423293d
AM
509. {* Early in the link process, map_head and map_tail are used to build
510. a list of input sections attached to an output section. Later,
511. output sections use these fields for a list of bfd_link_order
512. structs. *}
513. union {
514. struct bfd_link_order *link_order;
515. struct bfd_section *s;
516. } map_head, map_tail;
b5f79c76 517.} asection;
252b5132 518.
7ba29e2a
NC
519.{* Relax table contains information about instructions which can
520. be removed by relaxation -- replacing a long address with a
521. short address. *}
522.struct relax_table {
523. {* Address where bytes may be deleted. *}
524. bfd_vma addr;
525.
526. {* Number of bytes to be deleted. *}
527. int size;
528.};
529.
52b219b5
AM
530.{* These sections are global, and are managed by BFD. The application
531. and target back end are not permitted to change the values in
532. these sections. New code should use the section_ptr macros rather
533. than referring directly to the const sections. The const sections
534. may eventually vanish. *}
252b5132
RH
535.#define BFD_ABS_SECTION_NAME "*ABS*"
536.#define BFD_UND_SECTION_NAME "*UND*"
537.#define BFD_COM_SECTION_NAME "*COM*"
538.#define BFD_IND_SECTION_NAME "*IND*"
539.
b5f79c76 540.{* The absolute section. *}
2f89ff8d 541.extern asection bfd_abs_section;
252b5132
RH
542.#define bfd_abs_section_ptr ((asection *) &bfd_abs_section)
543.#define bfd_is_abs_section(sec) ((sec) == bfd_abs_section_ptr)
b5f79c76 544.{* Pointer to the undefined section. *}
2f89ff8d 545.extern asection bfd_und_section;
252b5132
RH
546.#define bfd_und_section_ptr ((asection *) &bfd_und_section)
547.#define bfd_is_und_section(sec) ((sec) == bfd_und_section_ptr)
b5f79c76 548.{* Pointer to the common section. *}
2f89ff8d 549.extern asection bfd_com_section;
252b5132 550.#define bfd_com_section_ptr ((asection *) &bfd_com_section)
b5f79c76 551.{* Pointer to the indirect section. *}
2f89ff8d 552.extern asection bfd_ind_section;
252b5132
RH
553.#define bfd_ind_section_ptr ((asection *) &bfd_ind_section)
554.#define bfd_is_ind_section(sec) ((sec) == bfd_ind_section_ptr)
555.
84c254c6
NC
556.#define bfd_is_const_section(SEC) \
557. ( ((SEC) == bfd_abs_section_ptr) \
558. || ((SEC) == bfd_und_section_ptr) \
559. || ((SEC) == bfd_com_section_ptr) \
560. || ((SEC) == bfd_ind_section_ptr))
561.
9e7b37b3
AM
562.{* Macros to handle insertion and deletion of a bfd's sections. These
563. only handle the list pointers, ie. do not adjust section_count,
564. target_index etc. *}
5daa8fe7
L
565.#define bfd_section_list_remove(ABFD, S) \
566. do \
567. { \
568. asection *_s = S; \
569. asection *_next = _s->next; \
570. asection *_prev = _s->prev; \
571. if (_prev) \
572. _prev->next = _next; \
573. else \
574. (ABFD)->sections = _next; \
575. if (_next) \
04dd1667 576. _next->prev = _prev; \
5daa8fe7
L
577. else \
578. (ABFD)->section_last = _prev; \
579. } \
580. while (0)
581.#define bfd_section_list_append(ABFD, S) \
9e7b37b3
AM
582. do \
583. { \
5daa8fe7
L
584. asection *_s = S; \
585. bfd *_abfd = ABFD; \
586. _s->next = NULL; \
587. if (_abfd->section_last) \
588. { \
589. _s->prev = _abfd->section_last; \
590. _abfd->section_last->next = _s; \
591. } \
592. else \
04dd1667
AM
593. { \
594. _s->prev = NULL; \
595. _abfd->sections = _s; \
596. } \
5daa8fe7
L
597. _abfd->section_last = _s; \
598. } \
599. while (0)
04dd1667
AM
600.#define bfd_section_list_prepend(ABFD, S) \
601. do \
602. { \
603. asection *_s = S; \
604. bfd *_abfd = ABFD; \
605. _s->prev = NULL; \
606. if (_abfd->sections) \
607. { \
608. _s->next = _abfd->sections; \
609. _abfd->sections->prev = _s; \
610. } \
611. else \
612. { \
613. _s->next = NULL; \
614. _abfd->section_last = _s; \
615. } \
616. _abfd->sections = _s; \
617. } \
618. while (0)
5daa8fe7
L
619.#define bfd_section_list_insert_after(ABFD, A, S) \
620. do \
621. { \
622. asection *_a = A; \
623. asection *_s = S; \
624. asection *_next = _a->next; \
625. _s->next = _next; \
626. _s->prev = _a; \
627. _a->next = _s; \
628. if (_next) \
04dd1667 629. _next->prev = _s; \
ab82c5b9 630. else \
5daa8fe7 631. (ABFD)->section_last = _s; \
9e7b37b3
AM
632. } \
633. while (0)
5daa8fe7 634.#define bfd_section_list_insert_before(ABFD, B, S) \
9e7b37b3
AM
635. do \
636. { \
5daa8fe7 637. asection *_b = B; \
9e7b37b3 638. asection *_s = S; \
5daa8fe7
L
639. asection *_prev = _b->prev; \
640. _s->prev = _prev; \
641. _s->next = _b; \
642. _b->prev = _s; \
643. if (_prev) \
644. _prev->next = _s; \
645. else \
646. (ABFD)->sections = _s; \
9e7b37b3
AM
647. } \
648. while (0)
5daa8fe7 649.#define bfd_section_removed_from_list(ABFD, S) \
04dd1667 650. ((S)->next == NULL ? (ABFD)->section_last != (S) : (S)->next->prev != (S))
9e7b37b3 651.
f592407e 652.#define BFD_FAKE_SECTION(SEC, FLAGS, SYM, NAME, IDX) \
a4d8e49b
L
653. {* name, id, index, next, prev, flags, user_set_vma, *} \
654. { NAME, IDX, 0, NULL, NULL, FLAGS, 0, \
655. \
b0dddeec
AM
656. {* linker_mark, linker_has_input, gc_mark, segment_mark, *} \
657. 0, 0, 1, 0, \
a4d8e49b 658. \
b0dddeec
AM
659. {* sec_info_type, use_rela_p, *} \
660. 0, 0, \
a4d8e49b 661. \
b0dddeec
AM
662. {* sec_flg0, sec_flg1, sec_flg2, sec_flg3, sec_flg4, sec_flg5, *} \
663. 0, 0, 0, 0, 0, 0, \
a4d8e49b 664. \
b0dddeec
AM
665. {* vma, lma, size, rawsize, relax, relax_count, *} \
666. 0, 0, 0, 0, 0, 0, \
a4d8e49b
L
667. \
668. {* output_offset, output_section, alignment_power, *} \
669. 0, (struct bfd_section *) &SEC, 0, \
670. \
671. {* relocation, orelocation, reloc_count, filepos, rel_filepos, *} \
672. NULL, NULL, 0, 0, 0, \
673. \
674. {* line_filepos, userdata, contents, lineno, lineno_count, *} \
675. 0, NULL, NULL, NULL, 0, \
676. \
677. {* entsize, kept_section, moving_line_filepos, *} \
678. 0, NULL, 0, \
679. \
680. {* target_index, used_by_bfd, constructor_chain, owner, *} \
681. 0, NULL, NULL, NULL, \
682. \
f592407e
AM
683. {* symbol, symbol_ptr_ptr, *} \
684. (struct bfd_symbol *) SYM, &SEC.symbol, \
a4d8e49b
L
685. \
686. {* map_head, map_tail *} \
687. { NULL }, { NULL } \
688. }
689.
252b5132
RH
690*/
691
22bc497d
ILT
692/* We use a macro to initialize the static asymbol structures because
693 traditional C does not permit us to initialize a union member while
694 gcc warns if we don't initialize it. */
695 /* the_bfd, name, value, attr, section [, udata] */
696#ifdef __STDC__
697#define GLOBAL_SYM_INIT(NAME, SECTION) \
698 { 0, NAME, 0, BSF_SECTION_SYM, (asection *) SECTION, { 0 }}
699#else
700#define GLOBAL_SYM_INIT(NAME, SECTION) \
701 { 0, NAME, 0, BSF_SECTION_SYM, (asection *) SECTION }
702#endif
703
252b5132
RH
704/* These symbols are global, not specific to any BFD. Therefore, anything
705 that tries to change them is broken, and should be repaired. */
22bc497d 706
252b5132
RH
707static const asymbol global_syms[] =
708{
22bc497d
ILT
709 GLOBAL_SYM_INIT (BFD_COM_SECTION_NAME, &bfd_com_section),
710 GLOBAL_SYM_INIT (BFD_UND_SECTION_NAME, &bfd_und_section),
711 GLOBAL_SYM_INIT (BFD_ABS_SECTION_NAME, &bfd_abs_section),
712 GLOBAL_SYM_INIT (BFD_IND_SECTION_NAME, &bfd_ind_section)
252b5132
RH
713};
714
f592407e
AM
715#define STD_SECTION(SEC, FLAGS, NAME, IDX) \
716 asection SEC = BFD_FAKE_SECTION(SEC, FLAGS, &global_syms[IDX], \
a4d8e49b 717 NAME, IDX)
252b5132 718
f592407e
AM
719STD_SECTION (bfd_com_section, SEC_IS_COMMON, BFD_COM_SECTION_NAME, 0);
720STD_SECTION (bfd_und_section, 0, BFD_UND_SECTION_NAME, 1);
721STD_SECTION (bfd_abs_section, 0, BFD_ABS_SECTION_NAME, 2);
722STD_SECTION (bfd_ind_section, 0, BFD_IND_SECTION_NAME, 3);
252b5132
RH
723#undef STD_SECTION
724
73e87d70
AM
725/* Initialize an entry in the section hash table. */
726
727struct bfd_hash_entry *
c58b9523
AM
728bfd_section_hash_newfunc (struct bfd_hash_entry *entry,
729 struct bfd_hash_table *table,
730 const char *string)
73e87d70
AM
731{
732 /* Allocate the structure if it has not already been allocated by a
733 subclass. */
734 if (entry == NULL)
735 {
d45913a0
DA
736 entry = (struct bfd_hash_entry *)
737 bfd_hash_allocate (table, sizeof (struct section_hash_entry));
73e87d70
AM
738 if (entry == NULL)
739 return entry;
740 }
741
742 /* Call the allocation method of the superclass. */
743 entry = bfd_hash_newfunc (entry, table, string);
744 if (entry != NULL)
c58b9523
AM
745 memset (&((struct section_hash_entry *) entry)->section, 0,
746 sizeof (asection));
73e87d70
AM
747
748 return entry;
749}
750
751#define section_hash_lookup(table, string, create, copy) \
752 ((struct section_hash_entry *) \
753 bfd_hash_lookup ((table), (string), (create), (copy)))
754
f592407e
AM
755/* Create a symbol whose only job is to point to this section. This
756 is useful for things like relocs which are relative to the base
757 of a section. */
73e87d70 758
f592407e
AM
759bfd_boolean
760_bfd_generic_new_section_hook (bfd *abfd, asection *newsect)
73e87d70 761{
73e87d70
AM
762 newsect->symbol = bfd_make_empty_symbol (abfd);
763 if (newsect->symbol == NULL)
f592407e 764 return FALSE;
73e87d70
AM
765
766 newsect->symbol->name = newsect->name;
767 newsect->symbol->value = 0;
768 newsect->symbol->section = newsect;
769 newsect->symbol->flags = BSF_SECTION_SYM;
770
771 newsect->symbol_ptr_ptr = &newsect->symbol;
f592407e
AM
772 return TRUE;
773}
774
775/* Initializes a new section. NEWSECT->NAME is already set. */
776
777static asection *
778bfd_section_init (bfd *abfd, asection *newsect)
779{
780 static int section_id = 0x10; /* id 0 to 3 used by STD_SECTION. */
781
782 newsect->id = section_id;
783 newsect->index = abfd->section_count;
784 newsect->owner = abfd;
73e87d70
AM
785
786 if (! BFD_SEND (abfd, _new_section_hook, (abfd, newsect)))
787 return NULL;
788
789 section_id++;
790 abfd->section_count++;
5daa8fe7 791 bfd_section_list_append (abfd, newsect);
73e87d70
AM
792 return newsect;
793}
794
252b5132
RH
795/*
796DOCDD
797INODE
798section prototypes, , typedef asection, Sections
799SUBSECTION
800 Section prototypes
801
802These are the functions exported by the section handling part of BFD.
803*/
804
9e7b37b3
AM
805/*
806FUNCTION
807 bfd_section_list_clear
808
809SYNOPSIS
810 void bfd_section_list_clear (bfd *);
811
812DESCRIPTION
813 Clears the section list, and also resets the section count and
814 hash table entries.
815*/
816
817void
c58b9523 818bfd_section_list_clear (bfd *abfd)
9e7b37b3
AM
819{
820 abfd->sections = NULL;
5daa8fe7 821 abfd->section_last = NULL;
9e7b37b3 822 abfd->section_count = 0;
c58b9523 823 memset (abfd->section_htab.table, 0,
9e7b37b3
AM
824 abfd->section_htab.size * sizeof (struct bfd_hash_entry *));
825}
826
252b5132
RH
827/*
828FUNCTION
829 bfd_get_section_by_name
830
831SYNOPSIS
c58b9523 832 asection *bfd_get_section_by_name (bfd *abfd, const char *name);
252b5132
RH
833
834DESCRIPTION
835 Run through @var{abfd} and return the one of the
836 <<asection>>s whose name matches @var{name}, otherwise <<NULL>>.
837 @xref{Sections}, for more information.
838
839 This should only be used in special cases; the normal way to process
840 all sections of a given name is to use <<bfd_map_over_sections>> and
841 <<strcmp>> on the name (or better yet, base it on the section flags
842 or something else) for each section.
843*/
844
845asection *
c58b9523 846bfd_get_section_by_name (bfd *abfd, const char *name)
252b5132 847{
73e87d70
AM
848 struct section_hash_entry *sh;
849
b34976b6 850 sh = section_hash_lookup (&abfd->section_htab, name, FALSE, FALSE);
73e87d70
AM
851 if (sh != NULL)
852 return &sh->section;
252b5132 853
252b5132
RH
854 return NULL;
855}
856
fafe6678
L
857/*
858FUNCTION
859 bfd_get_section_by_name_if
860
861SYNOPSIS
862 asection *bfd_get_section_by_name_if
863 (bfd *abfd,
864 const char *name,
865 bfd_boolean (*func) (bfd *abfd, asection *sect, void *obj),
866 void *obj);
867
868DESCRIPTION
869 Call the provided function @var{func} for each section
870 attached to the BFD @var{abfd} whose name matches @var{name},
871 passing @var{obj} as an argument. The function will be called
872 as if by
873
874| func (abfd, the_section, obj);
875
876 It returns the first section for which @var{func} returns true,
877 otherwise <<NULL>>.
878
879*/
880
881asection *
882bfd_get_section_by_name_if (bfd *abfd, const char *name,
883 bfd_boolean (*operation) (bfd *,
884 asection *,
885 void *),
886 void *user_storage)
887{
888 struct section_hash_entry *sh;
889 unsigned long hash;
890
891 sh = section_hash_lookup (&abfd->section_htab, name, FALSE, FALSE);
892 if (sh == NULL)
893 return NULL;
894
895 hash = sh->root.hash;
896 do
897 {
898 if ((*operation) (abfd, &sh->section, user_storage))
899 return &sh->section;
900 sh = (struct section_hash_entry *) sh->root.next;
901 }
902 while (sh != NULL && sh->root.hash == hash
903 && strcmp (sh->root.string, name) == 0);
904
905 return NULL;
906}
907
1bd91689
AM
908/*
909FUNCTION
910 bfd_get_unique_section_name
911
912SYNOPSIS
c58b9523
AM
913 char *bfd_get_unique_section_name
914 (bfd *abfd, const char *templat, int *count);
1bd91689
AM
915
916DESCRIPTION
917 Invent a section name that is unique in @var{abfd} by tacking
77cb06e9
AM
918 a dot and a digit suffix onto the original @var{templat}. If
919 @var{count} is non-NULL, then it specifies the first number
920 tried as a suffix to generate a unique name. The value
921 pointed to by @var{count} will be incremented in this case.
1bd91689
AM
922*/
923
924char *
c58b9523 925bfd_get_unique_section_name (bfd *abfd, const char *templat, int *count)
1bd91689
AM
926{
927 int num;
928 unsigned int len;
929 char *sname;
930
a966dba9 931 len = strlen (templat);
a50b1753 932 sname = (char *) bfd_malloc (len + 8);
b3ea3584
AM
933 if (sname == NULL)
934 return NULL;
d4c88bbb 935 memcpy (sname, templat, len);
1bd91689
AM
936 num = 1;
937 if (count != NULL)
938 num = *count;
939
940 do
941 {
942 /* If we have a million sections, something is badly wrong. */
943 if (num > 999999)
944 abort ();
77cb06e9 945 sprintf (sname + len, ".%d", num++);
1bd91689 946 }
b34976b6 947 while (section_hash_lookup (&abfd->section_htab, sname, FALSE, FALSE));
1bd91689
AM
948
949 if (count != NULL)
950 *count = num;
951 return sname;
952}
953
252b5132
RH
954/*
955FUNCTION
956 bfd_make_section_old_way
957
958SYNOPSIS
c58b9523 959 asection *bfd_make_section_old_way (bfd *abfd, const char *name);
252b5132
RH
960
961DESCRIPTION
962 Create a new empty section called @var{name}
963 and attach it to the end of the chain of sections for the
964 BFD @var{abfd}. An attempt to create a section with a name which
965 is already in use returns its pointer without changing the
966 section chain.
967
968 It has the funny name since this is the way it used to be
969 before it was rewritten....
970
971 Possible errors are:
972 o <<bfd_error_invalid_operation>> -
973 If output has already started for this BFD.
974 o <<bfd_error_no_memory>> -
975 If memory allocation fails.
976
977*/
978
252b5132 979asection *
c58b9523 980bfd_make_section_old_way (bfd *abfd, const char *name)
252b5132 981{
73e87d70
AM
982 asection *newsect;
983
984 if (abfd->output_has_begun)
985 {
986 bfd_set_error (bfd_error_invalid_operation);
987 return NULL;
988 }
989
990 if (strcmp (name, BFD_ABS_SECTION_NAME) == 0)
f592407e
AM
991 newsect = bfd_abs_section_ptr;
992 else if (strcmp (name, BFD_COM_SECTION_NAME) == 0)
993 newsect = bfd_com_section_ptr;
994 else if (strcmp (name, BFD_UND_SECTION_NAME) == 0)
995 newsect = bfd_und_section_ptr;
996 else if (strcmp (name, BFD_IND_SECTION_NAME) == 0)
997 newsect = bfd_ind_section_ptr;
998 else
999 {
1000 struct section_hash_entry *sh;
73e87d70 1001
f592407e
AM
1002 sh = section_hash_lookup (&abfd->section_htab, name, TRUE, FALSE);
1003 if (sh == NULL)
1004 return NULL;
73e87d70 1005
f592407e
AM
1006 newsect = &sh->section;
1007 if (newsect->name != NULL)
1008 {
1009 /* Section already exists. */
1010 return newsect;
1011 }
73e87d70 1012
f592407e
AM
1013 newsect->name = name;
1014 return bfd_section_init (abfd, newsect);
252b5132 1015 }
73e87d70 1016
f592407e
AM
1017 /* Call new_section_hook when "creating" the standard abs, com, und
1018 and ind sections to tack on format specific section data.
1019 Also, create a proper section symbol. */
1020 if (! BFD_SEND (abfd, _new_section_hook, (abfd, newsect)))
1021 return NULL;
1022 return newsect;
252b5132
RH
1023}
1024
1025/*
1026FUNCTION
3496cb2a 1027 bfd_make_section_anyway_with_flags
252b5132
RH
1028
1029SYNOPSIS
3496cb2a
L
1030 asection *bfd_make_section_anyway_with_flags
1031 (bfd *abfd, const char *name, flagword flags);
252b5132
RH
1032
1033DESCRIPTION
1034 Create a new empty section called @var{name} and attach it to the end of
1035 the chain of sections for @var{abfd}. Create a new section even if there
3496cb2a
L
1036 is already a section with that name. Also set the attributes of the
1037 new section to the value @var{flags}.
252b5132
RH
1038
1039 Return <<NULL>> and set <<bfd_error>> on error; possible errors are:
1040 o <<bfd_error_invalid_operation>> - If output has already started for @var{abfd}.
1041 o <<bfd_error_no_memory>> - If memory allocation fails.
1042*/
1043
1044sec_ptr
3496cb2a
L
1045bfd_make_section_anyway_with_flags (bfd *abfd, const char *name,
1046 flagword flags)
252b5132 1047{
73e87d70 1048 struct section_hash_entry *sh;
252b5132 1049 asection *newsect;
252b5132
RH
1050
1051 if (abfd->output_has_begun)
1052 {
1053 bfd_set_error (bfd_error_invalid_operation);
1054 return NULL;
1055 }
1056
b34976b6 1057 sh = section_hash_lookup (&abfd->section_htab, name, TRUE, FALSE);
73e87d70 1058 if (sh == NULL)
252b5132
RH
1059 return NULL;
1060
73e87d70
AM
1061 newsect = &sh->section;
1062 if (newsect->name != NULL)
4d7ce4dd 1063 {
72adc230
AM
1064 /* We are making a section of the same name. Put it in the
1065 section hash table. Even though we can't find it directly by a
1066 hash lookup, we'll be able to find the section by traversing
1067 sh->root.next quicker than looking at all the bfd sections. */
1068 struct section_hash_entry *new_sh;
1069 new_sh = (struct section_hash_entry *)
1070 bfd_section_hash_newfunc (NULL, &abfd->section_htab, name);
1071 if (new_sh == NULL)
73e87d70 1072 return NULL;
72adc230 1073
73499ab8 1074 new_sh->root = sh->root;
72adc230
AM
1075 sh->root.next = &new_sh->root;
1076 newsect = &new_sh->section;
252b5132
RH
1077 }
1078
3496cb2a 1079 newsect->flags = flags;
73e87d70
AM
1080 newsect->name = name;
1081 return bfd_section_init (abfd, newsect);
252b5132
RH
1082}
1083
1084/*
1085FUNCTION
3496cb2a 1086 bfd_make_section_anyway
252b5132
RH
1087
1088SYNOPSIS
3496cb2a
L
1089 asection *bfd_make_section_anyway (bfd *abfd, const char *name);
1090
1091DESCRIPTION
1092 Create a new empty section called @var{name} and attach it to the end of
1093 the chain of sections for @var{abfd}. Create a new section even if there
1094 is already a section with that name.
1095
1096 Return <<NULL>> and set <<bfd_error>> on error; possible errors are:
1097 o <<bfd_error_invalid_operation>> - If output has already started for @var{abfd}.
1098 o <<bfd_error_no_memory>> - If memory allocation fails.
1099*/
1100
1101sec_ptr
1102bfd_make_section_anyway (bfd *abfd, const char *name)
1103{
1104 return bfd_make_section_anyway_with_flags (abfd, name, 0);
1105}
1106
1107/*
1108FUNCTION
1109 bfd_make_section_with_flags
1110
1111SYNOPSIS
1112 asection *bfd_make_section_with_flags
1113 (bfd *, const char *name, flagword flags);
252b5132
RH
1114
1115DESCRIPTION
1116 Like <<bfd_make_section_anyway>>, but return <<NULL>> (without calling
1117 bfd_set_error ()) without changing the section chain if there is already a
3496cb2a
L
1118 section named @var{name}. Also set the attributes of the new section to
1119 the value @var{flags}. If there is an error, return <<NULL>> and set
252b5132
RH
1120 <<bfd_error>>.
1121*/
1122
1123asection *
3496cb2a
L
1124bfd_make_section_with_flags (bfd *abfd, const char *name,
1125 flagword flags)
252b5132 1126{
73e87d70
AM
1127 struct section_hash_entry *sh;
1128 asection *newsect;
252b5132 1129
73e87d70 1130 if (abfd->output_has_begun)
252b5132 1131 {
73e87d70
AM
1132 bfd_set_error (bfd_error_invalid_operation);
1133 return NULL;
252b5132
RH
1134 }
1135
73e87d70
AM
1136 if (strcmp (name, BFD_ABS_SECTION_NAME) == 0
1137 || strcmp (name, BFD_COM_SECTION_NAME) == 0
1138 || strcmp (name, BFD_UND_SECTION_NAME) == 0
1139 || strcmp (name, BFD_IND_SECTION_NAME) == 0)
1140 return NULL;
252b5132 1141
b34976b6 1142 sh = section_hash_lookup (&abfd->section_htab, name, TRUE, FALSE);
73e87d70
AM
1143 if (sh == NULL)
1144 return NULL;
1145
1146 newsect = &sh->section;
1147 if (newsect->name != NULL)
252b5132 1148 {
73e87d70 1149 /* Section already exists. */
003d627e 1150 return NULL;
252b5132
RH
1151 }
1152
73e87d70 1153 newsect->name = name;
3496cb2a 1154 newsect->flags = flags;
73e87d70 1155 return bfd_section_init (abfd, newsect);
252b5132
RH
1156}
1157
3496cb2a
L
1158/*
1159FUNCTION
1160 bfd_make_section
1161
1162SYNOPSIS
1163 asection *bfd_make_section (bfd *, const char *name);
1164
1165DESCRIPTION
1166 Like <<bfd_make_section_anyway>>, but return <<NULL>> (without calling
1167 bfd_set_error ()) without changing the section chain if there is already a
1168 section named @var{name}. If there is an error, return <<NULL>> and set
1169 <<bfd_error>>.
1170*/
1171
1172asection *
1173bfd_make_section (bfd *abfd, const char *name)
1174{
1175 return bfd_make_section_with_flags (abfd, name, 0);
1176}
1177
252b5132
RH
1178/*
1179FUNCTION
1180 bfd_set_section_flags
1181
1182SYNOPSIS
c58b9523
AM
1183 bfd_boolean bfd_set_section_flags
1184 (bfd *abfd, asection *sec, flagword flags);
252b5132
RH
1185
1186DESCRIPTION
1187 Set the attributes of the section @var{sec} in the BFD
b34976b6
AM
1188 @var{abfd} to the value @var{flags}. Return <<TRUE>> on success,
1189 <<FALSE>> on error. Possible error returns are:
252b5132
RH
1190
1191 o <<bfd_error_invalid_operation>> -
1192 The section cannot have one or more of the attributes
1193 requested. For example, a .bss section in <<a.out>> may not
1194 have the <<SEC_HAS_CONTENTS>> field set.
1195
1196*/
1197
b34976b6 1198bfd_boolean
c58b9523
AM
1199bfd_set_section_flags (bfd *abfd ATTRIBUTE_UNUSED,
1200 sec_ptr section,
1201 flagword flags)
252b5132 1202{
252b5132 1203 section->flags = flags;
b34976b6 1204 return TRUE;
252b5132
RH
1205}
1206
252b5132
RH
1207/*
1208FUNCTION
1209 bfd_map_over_sections
1210
1211SYNOPSIS
c58b9523
AM
1212 void bfd_map_over_sections
1213 (bfd *abfd,
1214 void (*func) (bfd *abfd, asection *sect, void *obj),
1215 void *obj);
252b5132
RH
1216
1217DESCRIPTION
1218 Call the provided function @var{func} for each section
1219 attached to the BFD @var{abfd}, passing @var{obj} as an
1220 argument. The function will be called as if by
1221
c58b9523 1222| func (abfd, the_section, obj);
252b5132 1223
7dee875e 1224 This is the preferred method for iterating over sections; an
252b5132
RH
1225 alternative would be to use a loop:
1226
1227| section *p;
1228| for (p = abfd->sections; p != NULL; p = p->next)
c58b9523 1229| func (abfd, p, ...)
252b5132 1230
252b5132
RH
1231*/
1232
252b5132 1233void
c58b9523
AM
1234bfd_map_over_sections (bfd *abfd,
1235 void (*operation) (bfd *, asection *, void *),
1236 void *user_storage)
252b5132
RH
1237{
1238 asection *sect;
1239 unsigned int i = 0;
1240
1241 for (sect = abfd->sections; sect != NULL; i++, sect = sect->next)
1242 (*operation) (abfd, sect, user_storage);
1243
1244 if (i != abfd->section_count) /* Debugging */
1245 abort ();
1246}
1247
bc87dd2e
L
1248/*
1249FUNCTION
1250 bfd_sections_find_if
1251
1252SYNOPSIS
1253 asection *bfd_sections_find_if
1254 (bfd *abfd,
f4eae89c 1255 bfd_boolean (*operation) (bfd *abfd, asection *sect, void *obj),
bc87dd2e
L
1256 void *obj);
1257
1258DESCRIPTION
f4eae89c 1259 Call the provided function @var{operation} for each section
bc87dd2e
L
1260 attached to the BFD @var{abfd}, passing @var{obj} as an
1261 argument. The function will be called as if by
1262
f4eae89c 1263| operation (abfd, the_section, obj);
bc87dd2e 1264
f4eae89c 1265 It returns the first section for which @var{operation} returns true.
bc87dd2e
L
1266
1267*/
1268
1269asection *
1270bfd_sections_find_if (bfd *abfd,
1271 bfd_boolean (*operation) (bfd *, asection *, void *),
1272 void *user_storage)
1273{
1274 asection *sect;
1275
1276 for (sect = abfd->sections; sect != NULL; sect = sect->next)
1277 if ((*operation) (abfd, sect, user_storage))
1278 break;
1279
1280 return sect;
1281}
1282
252b5132
RH
1283/*
1284FUNCTION
1285 bfd_set_section_size
1286
1287SYNOPSIS
c58b9523
AM
1288 bfd_boolean bfd_set_section_size
1289 (bfd *abfd, asection *sec, bfd_size_type val);
252b5132
RH
1290
1291DESCRIPTION
1292 Set @var{sec} to the size @var{val}. If the operation is
b34976b6 1293 ok, then <<TRUE>> is returned, else <<FALSE>>.
252b5132
RH
1294
1295 Possible error returns:
1296 o <<bfd_error_invalid_operation>> -
1297 Writing has started to the BFD, so setting the size is invalid.
1298
1299*/
1300
b34976b6 1301bfd_boolean
c58b9523 1302bfd_set_section_size (bfd *abfd, sec_ptr ptr, bfd_size_type val)
252b5132
RH
1303{
1304 /* Once you've started writing to any section you cannot create or change
7b82c249 1305 the size of any others. */
252b5132
RH
1306
1307 if (abfd->output_has_begun)
1308 {
1309 bfd_set_error (bfd_error_invalid_operation);
b34976b6 1310 return FALSE;
252b5132
RH
1311 }
1312
eea6121a 1313 ptr->size = val;
b34976b6 1314 return TRUE;
252b5132
RH
1315}
1316
1317/*
1318FUNCTION
1319 bfd_set_section_contents
1320
1321SYNOPSIS
c58b9523 1322 bfd_boolean bfd_set_section_contents
85302095
AC
1323 (bfd *abfd, asection *section, const void *data,
1324 file_ptr offset, bfd_size_type count);
252b5132 1325
252b5132
RH
1326DESCRIPTION
1327 Sets the contents of the section @var{section} in BFD
1328 @var{abfd} to the data starting in memory at @var{data}. The
1329 data is written to the output section starting at offset
9a968f43 1330 @var{offset} for @var{count} octets.
252b5132 1331
b34976b6 1332 Normally <<TRUE>> is returned, else <<FALSE>>. Possible error
252b5132
RH
1333 returns are:
1334 o <<bfd_error_no_contents>> -
1335 The output section does not have the <<SEC_HAS_CONTENTS>>
1336 attribute, so nothing can be written to it.
1337 o and some more too
1338
1339 This routine is front end to the back end function
1340 <<_bfd_set_section_contents>>.
1341
252b5132
RH
1342*/
1343
b34976b6 1344bfd_boolean
c58b9523
AM
1345bfd_set_section_contents (bfd *abfd,
1346 sec_ptr section,
85302095 1347 const void *location,
c58b9523
AM
1348 file_ptr offset,
1349 bfd_size_type count)
252b5132
RH
1350{
1351 bfd_size_type sz;
1352
1353 if (!(bfd_get_section_flags (abfd, section) & SEC_HAS_CONTENTS))
1354 {
1355 bfd_set_error (bfd_error_no_contents);
b34976b6 1356 return FALSE;
252b5132
RH
1357 }
1358
eea6121a 1359 sz = section->size;
dc810e39
AM
1360 if ((bfd_size_type) offset > sz
1361 || count > sz
1362 || offset + count > sz
1363 || count != (size_t) count)
252b5132 1364 {
252b5132 1365 bfd_set_error (bfd_error_bad_value);
b34976b6 1366 return FALSE;
252b5132 1367 }
252b5132 1368
26ae6d5e 1369 if (!bfd_write_p (abfd))
252b5132 1370 {
252b5132 1371 bfd_set_error (bfd_error_invalid_operation);
b34976b6 1372 return FALSE;
252b5132
RH
1373 }
1374
9a951beb
RH
1375 /* Record a copy of the data in memory if desired. */
1376 if (section->contents
c58b9523 1377 && location != section->contents + offset)
dc810e39 1378 memcpy (section->contents + offset, location, (size_t) count);
9a951beb 1379
252b5132
RH
1380 if (BFD_SEND (abfd, _bfd_set_section_contents,
1381 (abfd, section, location, offset, count)))
1382 {
b34976b6
AM
1383 abfd->output_has_begun = TRUE;
1384 return TRUE;
252b5132
RH
1385 }
1386
b34976b6 1387 return FALSE;
252b5132
RH
1388}
1389
1390/*
1391FUNCTION
1392 bfd_get_section_contents
1393
1394SYNOPSIS
c58b9523
AM
1395 bfd_boolean bfd_get_section_contents
1396 (bfd *abfd, asection *section, void *location, file_ptr offset,
1397 bfd_size_type count);
252b5132
RH
1398
1399DESCRIPTION
1400 Read data from @var{section} in BFD @var{abfd}
1401 into memory starting at @var{location}. The data is read at an
1402 offset of @var{offset} from the start of the input section,
1403 and is read for @var{count} bytes.
1404
1405 If the contents of a constructor with the <<SEC_CONSTRUCTOR>>
1406 flag set are requested or if the section does not have the
1407 <<SEC_HAS_CONTENTS>> flag set, then the @var{location} is filled
b34976b6
AM
1408 with zeroes. If no errors occur, <<TRUE>> is returned, else
1409 <<FALSE>>.
252b5132 1410
252b5132 1411*/
b34976b6 1412bfd_boolean
c58b9523
AM
1413bfd_get_section_contents (bfd *abfd,
1414 sec_ptr section,
1415 void *location,
1416 file_ptr offset,
1417 bfd_size_type count)
252b5132
RH
1418{
1419 bfd_size_type sz;
1420
1421 if (section->flags & SEC_CONSTRUCTOR)
1422 {
dc810e39 1423 memset (location, 0, (size_t) count);
b34976b6 1424 return TRUE;
252b5132
RH
1425 }
1426
eea6121a 1427 sz = section->rawsize ? section->rawsize : section->size;
dc810e39
AM
1428 if ((bfd_size_type) offset > sz
1429 || count > sz
1430 || offset + count > sz
1431 || count != (size_t) count)
252b5132 1432 {
252b5132 1433 bfd_set_error (bfd_error_bad_value);
b34976b6 1434 return FALSE;
252b5132 1435 }
252b5132
RH
1436
1437 if (count == 0)
1438 /* Don't bother. */
b34976b6 1439 return TRUE;
252b5132
RH
1440
1441 if ((section->flags & SEC_HAS_CONTENTS) == 0)
1442 {
dc810e39 1443 memset (location, 0, (size_t) count);
b34976b6 1444 return TRUE;
252b5132
RH
1445 }
1446
1447 if ((section->flags & SEC_IN_MEMORY) != 0)
1448 {
ea882e87
NC
1449 if (section->contents == NULL)
1450 {
1451 /* This can happen because of errors earlier on in the linking process.
1452 We do not want to seg-fault here, so clear the flag and return an
1453 error code. */
1454 section->flags &= ~ SEC_IN_MEMORY;
1455 bfd_set_error (bfd_error_invalid_operation);
1456 return FALSE;
1457 }
1458
252b5132 1459 memcpy (location, section->contents + offset, (size_t) count);
b34976b6 1460 return TRUE;
252b5132
RH
1461 }
1462
1463 return BFD_SEND (abfd, _bfd_get_section_contents,
1464 (abfd, section, location, offset, count));
1465}
1466
eea6121a
AM
1467/*
1468FUNCTION
1469 bfd_malloc_and_get_section
1470
1471SYNOPSIS
1472 bfd_boolean bfd_malloc_and_get_section
1473 (bfd *abfd, asection *section, bfd_byte **buf);
1474
1475DESCRIPTION
1476 Read all data from @var{section} in BFD @var{abfd}
1477 into a buffer, *@var{buf}, malloc'd by this function.
1478*/
1479
1480bfd_boolean
1481bfd_malloc_and_get_section (bfd *abfd, sec_ptr sec, bfd_byte **buf)
1482{
1483 bfd_size_type sz = sec->rawsize ? sec->rawsize : sec->size;
1484 bfd_byte *p = NULL;
1485
1486 *buf = p;
1487 if (sz == 0)
1488 return TRUE;
1489
a50b1753
NC
1490 p = (bfd_byte *)
1491 bfd_malloc (sec->rawsize > sec->size ? sec->rawsize : sec->size);
eea6121a
AM
1492 if (p == NULL)
1493 return FALSE;
1494 *buf = p;
1495
1496 return bfd_get_section_contents (abfd, sec, p, 0, sz);
1497}
252b5132
RH
1498/*
1499FUNCTION
1500 bfd_copy_private_section_data
1501
1502SYNOPSIS
c58b9523
AM
1503 bfd_boolean bfd_copy_private_section_data
1504 (bfd *ibfd, asection *isec, bfd *obfd, asection *osec);
252b5132
RH
1505
1506DESCRIPTION
1507 Copy private section information from @var{isec} in the BFD
1508 @var{ibfd} to the section @var{osec} in the BFD @var{obfd}.
b34976b6 1509 Return <<TRUE>> on success, <<FALSE>> on error. Possible error
252b5132
RH
1510 returns are:
1511
1512 o <<bfd_error_no_memory>> -
1513 Not enough memory exists to create private data for @var{osec}.
1514
1515.#define bfd_copy_private_section_data(ibfd, isection, obfd, osection) \
1516. BFD_SEND (obfd, _bfd_copy_private_section_data, \
1517. (ibfd, isection, obfd, osection))
1518*/
1519
72adc230
AM
1520/*
1521FUNCTION
1522 bfd_generic_is_group_section
1523
1524SYNOPSIS
1525 bfd_boolean bfd_generic_is_group_section (bfd *, const asection *sec);
1526
1527DESCRIPTION
1528 Returns TRUE if @var{sec} is a member of a group.
1529*/
1530
1531bfd_boolean
1532bfd_generic_is_group_section (bfd *abfd ATTRIBUTE_UNUSED,
1533 const asection *sec ATTRIBUTE_UNUSED)
1534{
1535 return FALSE;
1536}
1537
b885599b
AM
1538/*
1539FUNCTION
e61463e1 1540 bfd_generic_discard_group
b885599b
AM
1541
1542SYNOPSIS
b34976b6 1543 bfd_boolean bfd_generic_discard_group (bfd *abfd, asection *group);
b885599b
AM
1544
1545DESCRIPTION
1546 Remove all members of @var{group} from the output.
1547*/
1548
b34976b6 1549bfd_boolean
c58b9523
AM
1550bfd_generic_discard_group (bfd *abfd ATTRIBUTE_UNUSED,
1551 asection *group ATTRIBUTE_UNUSED)
b885599b 1552{
b34976b6 1553 return TRUE;
b885599b 1554}
This page took 0.697187 seconds and 4 git commands to generate.