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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [binutils-2.18.50/] [bfd/] [section.c] - Blame information for rev 835

Go to most recent revision | Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

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