Coverage Report

Created: 2024-05-21 06:29

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