section.c revision 33965
1/* Object file "section" support for the BFD library. 2 Copyright (C) 1990, 91, 92, 93, 94, 95, 96, 1997 3 Free Software Foundation, Inc. 4 Written by Cygnus Support. 5 6This file is part of BFD, the Binary File Descriptor library. 7 8This program is free software; you can redistribute it and/or modify 9it under the terms of the GNU General Public License as published by 10the Free Software Foundation; either version 2 of the License, or 11(at your option) any later version. 12 13This program is distributed in the hope that it will be useful, 14but WITHOUT ANY WARRANTY; without even the implied warranty of 15MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16GNU General Public License for more details. 17 18You should have received a copy of the GNU General Public License 19along with this program; if not, write to the Free Software 20Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ 21 22/* 23SECTION 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 40INODE 41Section Input, Section Output, Sections, Sections 42SUBSECTION 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. An IEEE-695 file doesn't contain raw data in 69 sections, but data and relocation expressions intermixed, so 70 the data area has to be parsed to get out the data and 71 relocations. 72 73INODE 74Section Output, typedef asection, Section Input, Sections 75 76SUBSECTION 77 Section output 78 79 To write a new object style BFD, the various sections to be 80 written have to be created. They are attached to the BFD in 81 the same way as input sections; data is written to the 82 sections using <<bfd_set_section_contents>>. 83 84 Any program that creates or combines sections (e.g., the assembler 85 and linker) must use the <<asection>> fields <<output_section>> and 86 <<output_offset>> to indicate the file sections to which each 87 section must be written. (If the section is being created from 88 scratch, <<output_section>> should probably point to the section 89 itself and <<output_offset>> should probably be zero.) 90 91 The data to be written comes from input sections attached 92 (via <<output_section>> pointers) to 93 the output sections. The output section structure can be 94 considered a filter for the input section: the output section 95 determines the vma of the output data and the name, but the 96 input section determines the offset into the output section of 97 the data to be written. 98 99 E.g., to create a section "O", starting at 0x100, 0x123 long, 100 containing two subsections, "A" at offset 0x0 (i.e., at vma 101 0x100) and "B" at offset 0x20 (i.e., at vma 0x120) the <<asection>> 102 structures would look like: 103 104| section name "A" 105| output_offset 0x00 106| size 0x20 107| output_section -----------> section name "O" 108| | vma 0x100 109| section name "B" | size 0x123 110| output_offset 0x20 | 111| size 0x103 | 112| output_section --------| 113 114 115SUBSECTION 116 Link orders 117 118 The data within a section is stored in a @dfn{link_order}. 119 These are much like the fixups in <<gas>>. The link_order 120 abstraction allows a section to grow and shrink within itself. 121 122 A link_order knows how big it is, and which is the next 123 link_order and where the raw data for it is; it also points to 124 a list of relocations which apply to it. 125 126 The link_order is used by the linker to perform relaxing on 127 final code. The compiler creates code which is as big as 128 necessary to make it work without relaxing, and the user can 129 select whether to relax. Sometimes relaxing takes a lot of 130 time. The linker runs around the relocations to see if any 131 are attached to data which can be shrunk, if so it does it on 132 a link_order by link_order basis. 133 134*/ 135 136 137#include "bfd.h" 138#include "sysdep.h" 139#include "libbfd.h" 140 141 142/* 143DOCDD 144INODE 145typedef asection, section prototypes, Section Output, Sections 146SUBSECTION 147 typedef asection 148 149 Here is the section structure: 150 151CODE_FRAGMENT 152. 153.typedef struct sec 154.{ 155. {* The name of the section; the name isn't a copy, the pointer is 156. the same as that passed to bfd_make_section. *} 157. 158. CONST char *name; 159. 160. {* Which section is it; 0..nth. *} 161. 162. int index; 163. 164. {* The next section in the list belonging to the BFD, or NULL. *} 165. 166. struct sec *next; 167. 168. {* The field flags contains attributes of the section. Some 169. flags are read in from the object file, and some are 170. synthesized from other information. *} 171. 172. flagword flags; 173. 174.#define SEC_NO_FLAGS 0x000 175. 176. {* Tells the OS to allocate space for this section when loading. 177. This is clear for a section containing debug information 178. only. *} 179.#define SEC_ALLOC 0x001 180. 181. {* Tells the OS to load the section from the file when loading. 182. This is clear for a .bss section. *} 183.#define SEC_LOAD 0x002 184. 185. {* The section contains data still to be relocated, so there is 186. some relocation information too. *} 187.#define SEC_RELOC 0x004 188. 189.#if 0 {* Obsolete ? *} 190.#define SEC_BALIGN 0x008 191.#endif 192. 193. {* A signal to the OS that the section contains read only 194. data. *} 195.#define SEC_READONLY 0x010 196. 197. {* The section contains code only. *} 198.#define SEC_CODE 0x020 199. 200. {* The section contains data only. *} 201.#define SEC_DATA 0x040 202. 203. {* The section will reside in ROM. *} 204.#define SEC_ROM 0x080 205. 206. {* The section contains constructor information. This section 207. type is used by the linker to create lists of constructors and 208. destructors used by <<g++>>. When a back end sees a symbol 209. which should be used in a constructor list, it creates a new 210. section for the type of name (e.g., <<__CTOR_LIST__>>), attaches 211. the symbol to it, and builds a relocation. To build the lists 212. of constructors, all the linker has to do is catenate all the 213. sections called <<__CTOR_LIST__>> and relocate the data 214. contained within - exactly the operations it would peform on 215. standard data. *} 216.#define SEC_CONSTRUCTOR 0x100 217. 218. {* The section is a constuctor, and should be placed at the 219. end of the text, data, or bss section(?). *} 220.#define SEC_CONSTRUCTOR_TEXT 0x1100 221.#define SEC_CONSTRUCTOR_DATA 0x2100 222.#define SEC_CONSTRUCTOR_BSS 0x3100 223. 224. {* The section has contents - a data section could be 225. <<SEC_ALLOC>> | <<SEC_HAS_CONTENTS>>; a debug section could be 226. <<SEC_HAS_CONTENTS>> *} 227.#define SEC_HAS_CONTENTS 0x200 228. 229. {* An instruction to the linker to not output the section 230. even if it has information which would normally be written. *} 231.#define SEC_NEVER_LOAD 0x400 232. 233. {* The section is a COFF shared library section. This flag is 234. only for the linker. If this type of section appears in 235. the input file, the linker must copy it to the output file 236. without changing the vma or size. FIXME: Although this 237. was originally intended to be general, it really is COFF 238. specific (and the flag was renamed to indicate this). It 239. might be cleaner to have some more general mechanism to 240. allow the back end to control what the linker does with 241. sections. *} 242.#define SEC_COFF_SHARED_LIBRARY 0x800 243. 244. {* The section contains common symbols (symbols may be defined 245. multiple times, the value of a symbol is the amount of 246. space it requires, and the largest symbol value is the one 247. used). Most targets have exactly one of these (which we 248. translate to bfd_com_section_ptr), but ECOFF has two. *} 249.#define SEC_IS_COMMON 0x8000 250. 251. {* The section contains only debugging information. For 252. example, this is set for ELF .debug and .stab sections. 253. strip tests this flag to see if a section can be 254. discarded. *} 255.#define SEC_DEBUGGING 0x10000 256. 257. {* The contents of this section are held in memory pointed to 258. by the contents field. This is checked by 259. bfd_get_section_contents, and the data is retrieved from 260. memory if appropriate. *} 261.#define SEC_IN_MEMORY 0x20000 262. 263. {* The contents of this section are to be excluded by the 264. linker for executable and shared objects unless those 265. objects are to be further relocated. *} 266.#define SEC_EXCLUDE 0x40000 267. 268. {* The contents of this section are to be sorted by the 269. based on the address specified in the associated symbol 270. table. *} 271.#define SEC_SORT_ENTRIES 0x80000 272. 273. {* When linking, duplicate sections of the same name should be 274. discarded, rather than being combined into a single section as 275. is usually done. This is similar to how common symbols are 276. handled. See SEC_LINK_DUPLICATES below. *} 277.#define SEC_LINK_ONCE 0x100000 278. 279. {* If SEC_LINK_ONCE is set, this bitfield describes how the linker 280. should handle duplicate sections. *} 281.#define SEC_LINK_DUPLICATES 0x600000 282. 283. {* This value for SEC_LINK_DUPLICATES means that duplicate 284. sections with the same name should simply be discarded. *} 285.#define SEC_LINK_DUPLICATES_DISCARD 0x0 286. 287. {* This value for SEC_LINK_DUPLICATES means that the linker 288. should warn if there are any duplicate sections, although 289. it should still only link one copy. *} 290.#define SEC_LINK_DUPLICATES_ONE_ONLY 0x200000 291. 292. {* This value for SEC_LINK_DUPLICATES means that the linker 293. should warn if any duplicate sections are a different size. *} 294.#define SEC_LINK_DUPLICATES_SAME_SIZE 0x400000 295. 296. {* This value for SEC_LINK_DUPLICATES means that the linker 297. should warn if any duplicate sections contain different 298. contents. *} 299.#define SEC_LINK_DUPLICATES_SAME_CONTENTS 0x600000 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 0x800000 306. 307. {* End of section flags. *} 308. 309. {* Some internal packed boolean fields. *} 310. 311. {* See the vma field. *} 312. unsigned int user_set_vma : 1; 313. 314. {* Whether relocations have been processed. *} 315. unsigned int reloc_done : 1; 316. 317. {* A mark flag used by some of the linker backends. *} 318. unsigned int linker_mark : 1; 319. 320. {* End of internal packed boolean fields. *} 321. 322. {* The virtual memory address of the section - where it will be 323. at run time. The symbols are relocated against this. The 324. user_set_vma flag is maintained by bfd; if it's not set, the 325. backend can assign addresses (for example, in <<a.out>>, where 326. the default address for <<.data>> is dependent on the specific 327. target and various flags). *} 328. 329. bfd_vma vma; 330. 331. {* The load address of the section - where it would be in a 332. rom image; really only used for writing section header 333. information. *} 334. 335. bfd_vma lma; 336. 337. {* The size of the section in bytes, as it will be output. 338. contains a value even if the section has no contents (e.g., the 339. size of <<.bss>>). This will be filled in after relocation *} 340. 341. bfd_size_type _cooked_size; 342. 343. {* The original size on disk of the section, in bytes. Normally this 344. value is the same as the size, but if some relaxing has 345. been done, then this value will be bigger. *} 346. 347. bfd_size_type _raw_size; 348. 349. {* If this section is going to be output, then this value is the 350. offset into the output section of the first byte in the input 351. section. E.g., if this was going to start at the 100th byte in 352. the output section, this value would be 100. *} 353. 354. bfd_vma output_offset; 355. 356. {* The output section through which to map on output. *} 357. 358. struct sec *output_section; 359. 360. {* The alignment requirement of the section, as an exponent of 2 - 361. e.g., 3 aligns to 2^3 (or 8). *} 362. 363. unsigned int alignment_power; 364. 365. {* If an input section, a pointer to a vector of relocation 366. records for the data in this section. *} 367. 368. struct reloc_cache_entry *relocation; 369. 370. {* If an output section, a pointer to a vector of pointers to 371. relocation records for the data in this section. *} 372. 373. struct reloc_cache_entry **orelocation; 374. 375. {* The number of relocation records in one of the above *} 376. 377. unsigned reloc_count; 378. 379. {* Information below is back end specific - and not always used 380. or updated. *} 381. 382. {* File position of section data *} 383. 384. file_ptr filepos; 385. 386. {* File position of relocation info *} 387. 388. file_ptr rel_filepos; 389. 390. {* File position of line data *} 391. 392. file_ptr line_filepos; 393. 394. {* Pointer to data for applications *} 395. 396. PTR userdata; 397. 398. {* If the SEC_IN_MEMORY flag is set, this points to the actual 399. contents. *} 400. unsigned char *contents; 401. 402. {* Attached line number information *} 403. 404. alent *lineno; 405. 406. {* Number of line number records *} 407. 408. unsigned int lineno_count; 409. 410. {* When a section is being output, this value changes as more 411. linenumbers are written out *} 412. 413. file_ptr moving_line_filepos; 414. 415. {* What the section number is in the target world *} 416. 417. int target_index; 418. 419. PTR used_by_bfd; 420. 421. {* If this is a constructor section then here is a list of the 422. relocations created to relocate items within it. *} 423. 424. struct relent_chain *constructor_chain; 425. 426. {* The BFD which owns the section. *} 427. 428. bfd *owner; 429. 430. {* A symbol which points at this section only *} 431. struct symbol_cache_entry *symbol; 432. struct symbol_cache_entry **symbol_ptr_ptr; 433. 434. struct bfd_link_order *link_order_head; 435. struct bfd_link_order *link_order_tail; 436.} asection ; 437. 438. {* These sections are global, and are managed by BFD. The application 439. and target back end are not permitted to change the values in 440. these sections. New code should use the section_ptr macros rather 441. than referring directly to the const sections. The const sections 442. may eventually vanish. *} 443.#define BFD_ABS_SECTION_NAME "*ABS*" 444.#define BFD_UND_SECTION_NAME "*UND*" 445.#define BFD_COM_SECTION_NAME "*COM*" 446.#define BFD_IND_SECTION_NAME "*IND*" 447. 448. {* the absolute section *} 449.extern const asection bfd_abs_section; 450.#define bfd_abs_section_ptr ((asection *) &bfd_abs_section) 451.#define bfd_is_abs_section(sec) ((sec) == bfd_abs_section_ptr) 452. {* Pointer to the undefined section *} 453.extern const asection bfd_und_section; 454.#define bfd_und_section_ptr ((asection *) &bfd_und_section) 455.#define bfd_is_und_section(sec) ((sec) == bfd_und_section_ptr) 456. {* Pointer to the common section *} 457.extern const asection bfd_com_section; 458.#define bfd_com_section_ptr ((asection *) &bfd_com_section) 459. {* Pointer to the indirect section *} 460.extern const asection bfd_ind_section; 461.#define bfd_ind_section_ptr ((asection *) &bfd_ind_section) 462.#define bfd_is_ind_section(sec) ((sec) == bfd_ind_section_ptr) 463. 464.extern const struct symbol_cache_entry * const bfd_abs_symbol; 465.extern const struct symbol_cache_entry * const bfd_com_symbol; 466.extern const struct symbol_cache_entry * const bfd_und_symbol; 467.extern const struct symbol_cache_entry * const bfd_ind_symbol; 468.#define bfd_get_section_size_before_reloc(section) \ 469. (section->reloc_done ? (abort(),1): (section)->_raw_size) 470.#define bfd_get_section_size_after_reloc(section) \ 471. ((section->reloc_done) ? (section)->_cooked_size: (abort(),1)) 472*/ 473 474/* These symbols are global, not specific to any BFD. Therefore, anything 475 that tries to change them is broken, and should be repaired. */ 476static const asymbol global_syms[] = 477{ 478 /* the_bfd, name, value, attr, section [, udata] */ 479 {0, BFD_COM_SECTION_NAME, 0, BSF_SECTION_SYM, (asection *) &bfd_com_section}, 480 {0, BFD_UND_SECTION_NAME, 0, BSF_SECTION_SYM, (asection *) &bfd_und_section}, 481 {0, BFD_ABS_SECTION_NAME, 0, BSF_SECTION_SYM, (asection *) &bfd_abs_section}, 482 {0, BFD_IND_SECTION_NAME, 0, BSF_SECTION_SYM, (asection *) &bfd_ind_section}, 483}; 484 485#define STD_SECTION(SEC, FLAGS, SYM, NAME, IDX) \ 486 const asymbol * const SYM = (asymbol *) &global_syms[IDX]; \ 487 const asection SEC = \ 488 { NAME, 0, 0, FLAGS, 0, 0, 0, 0, 0, 0, 0, 0, (asection *) &SEC, \ 489 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \ 490 (asymbol *) &global_syms[IDX], (asymbol **) &SYM, 0, 0 } 491 492STD_SECTION (bfd_com_section, SEC_IS_COMMON, bfd_com_symbol, 493 BFD_COM_SECTION_NAME, 0); 494STD_SECTION (bfd_und_section, 0, bfd_und_symbol, BFD_UND_SECTION_NAME, 1); 495STD_SECTION (bfd_abs_section, 0, bfd_abs_symbol, BFD_ABS_SECTION_NAME, 2); 496STD_SECTION (bfd_ind_section, 0, bfd_ind_symbol, BFD_IND_SECTION_NAME, 3); 497#undef STD_SECTION 498 499/* 500DOCDD 501INODE 502section prototypes, , typedef asection, Sections 503SUBSECTION 504 Section prototypes 505 506These are the functions exported by the section handling part of BFD. 507*/ 508 509/* 510FUNCTION 511 bfd_get_section_by_name 512 513SYNOPSIS 514 asection *bfd_get_section_by_name(bfd *abfd, CONST char *name); 515 516DESCRIPTION 517 Run through @var{abfd} and return the one of the 518 <<asection>>s whose name matches @var{name}, otherwise <<NULL>>. 519 @xref{Sections}, for more information. 520 521 This should only be used in special cases; the normal way to process 522 all sections of a given name is to use <<bfd_map_over_sections>> and 523 <<strcmp>> on the name (or better yet, base it on the section flags 524 or something else) for each section. 525*/ 526 527asection * 528bfd_get_section_by_name (abfd, name) 529 bfd *abfd; 530 CONST char *name; 531{ 532 asection *sect; 533 534 for (sect = abfd->sections; sect != NULL; sect = sect->next) 535 if (!strcmp (sect->name, name)) 536 return sect; 537 return NULL; 538} 539 540 541/* 542FUNCTION 543 bfd_make_section_old_way 544 545SYNOPSIS 546 asection *bfd_make_section_old_way(bfd *abfd, CONST char *name); 547 548DESCRIPTION 549 Create a new empty section called @var{name} 550 and attach it to the end of the chain of sections for the 551 BFD @var{abfd}. An attempt to create a section with a name which 552 is already in use returns its pointer without changing the 553 section chain. 554 555 It has the funny name since this is the way it used to be 556 before it was rewritten.... 557 558 Possible errors are: 559 o <<bfd_error_invalid_operation>> - 560 If output has already started for this BFD. 561 o <<bfd_error_no_memory>> - 562 If memory allocation fails. 563 564*/ 565 566 567asection * 568bfd_make_section_old_way (abfd, name) 569 bfd *abfd; 570 CONST char *name; 571{ 572 asection *sec = bfd_get_section_by_name (abfd, name); 573 if (sec == (asection *) NULL) 574 { 575 sec = bfd_make_section (abfd, name); 576 } 577 return sec; 578} 579 580/* 581FUNCTION 582 bfd_make_section_anyway 583 584SYNOPSIS 585 asection *bfd_make_section_anyway(bfd *abfd, CONST char *name); 586 587DESCRIPTION 588 Create a new empty section called @var{name} and attach it to the end of 589 the chain of sections for @var{abfd}. Create a new section even if there 590 is already a section with that name. 591 592 Return <<NULL>> and set <<bfd_error>> on error; possible errors are: 593 o <<bfd_error_invalid_operation>> - If output has already started for @var{abfd}. 594 o <<bfd_error_no_memory>> - If memory allocation fails. 595*/ 596 597sec_ptr 598bfd_make_section_anyway (abfd, name) 599 bfd *abfd; 600 CONST char *name; 601{ 602 asection *newsect; 603 asection **prev = &abfd->sections; 604 asection *sect = abfd->sections; 605 606 if (abfd->output_has_begun) 607 { 608 bfd_set_error (bfd_error_invalid_operation); 609 return NULL; 610 } 611 612 while (sect) 613 { 614 prev = §->next; 615 sect = sect->next; 616 } 617 618 newsect = (asection *) bfd_zalloc (abfd, sizeof (asection)); 619 if (newsect == NULL) 620 return NULL; 621 622 newsect->name = name; 623 newsect->index = abfd->section_count++; 624 newsect->flags = SEC_NO_FLAGS; 625 626 newsect->userdata = NULL; 627 newsect->contents = NULL; 628 newsect->next = (asection *) NULL; 629 newsect->relocation = (arelent *) NULL; 630 newsect->reloc_count = 0; 631 newsect->line_filepos = 0; 632 newsect->owner = abfd; 633 634 /* Create a symbol whos only job is to point to this section. This is 635 useful for things like relocs which are relative to the base of a 636 section. */ 637 newsect->symbol = bfd_make_empty_symbol (abfd); 638 if (newsect->symbol == NULL) 639 return NULL; 640 newsect->symbol->name = name; 641 newsect->symbol->value = 0; 642 newsect->symbol->section = newsect; 643 newsect->symbol->flags = BSF_SECTION_SYM; 644 645 newsect->symbol_ptr_ptr = &newsect->symbol; 646 647 if (BFD_SEND (abfd, _new_section_hook, (abfd, newsect)) != true) 648 { 649 free (newsect); 650 return NULL; 651 } 652 653 *prev = newsect; 654 return newsect; 655} 656 657/* 658FUNCTION 659 bfd_make_section 660 661SYNOPSIS 662 asection *bfd_make_section(bfd *, CONST char *name); 663 664DESCRIPTION 665 Like <<bfd_make_section_anyway>>, but return <<NULL>> (without calling 666 bfd_set_error ()) without changing the section chain if there is already a 667 section named @var{name}. If there is an error, return <<NULL>> and set 668 <<bfd_error>>. 669*/ 670 671asection * 672bfd_make_section (abfd, name) 673 bfd *abfd; 674 CONST char *name; 675{ 676 asection *sect = abfd->sections; 677 678 if (strcmp (name, BFD_ABS_SECTION_NAME) == 0) 679 { 680 return bfd_abs_section_ptr; 681 } 682 if (strcmp (name, BFD_COM_SECTION_NAME) == 0) 683 { 684 return bfd_com_section_ptr; 685 } 686 if (strcmp (name, BFD_UND_SECTION_NAME) == 0) 687 { 688 return bfd_und_section_ptr; 689 } 690 691 if (strcmp (name, BFD_IND_SECTION_NAME) == 0) 692 { 693 return bfd_ind_section_ptr; 694 } 695 696 while (sect) 697 { 698 if (!strcmp (sect->name, name)) 699 return NULL; 700 sect = sect->next; 701 } 702 703 /* The name is not already used; go ahead and make a new section. */ 704 return bfd_make_section_anyway (abfd, name); 705} 706 707 708/* 709FUNCTION 710 bfd_set_section_flags 711 712SYNOPSIS 713 boolean bfd_set_section_flags(bfd *abfd, asection *sec, flagword flags); 714 715DESCRIPTION 716 Set the attributes of the section @var{sec} in the BFD 717 @var{abfd} to the value @var{flags}. Return <<true>> on success, 718 <<false>> on error. Possible error returns are: 719 720 o <<bfd_error_invalid_operation>> - 721 The section cannot have one or more of the attributes 722 requested. For example, a .bss section in <<a.out>> may not 723 have the <<SEC_HAS_CONTENTS>> field set. 724 725*/ 726 727/*ARGSUSED*/ 728boolean 729bfd_set_section_flags (abfd, section, flags) 730 bfd *abfd; 731 sec_ptr section; 732 flagword flags; 733{ 734#if 0 735 /* If you try to copy a text section from an input file (where it 736 has the SEC_CODE flag set) to an output file, this loses big if 737 the bfd_applicable_section_flags (abfd) doesn't have the SEC_CODE 738 set - which it doesn't, at least not for a.out. FIXME */ 739 740 if ((flags & bfd_applicable_section_flags (abfd)) != flags) 741 { 742 bfd_set_error (bfd_error_invalid_operation); 743 return false; 744 } 745#endif 746 747 section->flags = flags; 748 return true; 749} 750 751 752/* 753FUNCTION 754 bfd_map_over_sections 755 756SYNOPSIS 757 void bfd_map_over_sections(bfd *abfd, 758 void (*func)(bfd *abfd, 759 asection *sect, 760 PTR obj), 761 PTR obj); 762 763DESCRIPTION 764 Call the provided function @var{func} for each section 765 attached to the BFD @var{abfd}, passing @var{obj} as an 766 argument. The function will be called as if by 767 768| func(abfd, the_section, obj); 769 770 This is the prefered method for iterating over sections; an 771 alternative would be to use a loop: 772 773| section *p; 774| for (p = abfd->sections; p != NULL; p = p->next) 775| func(abfd, p, ...) 776 777 778*/ 779 780/*VARARGS2*/ 781void 782bfd_map_over_sections (abfd, operation, user_storage) 783 bfd *abfd; 784 void (*operation) PARAMS ((bfd * abfd, asection * sect, PTR obj)); 785 PTR user_storage; 786{ 787 asection *sect; 788 unsigned int i = 0; 789 790 for (sect = abfd->sections; sect != NULL; i++, sect = sect->next) 791 (*operation) (abfd, sect, user_storage); 792 793 if (i != abfd->section_count) /* Debugging */ 794 abort (); 795} 796 797 798/* 799FUNCTION 800 bfd_set_section_size 801 802SYNOPSIS 803 boolean bfd_set_section_size(bfd *abfd, asection *sec, bfd_size_type val); 804 805DESCRIPTION 806 Set @var{sec} to the size @var{val}. If the operation is 807 ok, then <<true>> is returned, else <<false>>. 808 809 Possible error returns: 810 o <<bfd_error_invalid_operation>> - 811 Writing has started to the BFD, so setting the size is invalid. 812 813*/ 814 815boolean 816bfd_set_section_size (abfd, ptr, val) 817 bfd *abfd; 818 sec_ptr ptr; 819 bfd_size_type val; 820{ 821 /* Once you've started writing to any section you cannot create or change 822 the size of any others. */ 823 824 if (abfd->output_has_begun) 825 { 826 bfd_set_error (bfd_error_invalid_operation); 827 return false; 828 } 829 830 ptr->_cooked_size = val; 831 ptr->_raw_size = val; 832 833 return true; 834} 835 836/* 837FUNCTION 838 bfd_set_section_contents 839 840SYNOPSIS 841 boolean bfd_set_section_contents 842 (bfd *abfd, 843 asection *section, 844 PTR data, 845 file_ptr offset, 846 bfd_size_type count); 847 848 849DESCRIPTION 850 Sets the contents of the section @var{section} in BFD 851 @var{abfd} to the data starting in memory at @var{data}. The 852 data is written to the output section starting at offset 853 @var{offset} for @var{count} bytes. 854 855 856 857 Normally <<true>> is returned, else <<false>>. Possible error 858 returns are: 859 o <<bfd_error_no_contents>> - 860 The output section does not have the <<SEC_HAS_CONTENTS>> 861 attribute, so nothing can be written to it. 862 o and some more too 863 864 This routine is front end to the back end function 865 <<_bfd_set_section_contents>>. 866 867 868*/ 869 870#define bfd_get_section_size_now(abfd,sec) \ 871(sec->reloc_done \ 872 ? bfd_get_section_size_after_reloc (sec) \ 873 : bfd_get_section_size_before_reloc (sec)) 874 875boolean 876bfd_set_section_contents (abfd, section, location, offset, count) 877 bfd *abfd; 878 sec_ptr section; 879 PTR location; 880 file_ptr offset; 881 bfd_size_type count; 882{ 883 bfd_size_type sz; 884 885 if (!(bfd_get_section_flags (abfd, section) & SEC_HAS_CONTENTS)) 886 { 887 bfd_set_error (bfd_error_no_contents); 888 return (false); 889 } 890 891 if (offset < 0) 892 { 893 bad_val: 894 bfd_set_error (bfd_error_bad_value); 895 return false; 896 } 897 sz = bfd_get_section_size_now (abfd, section); 898 if ((bfd_size_type) offset > sz 899 || count > sz 900 || offset + count > sz) 901 goto bad_val; 902 903 switch (abfd->direction) 904 { 905 case read_direction: 906 case no_direction: 907 bfd_set_error (bfd_error_invalid_operation); 908 return false; 909 910 case write_direction: 911 break; 912 913 case both_direction: 914 /* File is opened for update. `output_has_begun' some time ago when 915 the file was created. Do not recompute sections sizes or alignments 916 in _bfd_set_section_content. */ 917 abfd->output_has_begun = true; 918 break; 919 } 920 921 if (BFD_SEND (abfd, _bfd_set_section_contents, 922 (abfd, section, location, offset, count))) 923 { 924 abfd->output_has_begun = true; 925 return true; 926 } 927 928 return false; 929} 930 931/* 932FUNCTION 933 bfd_get_section_contents 934 935SYNOPSIS 936 boolean bfd_get_section_contents 937 (bfd *abfd, asection *section, PTR location, 938 file_ptr offset, bfd_size_type count); 939 940DESCRIPTION 941 Read data from @var{section} in BFD @var{abfd} 942 into memory starting at @var{location}. The data is read at an 943 offset of @var{offset} from the start of the input section, 944 and is read for @var{count} bytes. 945 946 If the contents of a constructor with the <<SEC_CONSTRUCTOR>> 947 flag set are requested or if the section does not have the 948 <<SEC_HAS_CONTENTS>> flag set, then the @var{location} is filled 949 with zeroes. If no errors occur, <<true>> is returned, else 950 <<false>>. 951 952 953 954*/ 955boolean 956bfd_get_section_contents (abfd, section, location, offset, count) 957 bfd *abfd; 958 sec_ptr section; 959 PTR location; 960 file_ptr offset; 961 bfd_size_type count; 962{ 963 bfd_size_type sz; 964 965 if (section->flags & SEC_CONSTRUCTOR) 966 { 967 memset (location, 0, (unsigned) count); 968 return true; 969 } 970 971 if (offset < 0) 972 { 973 bad_val: 974 bfd_set_error (bfd_error_bad_value); 975 return false; 976 } 977 /* Even if reloc_done is true, this function reads unrelocated 978 contents, so we want the raw size. */ 979 sz = section->_raw_size; 980 if ((bfd_size_type) offset > sz || count > sz || offset + count > sz) 981 goto bad_val; 982 983 if (count == 0) 984 /* Don't bother. */ 985 return true; 986 987 if ((section->flags & SEC_HAS_CONTENTS) == 0) 988 { 989 memset (location, 0, (unsigned) count); 990 return true; 991 } 992 993 if ((section->flags & SEC_IN_MEMORY) != 0) 994 { 995 memcpy (location, section->contents + offset, (size_t) count); 996 return true; 997 } 998 999 return BFD_SEND (abfd, _bfd_get_section_contents, 1000 (abfd, section, location, offset, count)); 1001} 1002 1003/* 1004FUNCTION 1005 bfd_copy_private_section_data 1006 1007SYNOPSIS 1008 boolean bfd_copy_private_section_data(bfd *ibfd, asection *isec, bfd *obfd, asection *osec); 1009 1010DESCRIPTION 1011 Copy private section information from @var{isec} in the BFD 1012 @var{ibfd} to the section @var{osec} in the BFD @var{obfd}. 1013 Return <<true>> on success, <<false>> on error. Possible error 1014 returns are: 1015 1016 o <<bfd_error_no_memory>> - 1017 Not enough memory exists to create private data for @var{osec}. 1018 1019.#define bfd_copy_private_section_data(ibfd, isection, obfd, osection) \ 1020. BFD_SEND (obfd, _bfd_copy_private_section_data, \ 1021. (ibfd, isection, obfd, osection)) 1022*/ 1023