OpenCores
URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-6.8/] [bfd/] [section.c] - Blame information for rev 225

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.