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