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 { 792 /* Allocate the structure if it has not already been allocated by a 793 subclass. */ 794 if (entry == NULL) 795 { 796 entry = (struct bfd_hash_entry *) 797 bfd_hash_allocate (table, sizeof (struct section_hash_entry)); 798 if (entry == NULL) 799 return entry; 800 } 801 802 /* Call the allocation method of the superclass. */ 803 entry = bfd_hash_newfunc (entry, table, string); 804 if (entry != NULL) 805 memset (&((struct section_hash_entry *) entry)->section, 0, 806 sizeof (asection)); 807 808 return entry; 809 } 810 811 #define section_hash_lookup(table, string, create, copy) \ 812 ((struct section_hash_entry *) \ 813 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 { 822 newsect->symbol = bfd_make_empty_symbol (abfd); 823 if (newsect->symbol == NULL) 824 return false; 825 826 newsect->symbol->name = newsect->name; 827 newsect->symbol->value = 0; 828 newsect->symbol->section = newsect; 829 newsect->symbol->flags = BSF_SECTION_SYM; 830 831 newsect->symbol_ptr_ptr = &newsect->symbol; 832 return true; 833 } 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 { 842 newsect->id = _bfd_section_id; 843 newsect->index = abfd->section_count; 844 newsect->owner = abfd; 845 846 if (! BFD_SEND (abfd, _new_section_hook, (abfd, newsect))) 847 return NULL; 848 849 _bfd_section_id++; 850 abfd->section_count++; 851 bfd_section_list_append (abfd, newsect); 852 return newsect; 853 } 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 { 880 abfd->sections = NULL; 881 abfd->section_last = NULL; 882 abfd->section_count = 0; 883 memset (abfd->section_htab.table, 0, 884 abfd->section_htab.size * sizeof (struct bfd_hash_entry *)); 885 abfd->section_htab.count = 0; 886 } 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 { 903 struct section_hash_entry *sh; 904 905 if (name == NULL) 906 return NULL; 907 908 sh = section_hash_lookup (&abfd->section_htab, name, false, false); 909 if (sh != NULL) 910 return &sh->section; 911 912 return NULL; 913 } 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 { 933 struct section_hash_entry *sh; 934 const char *name; 935 unsigned long hash; 936 937 sh = ((struct section_hash_entry *) 938 ((char *) sec - offsetof (struct section_hash_entry, section))); 939 940 hash = sh->root.hash; 941 name = sec->name; 942 for (sh = (struct section_hash_entry *) sh->root.next; 943 sh != NULL; 944 sh = (struct section_hash_entry *) sh->root.next) 945 if (sh->root.hash == hash 946 && strcmp (sh->root.string, name) == 0) 947 return &sh->section; 948 949 if (ibfd != NULL) 950 { 951 while ((ibfd = ibfd->link.next) != NULL) 952 { 953 asection *s = bfd_get_section_by_name (ibfd, name); 954 if (s != NULL) 955 return s; 956 } 957 } 958 959 return NULL; 960 } 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 { 977 asection *sec = bfd_get_section_by_name (abfd, name); 978 979 while (sec != NULL && (sec->flags & SEC_LINKER_CREATED) == 0) 980 sec = bfd_get_next_section_by_name (NULL, sec); 981 return sec; 982 } 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 { 1013 struct section_hash_entry *sh; 1014 unsigned long hash; 1015 1016 if (name == NULL) 1017 return NULL; 1018 1019 sh = section_hash_lookup (&abfd->section_htab, name, false, false); 1020 if (sh == NULL) 1021 return NULL; 1022 1023 hash = sh->root.hash; 1024 for (; sh != NULL; sh = (struct section_hash_entry *) sh->root.next) 1025 if (sh->root.hash == hash 1026 && strcmp (sh->root.string, name) == 0 1027 && (*operation) (abfd, &sh->section, user_storage)) 1028 return &sh->section; 1029 1030 return NULL; 1031 } 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 { 1052 int num; 1053 unsigned int len; 1054 char *sname; 1055 1056 len = strlen (templat); 1057 sname = (char *) bfd_malloc (len + 8); 1058 if (sname == NULL) 1059 return NULL; 1060 memcpy (sname, templat, len); 1061 num = 1; 1062 if (count != NULL) 1063 num = *count; 1064 1065 do 1066 { 1067 /* If we have a million sections, something is badly wrong. */ 1068 if (num > 999999) 1069 abort (); 1070 sprintf (sname + len, ".%d", num++); 1071 } 1072 while (section_hash_lookup (&abfd->section_htab, sname, false, false)); 1073 1074 if (count != NULL) 1075 *count = num; 1076 return sname; 1077 } 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 { 1107 asection *newsect; 1108 1109 if (abfd->output_has_begun) 1110 { 1111 bfd_set_error (bfd_error_invalid_operation); 1112 return NULL; 1113 } 1114 1115 if (strcmp (name, BFD_ABS_SECTION_NAME) == 0) 1116 newsect = bfd_abs_section_ptr; 1117 else if (strcmp (name, BFD_COM_SECTION_NAME) == 0) 1118 newsect = bfd_com_section_ptr; 1119 else if (strcmp (name, BFD_UND_SECTION_NAME) == 0) 1120 newsect = bfd_und_section_ptr; 1121 else if (strcmp (name, BFD_IND_SECTION_NAME) == 0) 1122 newsect = bfd_ind_section_ptr; 1123 else 1124 { 1125 struct section_hash_entry *sh; 1126 1127 sh = section_hash_lookup (&abfd->section_htab, name, true, false); 1128 if (sh == NULL) 1129 return NULL; 1130 1131 newsect = &sh->section; 1132 if (newsect->name != NULL) 1133 { 1134 /* Section already exists. */ 1135 return newsect; 1136 } 1137 1138 newsect->name = name; 1139 return bfd_section_init (abfd, newsect); 1140 } 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 if (! BFD_SEND (abfd, _new_section_hook, (abfd, newsect))) 1146 return NULL; 1147 return newsect; 1148 } 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 { 1173 struct section_hash_entry *sh; 1174 asection *newsect; 1175 1176 if (abfd->output_has_begun) 1177 { 1178 bfd_set_error (bfd_error_invalid_operation); 1179 return NULL; 1180 } 1181 1182 sh = section_hash_lookup (&abfd->section_htab, name, true, false); 1183 if (sh == NULL) 1184 return NULL; 1185 1186 newsect = &sh->section; 1187 if (newsect->name != NULL) 1188 { 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 struct section_hash_entry *new_sh; 1194 new_sh = (struct section_hash_entry *) 1195 bfd_section_hash_newfunc (NULL, &abfd->section_htab, name); 1196 if (new_sh == NULL) 1197 return NULL; 1198 1199 new_sh->root = sh->root; 1200 sh->root.next = &new_sh->root; 1201 newsect = &new_sh->section; 1202 } 1203 1204 newsect->flags = flags; 1205 newsect->name = name; 1206 return bfd_section_init (abfd, newsect); 1207 } 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 { 1229 return bfd_make_section_anyway_with_flags (abfd, name, 0); 1230 } 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 { 1252 struct section_hash_entry *sh; 1253 asection *newsect; 1254 1255 if (abfd == NULL || name == NULL || abfd->output_has_begun) 1256 { 1257 bfd_set_error (bfd_error_invalid_operation); 1258 return NULL; 1259 } 1260 1261 if (strcmp (name, BFD_ABS_SECTION_NAME) == 0 1262 || strcmp (name, BFD_COM_SECTION_NAME) == 0 1263 || strcmp (name, BFD_UND_SECTION_NAME) == 0 1264 || strcmp (name, BFD_IND_SECTION_NAME) == 0) 1265 return NULL; 1266 1267 sh = section_hash_lookup (&abfd->section_htab, name, true, false); 1268 if (sh == NULL) 1269 return NULL; 1270 1271 newsect = &sh->section; 1272 if (newsect->name != NULL) 1273 { 1274 /* Section already exists. */ 1275 return NULL; 1276 } 1277 1278 newsect->name = name; 1279 newsect->flags = flags; 1280 return bfd_section_init (abfd, newsect); 1281 } 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 { 1300 return bfd_make_section_with_flags (abfd, name, 0); 1301 } 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 { 1325 section->flags = flags; 1326 return true; 1327 } 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 { 1344 struct section_hash_entry *sh; 1345 1346 sh = (struct section_hash_entry *) 1347 ((char *) sec - offsetof (struct section_hash_entry, section)); 1348 sh->section.name = newname; 1349 bfd_hash_rename (&sec->owner->section_htab, newname, &sh->root); 1350 } 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 { 1383 asection *sect; 1384 unsigned int i = 0; 1385 1386 for (sect = abfd->sections; sect != NULL; i++, sect = sect->next) 1387 (*operation) (abfd, sect, user_storage); 1388 1389 if (i != abfd->section_count) /* Debugging */ 1390 abort (); 1391 } 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 { 1419 asection *sect; 1420 1421 for (sect = abfd->sections; sect != NULL; sect = sect->next) 1422 if ((*operation) (abfd, sect, user_storage)) 1423 break; 1424 1425 return sect; 1426 } 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 { 1448 /* Once you've started writing to any section you cannot create or change 1449 the size of any others. */ 1450 1451 if (sec->owner == NULL || sec->owner->output_has_begun) 1452 { 1453 bfd_set_error (bfd_error_invalid_operation); 1454 return false; 1455 } 1456 1457 sec->size = val; 1458 return true; 1459 } 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 { 1499 bfd_size_type sz; 1500 1501 if (!(bfd_section_flags (section) & SEC_HAS_CONTENTS)) 1502 { 1503 bfd_set_error (bfd_error_no_contents); 1504 return false; 1505 } 1506 1507 sz = section->size; 1508 if ((bfd_size_type) offset > sz 1509 || count > sz - offset 1510 || count != (size_t) count) 1511 { 1512 bfd_set_error (bfd_error_bad_value); 1513 return false; 1514 } 1515 1516 if (!bfd_write_p (abfd)) 1517 { 1518 bfd_set_error (bfd_error_invalid_operation); 1519 return false; 1520 } 1521 1522 /* Record a copy of the data in memory if desired. */ 1523 if (section->contents 1524 && location != section->contents + offset) 1525 memcpy (section->contents + offset, location, (size_t) count); 1526 1527 if (BFD_SEND (abfd, _bfd_set_section_contents, 1528 (abfd, section, location, offset, count))) 1529 { 1530 abfd->output_has_begun = true; 1531 return true; 1532 } 1533 1534 return false; 1535 } 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 { 1566 bfd_size_type sz; 1567 1568 if (section->flags & SEC_CONSTRUCTOR) 1569 { 1570 memset (location, 0, (size_t) count); 1571 return true; 1572 } 1573 1574 sz = bfd_get_section_limit_octets (abfd, section); 1575 if ((bfd_size_type) offset > sz 1576 || count > sz - offset 1577 || count != (size_t) count) 1578 { 1579 bfd_set_error (bfd_error_bad_value); 1580 return false; 1581 } 1582 1583 if (count == 0) 1584 /* Don't bother. */ 1585 return true; 1586 1587 if ((section->flags & SEC_HAS_CONTENTS) == 0) 1588 { 1589 memset (location, 0, (size_t) count); 1590 return true; 1591 } 1592 1593 if ((section->flags & SEC_IN_MEMORY) != 0) 1594 { 1595 if (section->contents == NULL) 1596 { 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 section->flags &= ~ SEC_IN_MEMORY; 1601 bfd_set_error (bfd_error_invalid_operation); 1602 return false; 1603 } 1604 1605 memmove (location, section->contents + offset, (size_t) count); 1606 return true; 1607 } 1608 1609 return BFD_SEND (abfd, _bfd_get_section_contents, 1610 (abfd, section, location, offset, count)); 1611 } 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 { 1631 if (sec->mmapped_p) 1632 abort (); 1633 *buf = NULL; 1634 return bfd_get_full_section_contents (abfd, sec, buf); 1635 } 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 { 1673 return false; 1674 } 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 { 1691 return NULL; 1692 } 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 { 1709 return true; 1710 } 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 { 1719 return _bfd_bool_bfd_false_error (abfd); 1720 } 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 { 1739 bfd_size_type size = bfd_get_section_limit_octets (abfd, sec); 1740 if (size == 0) 1741 return false; 1742 1743 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 || (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 || (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 || bfd_get_flavour (abfd) == bfd_target_mmo_flavour) 1754 return false; 1755 1756 ufile_ptr filesize = bfd_get_file_size (abfd); 1757 if (filesize == 0) 1758 return false; 1759 1760 if (sec->compress_status == DECOMPRESS_SECTION_ZSTD 1761 || sec->compress_status == DECOMPRESS_SECTION_ZLIB) 1762 { 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 if (size / 10 > filesize) 1773 { 1774 bfd_set_error (bfd_error_bad_value); 1775 return true; 1776 } 1777 size = sec->compressed_size; 1778 } 1779 1780 if ((ufile_ptr) sec->filepos > filesize || size > filesize - sec->filepos) 1781 { 1782 bfd_set_error (bfd_error_file_truncated); 1783 return true; 1784 } 1785 return false; 1786 } 1787