| <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd"> |
| <html> |
| <!-- This file documents the BFD library. |
| |
| Copyright (C) 1991 - 2013 Free Software Foundation, Inc. |
| |
| Permission is granted to copy, distribute and/or modify this document |
| under the terms of the GNU Free Documentation License, Version 1.3 or |
| any later version published by the Free Software Foundation; with the |
| Invariant Sections being "GNU General Public License" and "Funding |
| Free Software", the Front-Cover texts being (a) (see below), and with |
| the Back-Cover Texts being (b) (see below). A copy of the license is |
| included in the section entitled "GNU Free Documentation License". |
| |
| (a) The FSF's Front-Cover Text is: |
| |
| A GNU Manual |
| |
| (b) The FSF's Back-Cover Text is: |
| |
| You have freedom to copy and modify this GNU Manual, like GNU |
| software. Copies published by the Free Software Foundation raise |
| funds for GNU development. --> |
| <!-- Created by GNU Texinfo 5.2, http://www.gnu.org/software/texinfo/ --> |
| <head> |
| <title>Untitled Document: typedef asection</title> |
| |
| <meta name="description" content="Untitled Document: typedef asection"> |
| <meta name="keywords" content="Untitled Document: typedef asection"> |
| <meta name="resource-type" content="document"> |
| <meta name="distribution" content="global"> |
| <meta name="Generator" content="makeinfo"> |
| <meta http-equiv="Content-Type" content="text/html; charset=utf-8"> |
| <link href="index.html#Top" rel="start" title="Top"> |
| <link href="BFD-Index.html#BFD-Index" rel="index" title="BFD Index"> |
| <link href="index.html#SEC_Contents" rel="contents" title="Table of Contents"> |
| <link href="Sections.html#Sections" rel="up" title="Sections"> |
| <link href="section-prototypes.html#section-prototypes" rel="next" title="section prototypes"> |
| <link href="Section-Output.html#Section-Output" rel="prev" title="Section Output"> |
| <style type="text/css"> |
| <!-- |
| a.summary-letter {text-decoration: none} |
| blockquote.smallquotation {font-size: smaller} |
| div.display {margin-left: 3.2em} |
| div.example {margin-left: 3.2em} |
| div.indentedblock {margin-left: 3.2em} |
| div.lisp {margin-left: 3.2em} |
| div.smalldisplay {margin-left: 3.2em} |
| div.smallexample {margin-left: 3.2em} |
| div.smallindentedblock {margin-left: 3.2em; font-size: smaller} |
| div.smalllisp {margin-left: 3.2em} |
| kbd {font-style:oblique} |
| pre.display {font-family: inherit} |
| pre.format {font-family: inherit} |
| pre.menu-comment {font-family: serif} |
| pre.menu-preformatted {font-family: serif} |
| pre.smalldisplay {font-family: inherit; font-size: smaller} |
| pre.smallexample {font-size: smaller} |
| pre.smallformat {font-family: inherit; font-size: smaller} |
| pre.smalllisp {font-size: smaller} |
| span.nocodebreak {white-space:nowrap} |
| span.nolinebreak {white-space:nowrap} |
| span.roman {font-family:serif; font-weight:normal} |
| span.sansserif {font-family:sans-serif; font-weight:normal} |
| ul.no-bullet {list-style: none} |
| --> |
| </style> |
| |
| |
| </head> |
| |
| <body lang="en" bgcolor="#FFFFFF" text="#000000" link="#0000FF" vlink="#800080" alink="#FF0000"> |
| <a name="typedef-asection"></a> |
| <div class="header"> |
| <p> |
| Next: <a href="section-prototypes.html#section-prototypes" accesskey="n" rel="next">section prototypes</a>, Previous: <a href="Section-Output.html#Section-Output" accesskey="p" rel="prev">Section Output</a>, Up: <a href="Sections.html#Sections" accesskey="u" rel="up">Sections</a> [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="BFD-Index.html#BFD-Index" title="Index" rel="index">Index</a>]</p> |
| </div> |
| <hr> |
| <a name="typedef-asection-1"></a> |
| <h4 class="subsection">2.6.4 typedef asection</h4> |
| <p>Here is the section structure: |
| </p> |
| |
| <div class="example"> |
| <pre class="example"> |
| typedef struct bfd_section |
| { |
| /* The name of the section; the name isn't a copy, the pointer is |
| the same as that passed to bfd_make_section. */ |
| const char *name; |
| |
| /* A unique sequence number. */ |
| int id; |
| |
| /* Which section in the bfd; 0..n-1 as sections are created in a bfd. */ |
| int index; |
| |
| /* The next section in the list belonging to the BFD, or NULL. */ |
| struct bfd_section *next; |
| |
| /* The previous section in the list belonging to the BFD, or NULL. */ |
| struct bfd_section *prev; |
| |
| /* The field flags contains attributes of the section. Some |
| flags are read in from the object file, and some are |
| synthesized from other information. */ |
| flagword flags; |
| |
| #define SEC_NO_FLAGS 0x000 |
| |
| /* 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 |
| |
| /* Tells the OS to load the section from the file when loading. |
| This is clear for a .bss section. */ |
| #define SEC_LOAD 0x002 |
| |
| /* The section contains data still to be relocated, so there is |
| some relocation information too. */ |
| #define SEC_RELOC 0x004 |
| |
| /* A signal to the OS that the section contains read only data. */ |
| #define SEC_READONLY 0x008 |
| |
| /* The section contains code only. */ |
| #define SEC_CODE 0x010 |
| |
| /* The section contains data only. */ |
| #define SEC_DATA 0x020 |
| |
| /* The section will reside in ROM. */ |
| #define SEC_ROM 0x040 |
| |
| /* The section contains constructor information. This section |
| type is used by the linker to create lists of constructors and |
| destructors used by <code>g++</code>. When a back end sees a symbol |
| which should be used in a constructor list, it creates a new |
| section for the type of name (e.g., <code>__CTOR_LIST__</code>), attaches |
| the symbol to it, and builds a relocation. To build the lists |
| of constructors, all the linker has to do is catenate all the |
| sections called <code>__CTOR_LIST__</code> and relocate the data |
| contained within - exactly the operations it would peform on |
| standard data. */ |
| #define SEC_CONSTRUCTOR 0x080 |
| |
| /* The section has contents - a data section could be |
| <code>SEC_ALLOC</code> | <code>SEC_HAS_CONTENTS</code>; a debug section could be |
| <code>SEC_HAS_CONTENTS</code> */ |
| #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 |
| |
| /* The section contains thread local data. */ |
| #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 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 |
| |
| /* 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 |
| |
| /* 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 |
| |
| /* 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 |
| |
| /* 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 |
| |
| /* 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 |
| |
| /* If SEC_LINK_ONCE is set, this bitfield describes how the linker |
| should handle duplicate sections. */ |
| #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 |
| |
| /* 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 |
| |
| /* This value for SEC_LINK_DUPLICATES means that the linker |
| should warn if any duplicate sections are a different size. */ |
| #define SEC_LINK_DUPLICATES_SAME_SIZE 0x80000 |
| |
| /* This value for SEC_LINK_DUPLICATES means that the linker |
| should warn if any duplicate sections contain different |
| contents. */ |
| #define SEC_LINK_DUPLICATES_SAME_CONTENTS \ |
| (SEC_LINK_DUPLICATES_ONE_ONLY | SEC_LINK_DUPLICATES_SAME_SIZE) |
| |
| /* This section was created by the linker as part of dynamic |
| 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 |
| |
| /* 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 |
| |
| /* This section contains "short" data, and should be placed |
| "near" the GP. */ |
| #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 |
| |
| /* 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 |
| |
| /* This section contains data about section groups. */ |
| #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 |
| the input file, the linker must copy it to the output file |
| without changing the vma or size. FIXME: Although this |
| was originally intended to be general, it really is COFF |
| specific (and the flag was renamed to indicate this). It |
| 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 |
| |
| /* 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 |
| |
| /* 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 |
| |
| /* 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 |
| |
| /* Indicate that section has the no read flag set. This happens |
| when memory read flag isn't set. */ |
| #define SEC_COFF_NOREAD 0x40000000 |
| |
| /* End of section flags. */ |
| |
| /* Some internal packed boolean fields. */ |
| |
| /* See the vma field. */ |
| unsigned int user_set_vma : 1; |
| |
| /* A mark flag used by some of the linker backends. */ |
| unsigned int linker_mark : 1; |
| |
| /* Another mark flag used by some of the linker backends. Set for |
| output sections that have an input section. */ |
| unsigned int linker_has_input : 1; |
| |
| /* Mark flag used by some linker backends for garbage collection. */ |
| unsigned int gc_mark : 1; |
| |
| /* Section compression status. */ |
| unsigned int compress_status : 2; |
| #define COMPRESS_SECTION_NONE 0 |
| #define COMPRESS_SECTION_DONE 1 |
| #define DECOMPRESS_SECTION_SIZED 2 |
| |
| /* The following flags are used by the ELF linker. */ |
| |
| /* Mark sections which have been allocated to segments. */ |
| unsigned int segment_mark : 1; |
| |
| /* Type of sec_info information. */ |
| unsigned int sec_info_type:3; |
| #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 |
| |
| /* Nonzero if this section uses RELA relocations, rather than REL. */ |
| unsigned int use_rela_p:1; |
| |
| /* Bits used by various backends. The generic code doesn't touch |
| these fields. */ |
| |
| unsigned int sec_flg0:1; |
| unsigned int sec_flg1:1; |
| unsigned int sec_flg2:1; |
| unsigned int sec_flg3:1; |
| unsigned int sec_flg4:1; |
| unsigned int sec_flg5:1; |
| |
| /* End of internal packed boolean fields. */ |
| |
| /* The virtual memory address of the section - where it will be |
| at run time. The symbols are relocated against this. The |
| user_set_vma flag is maintained by bfd; if it's not set, the |
| backend can assign addresses (for example, in <code>a.out</code>, where |
| the default address for <code>.data</code> is dependent on the specific |
| target and various flags). */ |
| bfd_vma vma; |
| |
| /* The load address of the section - where it would be in a |
| rom image; really only used for writing section header |
| information. */ |
| bfd_vma lma; |
| |
| /* 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 <code>.bss</code>). */ |
| bfd_size_type size; |
| |
| /* For input sections, the original size on disk of the section, in |
| octets. This field should be set for any section whose size is |
| changed by linker relaxation. It is required for sections where |
| the linker relaxation scheme doesn't cache altered section and |
| reloc contents (stabs, eh_frame, SEC_MERGE, some coff relaxing |
| targets), and thus the original size needs to be kept to read the |
| section multiple times. For output sections, rawsize holds the |
| section size calculated on a previous linker relaxation pass. */ |
| bfd_size_type rawsize; |
| |
| /* The compressed size of the section in octets. */ |
| bfd_size_type compressed_size; |
| |
| /* Relaxation table. */ |
| struct relax_table *relax; |
| |
| /* Count of used relaxation table entries. */ |
| int relax_count; |
| |
| |
| /* If this section is going to be output, then this value is the |
| offset in *bytes* into the output section of the first byte in the |
| input section (byte ==> smallest addressable unit on the |
| target). In most cases, if this was going to start at the |
| 100th octet (8-bit quantity) in the output section, this value |
| would be 100. However, if the target byte size is 16 bits |
| (bfd_octets_per_byte is "2"), this value would be 50. */ |
| bfd_vma output_offset; |
| |
| /* The output section through which to map on output. */ |
| struct bfd_section *output_section; |
| |
| /* The alignment requirement of the section, as an exponent of 2 - |
| e.g., 3 aligns to 2^3 (or 8). */ |
| unsigned int alignment_power; |
| |
| /* If an input section, a pointer to a vector of relocation |
| records for the data in this section. */ |
| struct reloc_cache_entry *relocation; |
| |
| /* If an output section, a pointer to a vector of pointers to |
| relocation records for the data in this section. */ |
| struct reloc_cache_entry **orelocation; |
| |
| /* The number of relocation records in one of the above. */ |
| unsigned reloc_count; |
| |
| /* Information below is back end specific - and not always used |
| or updated. */ |
| |
| /* File position of section data. */ |
| file_ptr filepos; |
| |
| /* File position of relocation info. */ |
| file_ptr rel_filepos; |
| |
| /* File position of line data. */ |
| file_ptr line_filepos; |
| |
| /* Pointer to data for applications. */ |
| void *userdata; |
| |
| /* If the SEC_IN_MEMORY flag is set, this points to the actual |
| contents. */ |
| unsigned char *contents; |
| |
| /* Attached line number information. */ |
| alent *lineno; |
| |
| /* Number of line number records. */ |
| unsigned int lineno_count; |
| |
| /* Entity size for merging purposes. */ |
| unsigned int entsize; |
| |
| /* Points to the kept section if this section is a link-once section, |
| and is discarded. */ |
| struct bfd_section *kept_section; |
| |
| /* When a section is being output, this value changes as more |
| linenumbers are written out. */ |
| file_ptr moving_line_filepos; |
| |
| /* What the section number is in the target world. */ |
| int target_index; |
| |
| void *used_by_bfd; |
| |
| /* If this is a constructor section then here is a list of the |
| relocations created to relocate items within it. */ |
| struct relent_chain *constructor_chain; |
| |
| /* The BFD which owns the section. */ |
| bfd *owner; |
| |
| /* A symbol which points at this section only. */ |
| struct bfd_symbol *symbol; |
| struct bfd_symbol **symbol_ptr_ptr; |
| |
| /* Early in the link process, map_head and map_tail are used to build |
| a list of input sections attached to an output section. Later, |
| output sections use these fields for a list of bfd_link_order |
| structs. */ |
| union { |
| struct bfd_link_order *link_order; |
| struct bfd_section *s; |
| } map_head, map_tail; |
| } asection; |
| |
| /* Relax table contains information about instructions which can |
| 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. */ |
| 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*" |
| |
| /* Pointer to the common 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. */ |
| #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) \ |
| ( ((SEC) == bfd_abs_section_ptr) \ |
| || ((SEC) == bfd_und_section_ptr) \ |
| || ((SEC) == bfd_com_section_ptr) \ |
| || ((SEC) == bfd_ind_section_ptr)) |
| |
| /* Macros to handle insertion and deletion of a bfd's sections. These |
| only handle the list pointers, ie. do not adjust section_count, |
| target_index etc. */ |
| #define bfd_section_list_remove(ABFD, S) \ |
| do \ |
| { \ |
| asection *_s = S; \ |
| asection *_next = _s->next; \ |
| asection *_prev = _s->prev; \ |
| if (_prev) \ |
| _prev->next = _next; \ |
| else \ |
| (ABFD)->sections = _next; \ |
| if (_next) \ |
| _next->prev = _prev; \ |
| else \ |
| (ABFD)->section_last = _prev; \ |
| } \ |
| while (0) |
| #define bfd_section_list_append(ABFD, S) \ |
| do \ |
| { \ |
| asection *_s = S; \ |
| bfd *_abfd = ABFD; \ |
| _s->next = NULL; \ |
| if (_abfd->section_last) \ |
| { \ |
| _s->prev = _abfd->section_last; \ |
| _abfd->section_last->next = _s; \ |
| } \ |
| else \ |
| { \ |
| _s->prev = NULL; \ |
| _abfd->sections = _s; \ |
| } \ |
| _abfd->section_last = _s; \ |
| } \ |
| while (0) |
| #define bfd_section_list_prepend(ABFD, S) \ |
| do \ |
| { \ |
| asection *_s = S; \ |
| bfd *_abfd = ABFD; \ |
| _s->prev = NULL; \ |
| if (_abfd->sections) \ |
| { \ |
| _s->next = _abfd->sections; \ |
| _abfd->sections->prev = _s; \ |
| } \ |
| else \ |
| { \ |
| _s->next = NULL; \ |
| _abfd->section_last = _s; \ |
| } \ |
| _abfd->sections = _s; \ |
| } \ |
| while (0) |
| #define bfd_section_list_insert_after(ABFD, A, S) \ |
| do \ |
| { \ |
| asection *_a = A; \ |
| asection *_s = S; \ |
| asection *_next = _a->next; \ |
| _s->next = _next; \ |
| _s->prev = _a; \ |
| _a->next = _s; \ |
| if (_next) \ |
| _next->prev = _s; \ |
| else \ |
| (ABFD)->section_last = _s; \ |
| } \ |
| while (0) |
| #define bfd_section_list_insert_before(ABFD, B, S) \ |
| do \ |
| { \ |
| asection *_b = B; \ |
| asection *_s = S; \ |
| asection *_prev = _b->prev; \ |
| _s->prev = _prev; \ |
| _s->next = _b; \ |
| _b->prev = _s; \ |
| if (_prev) \ |
| _prev->next = _s; \ |
| else \ |
| (ABFD)->sections = _s; \ |
| } \ |
| while (0) |
| #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) \ |
| /* name, id, index, next, prev, flags, user_set_vma, */ \ |
| { NAME, IDX, 0, NULL, NULL, FLAGS, 0, \ |
| \ |
| /* linker_mark, linker_has_input, gc_mark, decompress_status, */ \ |
| 0, 0, 1, 0, \ |
| \ |
| /* segment_mark, sec_info_type, use_rela_p, */ \ |
| 0, 0, 0, \ |
| \ |
| /* sec_flg0, sec_flg1, sec_flg2, sec_flg3, sec_flg4, sec_flg5, */ \ |
| 0, 0, 0, 0, 0, 0, \ |
| \ |
| /* vma, lma, size, rawsize, compressed_size, relax, relax_count, */ \ |
| 0, 0, 0, 0, 0, 0, 0, \ |
| \ |
| /* output_offset, output_section, alignment_power, */ \ |
| 0, &SEC, 0, \ |
| \ |
| /* relocation, orelocation, reloc_count, filepos, rel_filepos, */ \ |
| NULL, NULL, 0, 0, 0, \ |
| \ |
| /* line_filepos, userdata, contents, lineno, lineno_count, */ \ |
| 0, NULL, NULL, NULL, 0, \ |
| \ |
| /* entsize, kept_section, moving_line_filepos, */ \ |
| 0, NULL, 0, \ |
| \ |
| /* target_index, used_by_bfd, constructor_chain, owner, */ \ |
| 0, NULL, NULL, NULL, \ |
| \ |
| /* symbol, symbol_ptr_ptr, */ \ |
| (struct bfd_symbol *) SYM, &SEC.symbol, \ |
| \ |
| /* map_head, map_tail */ \ |
| { NULL }, { NULL } \ |
| } |
| |
| </pre></div> |
| |
| <hr> |
| <div class="header"> |
| <p> |
| Next: <a href="section-prototypes.html#section-prototypes" accesskey="n" rel="next">section prototypes</a>, Previous: <a href="Section-Output.html#Section-Output" accesskey="p" rel="prev">Section Output</a>, Up: <a href="Sections.html#Sections" accesskey="u" rel="up">Sections</a> [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="BFD-Index.html#BFD-Index" title="Index" rel="index">Index</a>]</p> |
| </div> |
| |
| |
| |
| </body> |
| </html> |
