<!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-2016 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. */
|
unsigned int id;
|
|
/* Which section in the bfd; 0..n-1 as sections are created in a bfd. */
|
unsigned 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
|
|
/* 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
|
|
/* 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
|
|
/* 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
|
|
/* Indicate that section has the no read flag set. */
|
#define SEC_ELF_NOREAD 0x80000000
|
|
/* 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
|
#define SEC_INFO_TYPE_EH_FRAME_ENTRY 6
|
|
/* 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>
|
