X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=bfd%2Fsection.c;h=64636334ac9316e31894fa2abf5218091f2253d5;hb=65d20a7403f2a2a6b20572e007f43037306d2a09;hp=bff8adfb0784f62bfca35b111e8acad6555a18de;hpb=4e011fb578429f06c186a2910270d34ea4bb3c8e;p=external%2Fbinutils.git diff --git a/bfd/section.c b/bfd/section.c index bff8adf..6463633 100644 --- a/bfd/section.c +++ b/bfd/section.c @@ -1,7 +1,5 @@ /* Object file "section" support for the BFD library. - Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, - 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 - Free Software Foundation, Inc. + Copyright (C) 1990-2019 Free Software Foundation, Inc. Written by Cygnus Support. This file is part of BFD, the Binary File Descriptor library. @@ -67,10 +65,7 @@ SUBSECTION data in place until a <> call is made. Other back ends may read in all the data at once. For example, an S-record file has to be read once to determine the - size of the data. An IEEE-695 file doesn't contain raw data in - sections, but data and relocation expressions intermixed, so - the data area has to be parsed to get out the data and - relocations. + size of the data. INODE Section Output, typedef asection, Section Input, Sections @@ -157,10 +152,10 @@ CODE_FRAGMENT . const char *name; . . {* A unique sequence number. *} -. int id; +. unsigned int id; . . {* Which section in the bfd; 0..n-1 as sections are created in a bfd. *} -. int index; +. unsigned int index; . . {* The next section in the list belonging to the BFD, or NULL. *} . struct bfd_section *next; @@ -173,31 +168,31 @@ CODE_FRAGMENT . synthesized from other information. *} . flagword flags; . -.#define SEC_NO_FLAGS 0x000 +.#define SEC_NO_FLAGS 0x0 . . {* Tells the OS to allocate space for this section when loading. . This is clear for a section containing debug information only. *} -.#define SEC_ALLOC 0x001 +.#define SEC_ALLOC 0x1 . . {* Tells the OS to load the section from the file when loading. . This is clear for a .bss section. *} -.#define SEC_LOAD 0x002 +.#define SEC_LOAD 0x2 . . {* The section contains data still to be relocated, so there is . some relocation information too. *} -.#define SEC_RELOC 0x004 +.#define SEC_RELOC 0x4 . . {* A signal to the OS that the section contains read only data. *} -.#define SEC_READONLY 0x008 +.#define SEC_READONLY 0x8 . . {* The section contains code only. *} -.#define SEC_CODE 0x010 +.#define SEC_CODE 0x10 . . {* The section contains data only. *} -.#define SEC_DATA 0x020 +.#define SEC_DATA 0x20 . . {* The section will reside in ROM. *} -.#define SEC_ROM 0x040 +.#define SEC_ROM 0x40 . . {* The section contains constructor information. This section . type is used by the linker to create lists of constructors and @@ -209,75 +204,72 @@ CODE_FRAGMENT . sections called <<__CTOR_LIST__>> and relocate the data . contained within - exactly the operations it would peform on . standard data. *} -.#define SEC_CONSTRUCTOR 0x080 +.#define SEC_CONSTRUCTOR 0x80 . . {* The section has contents - a data section could be . <> | <>; a debug section could be . <> *} -.#define SEC_HAS_CONTENTS 0x100 +.#define SEC_HAS_CONTENTS 0x100 . . {* An instruction to the linker to not output the section . even if it has information which would normally be written. *} -.#define SEC_NEVER_LOAD 0x200 +.#define SEC_NEVER_LOAD 0x200 . . {* The section contains thread local data. *} -.#define SEC_THREAD_LOCAL 0x400 +.#define SEC_THREAD_LOCAL 0x400 . -. {* The section has GOT references. This flag is only for the -. linker, and is currently only used by the elf32-hppa back end. -. It will be set if global offset table references were detected -. in this section, which indicate to the linker that the section -. contains PIC code, and must be handled specially when doing a -. static link. *} -.#define SEC_HAS_GOT_REF 0x800 +. {* The section's size is fixed. Generic linker code will not +. recalculate it and it is up to whoever has set this flag to +. get the size right. *} +.#define SEC_FIXED_SIZE 0x800 . . {* The section contains common symbols (symbols may be defined . multiple times, the value of a symbol is the amount of . space it requires, and the largest symbol value is the one . used). Most targets have exactly one of these (which we . translate to bfd_com_section_ptr), but ECOFF has two. *} -.#define SEC_IS_COMMON 0x1000 +.#define SEC_IS_COMMON 0x1000 . . {* The section contains only debugging information. For . example, this is set for ELF .debug and .stab sections. . strip tests this flag to see if a section can be . discarded. *} -.#define SEC_DEBUGGING 0x2000 +.#define SEC_DEBUGGING 0x2000 . . {* The contents of this section are held in memory pointed to . by the contents field. This is checked by bfd_get_section_contents, . and the data is retrieved from memory if appropriate. *} -.#define SEC_IN_MEMORY 0x4000 +.#define SEC_IN_MEMORY 0x4000 . . {* The contents of this section are to be excluded by the . linker for executable and shared objects unless those . objects are to be further relocated. *} -.#define SEC_EXCLUDE 0x8000 +.#define SEC_EXCLUDE 0x8000 . . {* The contents of this section are to be sorted based on the sum of . the symbol and addend values specified by the associated relocation . entries. Entries without associated relocation entries will be . appended to the end of the section in an unspecified order. *} -.#define SEC_SORT_ENTRIES 0x10000 +.#define SEC_SORT_ENTRIES 0x10000 . . {* When linking, duplicate sections of the same name should be . discarded, rather than being combined into a single section as . is usually done. This is similar to how common symbols are . handled. See SEC_LINK_DUPLICATES below. *} -.#define SEC_LINK_ONCE 0x20000 +.#define SEC_LINK_ONCE 0x20000 . . {* If SEC_LINK_ONCE is set, this bitfield describes how the linker . should handle duplicate sections. *} -.#define SEC_LINK_DUPLICATES 0xc0000 +.#define SEC_LINK_DUPLICATES 0xc0000 . . {* This value for SEC_LINK_DUPLICATES means that duplicate . sections with the same name should simply be discarded. *} -.#define SEC_LINK_DUPLICATES_DISCARD 0x0 +.#define SEC_LINK_DUPLICATES_DISCARD 0x0 . . {* This value for SEC_LINK_DUPLICATES means that the linker . should warn if there are any duplicate sections, although . it should still only link one copy. *} -.#define SEC_LINK_DUPLICATES_ONE_ONLY 0x40000 +.#define SEC_LINK_DUPLICATES_ONE_ONLY 0x40000 . . {* This value for SEC_LINK_DUPLICATES means that the linker . should warn if any duplicate sections are a different size. *} @@ -293,28 +285,28 @@ CODE_FRAGMENT . relocation or other arcane processing. It is skipped when . going through the first-pass output, trusting that someone . else up the line will take care of it later. *} -.#define SEC_LINKER_CREATED 0x100000 +.#define SEC_LINKER_CREATED 0x100000 . . {* This section should not be subject to garbage collection. . Also set to inform the linker that this section should not be . listed in the link map as discarded. *} -.#define SEC_KEEP 0x200000 +.#define SEC_KEEP 0x200000 . . {* This section contains "short" data, and should be placed . "near" the GP. *} -.#define SEC_SMALL_DATA 0x400000 +.#define SEC_SMALL_DATA 0x400000 . . {* Attempt to merge identical entities in the section. . Entity size is given in the entsize field. *} -.#define SEC_MERGE 0x800000 +.#define SEC_MERGE 0x800000 . . {* If given with SEC_MERGE, entities to merge are zero terminated . strings where entsize specifies character size instead of fixed . size entries. *} -.#define SEC_STRINGS 0x1000000 +.#define SEC_STRINGS 0x1000000 . . {* This section contains data about section groups. *} -.#define SEC_GROUP 0x2000000 +.#define SEC_GROUP 0x2000000 . . {* The section is a COFF shared library section. This flag is . only for the linker. If this type of section appears in @@ -325,27 +317,46 @@ CODE_FRAGMENT . might be cleaner to have some more general mechanism to . allow the back end to control what the linker does with . sections. *} -.#define SEC_COFF_SHARED_LIBRARY 0x4000000 +.#define SEC_COFF_SHARED_LIBRARY 0x4000000 +. +. {* This input section should be copied to output in reverse order +. as an array of pointers. This is for ELF linker internal use +. only. *} +.#define SEC_ELF_REVERSE_COPY 0x4000000 . . {* This section contains data which may be shared with other . executables or shared objects. This is for COFF only. *} -.#define SEC_COFF_SHARED 0x8000000 +.#define SEC_COFF_SHARED 0x8000000 +. +. {* This section should be compressed. This is for ELF linker +. internal use only. *} +.#define SEC_ELF_COMPRESS 0x8000000 . . {* When a section with this flag is being linked, then if the size of . the input section is less than a page, it should not cross a page . boundary. If the size of the input section is one page or more, . it should be aligned on a page boundary. This is for TI . TMS320C54X only. *} -.#define SEC_TIC54X_BLOCK 0x10000000 +.#define SEC_TIC54X_BLOCK 0x10000000 +. +. {* This section should be renamed. This is for ELF linker +. internal use only. *} +.#define SEC_ELF_RENAME 0x10000000 . . {* Conditionally link this section; do not link if there are no . references found to any symbol in the section. This is for TI . TMS320C54X only. *} -.#define SEC_TIC54X_CLINK 0x20000000 +.#define SEC_TIC54X_CLINK 0x20000000 +. +. {* This section contains vliw code. This is for Toshiba MeP only. *} +.#define SEC_MEP_VLIW 0x20000000 . . {* Indicate that section has the no read flag set. This happens . when memory read flag isn't set. *} -.#define SEC_COFF_NOREAD 0x40000000 +.#define SEC_COFF_NOREAD 0x40000000 +. +. {* Indicate that section has the purecode flag set. *} +.#define SEC_ELF_PURECODE 0x80000000 . . {* End of section flags. *} . @@ -377,11 +388,13 @@ CODE_FRAGMENT . . {* Type of sec_info information. *} . unsigned int sec_info_type:3; -.#define ELF_INFO_TYPE_NONE 0 -.#define ELF_INFO_TYPE_STABS 1 -.#define ELF_INFO_TYPE_MERGE 2 -.#define ELF_INFO_TYPE_EH_FRAME 3 -.#define ELF_INFO_TYPE_JUST_SYMS 4 +.#define SEC_INFO_TYPE_NONE 0 +.#define SEC_INFO_TYPE_STABS 1 +.#define SEC_INFO_TYPE_MERGE 2 +.#define SEC_INFO_TYPE_EH_FRAME 3 +.#define SEC_INFO_TYPE_JUST_SYMS 4 +.#define SEC_INFO_TYPE_TARGET 5 +.#define SEC_INFO_TYPE_EH_FRAME_ENTRY 6 . . {* Nonzero if this section uses RELA relocations, rather than REL. *} . unsigned int use_rela_p:1; @@ -411,7 +424,7 @@ CODE_FRAGMENT . information. *} . bfd_vma lma; . -. {* The size of the section in octets, as it will be output. +. {* The size of the section in *octets*, as it will be output. . Contains a value even if the section has no contents (e.g., the . size of <<.bss>>). *} . bfd_size_type size; @@ -526,40 +539,65 @@ CODE_FRAGMENT .} asection; . .{* Relax table contains information about instructions which can -. be removed by relaxation -- replacing a long address with a +. be removed by relaxation -- replacing a long address with a . short address. *} .struct relax_table { . {* Address where bytes may be deleted. *} . bfd_vma addr; -. +. . {* Number of bytes to be deleted. *} . int size; .}; . +.{* Note: the following are provided as inline functions rather than macros +. because not all callers use the return value. A macro implementation +. would use a comma expression, eg: "((ptr)->foo = val, TRUE)" and some +. compilers will complain about comma expressions that have no effect. *} +.static inline bfd_boolean +.bfd_set_section_userdata (bfd * abfd ATTRIBUTE_UNUSED, asection * ptr, +. void * val) +.{ +. ptr->userdata = val; +. return TRUE; +.} +. +.static inline bfd_boolean +.bfd_set_section_vma (bfd * abfd ATTRIBUTE_UNUSED, asection * ptr, bfd_vma val) +.{ +. ptr->vma = ptr->lma = val; +. ptr->user_set_vma = TRUE; +. return TRUE; +.} +. +.static inline bfd_boolean +.bfd_set_section_alignment (bfd * abfd ATTRIBUTE_UNUSED, asection * ptr, +. unsigned int val) +.{ +. ptr->alignment_power = val; +. return TRUE; +.} +. .{* These sections are global, and are managed by BFD. The application . and target back end are not permitted to change the values in -. these sections. New code should use the section_ptr macros rather -. than referring directly to the const sections. The const sections -. may eventually vanish. *} +. these sections. *} +.extern asection _bfd_std_section[4]; +. .#define BFD_ABS_SECTION_NAME "*ABS*" .#define BFD_UND_SECTION_NAME "*UND*" .#define BFD_COM_SECTION_NAME "*COM*" .#define BFD_IND_SECTION_NAME "*IND*" . -.{* The absolute section. *} -.extern asection bfd_abs_section; -.#define bfd_abs_section_ptr ((asection *) &bfd_abs_section) -.#define bfd_is_abs_section(sec) ((sec) == bfd_abs_section_ptr) -.{* Pointer to the undefined section. *} -.extern asection bfd_und_section; -.#define bfd_und_section_ptr ((asection *) &bfd_und_section) -.#define bfd_is_und_section(sec) ((sec) == bfd_und_section_ptr) .{* Pointer to the common section. *} -.extern asection bfd_com_section; -.#define bfd_com_section_ptr ((asection *) &bfd_com_section) +.#define bfd_com_section_ptr (&_bfd_std_section[0]) +.{* Pointer to the undefined section. *} +.#define bfd_und_section_ptr (&_bfd_std_section[1]) +.{* Pointer to the absolute section. *} +.#define bfd_abs_section_ptr (&_bfd_std_section[2]) .{* Pointer to the indirect section. *} -.extern asection bfd_ind_section; -.#define bfd_ind_section_ptr ((asection *) &bfd_ind_section) +.#define bfd_ind_section_ptr (&_bfd_std_section[3]) +. +.#define bfd_is_und_section(sec) ((sec) == bfd_und_section_ptr) +.#define bfd_is_abs_section(sec) ((sec) == bfd_abs_section_ptr) .#define bfd_is_ind_section(sec) ((sec) == bfd_ind_section_ptr) . .#define bfd_is_const_section(SEC) \ @@ -658,9 +696,9 @@ CODE_FRAGMENT .#define bfd_section_removed_from_list(ABFD, S) \ . ((S)->next == NULL ? (ABFD)->section_last != (S) : (S)->next->prev != (S)) . -.#define BFD_FAKE_SECTION(SEC, FLAGS, SYM, NAME, IDX) \ +.#define BFD_FAKE_SECTION(SEC, SYM, NAME, IDX, FLAGS) \ . {* name, id, index, next, prev, flags, user_set_vma, *} \ -. { NAME, IDX, 0, NULL, NULL, FLAGS, 0, \ +. { NAME, IDX, 0, NULL, NULL, FLAGS, 0, \ . \ . {* linker_mark, linker_has_input, gc_mark, decompress_status, *} \ . 0, 0, 1, 0, \ @@ -674,8 +712,8 @@ CODE_FRAGMENT . {* vma, lma, size, rawsize, compressed_size, relax, relax_count, *} \ . 0, 0, 0, 0, 0, 0, 0, \ . \ -. {* output_offset, output_section, alignment_power, *} \ -. 0, (struct bfd_section *) &SEC, 0, \ +. {* output_offset, output_section, alignment_power, *} \ +. 0, &SEC, 0, \ . \ . {* relocation, orelocation, reloc_count, filepos, rel_filepos, *} \ . NULL, NULL, 0, 0, 0, \ @@ -696,39 +734,40 @@ CODE_FRAGMENT . { NULL }, { NULL } \ . } . +.{* We use a macro to initialize the static asymbol structures because +. traditional C does not permit us to initialize a union member while +. gcc warns if we don't initialize it. +. the_bfd, name, value, attr, section [, udata] *} +.#ifdef __STDC__ +.#define GLOBAL_SYM_INIT(NAME, SECTION) \ +. { 0, NAME, 0, BSF_SECTION_SYM, SECTION, { 0 }} +.#else +.#define GLOBAL_SYM_INIT(NAME, SECTION) \ +. { 0, NAME, 0, BSF_SECTION_SYM, SECTION } +.#endif +. */ -/* We use a macro to initialize the static asymbol structures because - traditional C does not permit us to initialize a union member while - gcc warns if we don't initialize it. */ - /* the_bfd, name, value, attr, section [, udata] */ -#ifdef __STDC__ -#define GLOBAL_SYM_INIT(NAME, SECTION) \ - { 0, NAME, 0, BSF_SECTION_SYM, (asection *) SECTION, { 0 }} -#else -#define GLOBAL_SYM_INIT(NAME, SECTION) \ - { 0, NAME, 0, BSF_SECTION_SYM, (asection *) SECTION } -#endif - /* These symbols are global, not specific to any BFD. Therefore, anything that tries to change them is broken, and should be repaired. */ static const asymbol global_syms[] = { - GLOBAL_SYM_INIT (BFD_COM_SECTION_NAME, &bfd_com_section), - GLOBAL_SYM_INIT (BFD_UND_SECTION_NAME, &bfd_und_section), - GLOBAL_SYM_INIT (BFD_ABS_SECTION_NAME, &bfd_abs_section), - GLOBAL_SYM_INIT (BFD_IND_SECTION_NAME, &bfd_ind_section) + GLOBAL_SYM_INIT (BFD_COM_SECTION_NAME, bfd_com_section_ptr), + GLOBAL_SYM_INIT (BFD_UND_SECTION_NAME, bfd_und_section_ptr), + GLOBAL_SYM_INIT (BFD_ABS_SECTION_NAME, bfd_abs_section_ptr), + GLOBAL_SYM_INIT (BFD_IND_SECTION_NAME, bfd_ind_section_ptr) }; -#define STD_SECTION(SEC, FLAGS, NAME, IDX) \ - asection SEC = BFD_FAKE_SECTION(SEC, FLAGS, &global_syms[IDX], \ - NAME, IDX) +#define STD_SECTION(NAME, IDX, FLAGS) \ + BFD_FAKE_SECTION(_bfd_std_section[IDX], &global_syms[IDX], NAME, IDX, FLAGS) -STD_SECTION (bfd_com_section, SEC_IS_COMMON, BFD_COM_SECTION_NAME, 0); -STD_SECTION (bfd_und_section, 0, BFD_UND_SECTION_NAME, 1); -STD_SECTION (bfd_abs_section, 0, BFD_ABS_SECTION_NAME, 2); -STD_SECTION (bfd_ind_section, 0, BFD_IND_SECTION_NAME, 3); +asection _bfd_std_section[] = { + STD_SECTION (BFD_COM_SECTION_NAME, 0, SEC_IS_COMMON), + STD_SECTION (BFD_UND_SECTION_NAME, 1, 0), + STD_SECTION (BFD_ABS_SECTION_NAME, 2, 0), + STD_SECTION (BFD_IND_SECTION_NAME, 3, 0) +}; #undef STD_SECTION /* Initialize an entry in the section hash table. */ @@ -781,21 +820,21 @@ _bfd_generic_new_section_hook (bfd *abfd, asection *newsect) return TRUE; } +unsigned int _bfd_section_id = 0x10; /* id 0 to 3 used by STD_SECTION. */ + /* Initializes a new section. NEWSECT->NAME is already set. */ static asection * bfd_section_init (bfd *abfd, asection *newsect) { - static int section_id = 0x10; /* id 0 to 3 used by STD_SECTION. */ - - newsect->id = section_id; + newsect->id = _bfd_section_id; newsect->index = abfd->section_count; newsect->owner = abfd; if (! BFD_SEND (abfd, _new_section_hook, (abfd, newsect))) return NULL; - section_id++; + _bfd_section_id++; abfd->section_count++; bfd_section_list_append (abfd, newsect); return newsect; @@ -831,6 +870,7 @@ bfd_section_list_clear (bfd *abfd) abfd->section_count = 0; memset (abfd->section_htab.table, 0, abfd->section_htab.size * sizeof (struct bfd_hash_entry *)); + abfd->section_htab.count = 0; } /* @@ -841,14 +881,8 @@ SYNOPSIS asection *bfd_get_section_by_name (bfd *abfd, const char *name); DESCRIPTION - Run through @var{abfd} and return the one of the - <>s whose name matches @var{name}, otherwise <>. - @xref{Sections}, for more information. - - This should only be used in special cases; the normal way to process - all sections of a given name is to use <> and - <> on the name (or better yet, base it on the section flags - or something else) for each section. + Return the most recently created section attached to @var{abfd} + named @var{name}. Return NULL if no such section exists. */ asection * @@ -865,6 +899,75 @@ bfd_get_section_by_name (bfd *abfd, const char *name) /* FUNCTION + bfd_get_next_section_by_name + +SYNOPSIS + asection *bfd_get_next_section_by_name (bfd *ibfd, asection *sec); + +DESCRIPTION + Given @var{sec} is a section returned by @code{bfd_get_section_by_name}, + return the next most recently created section attached to the same + BFD with the same name, or if no such section exists in the same BFD and + IBFD is non-NULL, the next section with the same name in any input + BFD following IBFD. Return NULL on finding no section. +*/ + +asection * +bfd_get_next_section_by_name (bfd *ibfd, asection *sec) +{ + struct section_hash_entry *sh; + const char *name; + unsigned long hash; + + sh = ((struct section_hash_entry *) + ((char *) sec - offsetof (struct section_hash_entry, section))); + + hash = sh->root.hash; + name = sec->name; + for (sh = (struct section_hash_entry *) sh->root.next; + sh != NULL; + sh = (struct section_hash_entry *) sh->root.next) + if (sh->root.hash == hash + && strcmp (sh->root.string, name) == 0) + return &sh->section; + + if (ibfd != NULL) + { + while ((ibfd = ibfd->link.next) != NULL) + { + asection *s = bfd_get_section_by_name (ibfd, name); + if (s != NULL) + return s; + } + } + + return NULL; +} + +/* +FUNCTION + bfd_get_linker_section + +SYNOPSIS + asection *bfd_get_linker_section (bfd *abfd, const char *name); + +DESCRIPTION + Return the linker created section attached to @var{abfd} + named @var{name}. Return NULL if no such section exists. +*/ + +asection * +bfd_get_linker_section (bfd *abfd, const char *name) +{ + asection *sec = bfd_get_section_by_name (abfd, name); + + while (sec != NULL && (sec->flags & SEC_LINKER_CREATED) == 0) + sec = bfd_get_next_section_by_name (NULL, sec); + return sec; +} + +/* +FUNCTION bfd_get_section_by_name_if SYNOPSIS @@ -902,14 +1005,11 @@ bfd_get_section_by_name_if (bfd *abfd, const char *name, return NULL; hash = sh->root.hash; - do - { - if ((*operation) (abfd, &sh->section, user_storage)) - return &sh->section; - sh = (struct section_hash_entry *) sh->root.next; - } - while (sh != NULL && sh->root.hash == hash - && strcmp (sh->root.string, name) == 0); + for (; sh != NULL; sh = (struct section_hash_entry *) sh->root.next) + if (sh->root.hash == hash + && strcmp (sh->root.string, name) == 0 + && (*operation) (abfd, &sh->section, user_storage)) + return &sh->section; return NULL; } @@ -1136,7 +1236,7 @@ bfd_make_section_with_flags (bfd *abfd, const char *name, struct section_hash_entry *sh; asection *newsect; - if (abfd->output_has_begun) + if (abfd == NULL || name == NULL || abfd->output_has_begun) { bfd_set_error (bfd_error_invalid_operation); return NULL; @@ -1256,7 +1356,7 @@ DESCRIPTION This is the preferred method for iterating over sections; an alternative would be to use a loop: -| section *p; +| asection *p; | for (p = abfd->sections; p != NULL; p = p->next) | func (abfd, p, ...) @@ -1357,16 +1457,20 @@ SYNOPSIS DESCRIPTION Sets the contents of the section @var{section} in BFD - @var{abfd} to the data starting in memory at @var{data}. The - data is written to the output section starting at offset + @var{abfd} to the data starting in memory at @var{location}. + The data is written to the output section starting at offset @var{offset} for @var{count} octets. - Normally <> is returned, else <>. Possible error - returns are: + Normally <> is returned, but <> is returned if + there was an error. Possible error returns are: o <> - The output section does not have the <> attribute, so nothing can be written to it. - o and some more too + o <> - + The section is unable to contain all of the data. + o <> - + The BFD is not writeable. + o and some more too. This routine is front end to the back end function <<_bfd_set_section_contents>>. @@ -1456,7 +1560,10 @@ bfd_get_section_contents (bfd *abfd, return TRUE; } - sz = section->rawsize ? section->rawsize : section->size; + if (abfd->direction != write_direction && section->rawsize != 0) + sz = section->rawsize; + else + sz = section->size; if ((bfd_size_type) offset > sz || count > sz || offset + count > sz @@ -1487,8 +1594,8 @@ bfd_get_section_contents (bfd *abfd, bfd_set_error (bfd_error_invalid_operation); return FALSE; } - - memcpy (location, section->contents + offset, (size_t) count); + + memmove (location, section->contents + offset, (size_t) count); return TRUE; } @@ -1533,8 +1640,8 @@ DESCRIPTION Not enough memory exists to create private data for @var{osec}. .#define bfd_copy_private_section_data(ibfd, isection, obfd, osection) \ -. BFD_SEND (obfd, _bfd_copy_private_section_data, \ -. (ibfd, isection, obfd, osection)) +. BFD_SEND (obfd, _bfd_copy_private_section_data, \ +. (ibfd, isection, obfd, osection)) */ /* @@ -1572,3 +1679,13 @@ bfd_generic_discard_group (bfd *abfd ATTRIBUTE_UNUSED, { return TRUE; } + +bfd_boolean +_bfd_nowrite_set_section_contents (bfd *abfd, + sec_ptr section ATTRIBUTE_UNUSED, + const void *location ATTRIBUTE_UNUSED, + file_ptr offset ATTRIBUTE_UNUSED, + bfd_size_type count ATTRIBUTE_UNUSED) +{ + return _bfd_bool_bfd_false_error (abfd); +}