static void
obj_coff_ident (int ignore ATTRIBUTE_UNUSED)
{
segT current_seg = now_seg;
subsegT current_subseg = now_subseg;
#ifdef TE_PE
{
segT sec;
/* We could put it in .comment, but that creates an extra section
that shouldn't be loaded into memory, which requires linker
changes... For now, until proven otherwise, use .rdata. */
sec = subseg_new (".rdata$zzz", 0);
bfd_set_section_flags (stdoutput, sec,
((SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_DATA)
& bfd_applicable_section_flags (stdoutput)));
}
#else
subseg_new (".comment", 0);
#endif
stringer (1);
subseg_set (current_seg, current_subseg);
}
static void
s_data1()
{
subseg_new(SEG_DATA, 1);
demand_empty_rest_of_line();
return;
}
static segT
make_debug_seg (segT cseg, char *name, int sflags)
{
segT save_seg = now_seg;
int save_subseg = now_subseg;
segT r;
flagword flags;
r = subseg_new (name, 0);
/* Check if code segment is marked as linked once. */
if (!cseg)
flags = 0;
else
flags = bfd_get_section_flags (stdoutput, cseg)
& (SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD
| SEC_LINK_DUPLICATES_ONE_ONLY | SEC_LINK_DUPLICATES_SAME_SIZE
| SEC_LINK_DUPLICATES_SAME_CONTENTS);
/* Add standard section flags. */
flags |= sflags;
/* Apply possibly linked once flags to new generated segment, too. */
if (!bfd_set_section_flags (stdoutput, r, flags))
as_bad (_("bfd_set_section_flags: %s"),
bfd_errmsg (bfd_get_error ()));
/* Restore to previous segment. */
if (save_seg != NULL)
subseg_set (save_seg, save_subseg);
return r;
}
static void
obj_coff_bss (int ignore ATTRIBUTE_UNUSED)
{
if (*input_line_pointer == '\n')
subseg_new (".bss", get_absolute_expression ());
else
s_lcomm (0);
}
static symbolS *
obj_coff_common_parse (int ignore ATTRIBUTE_UNUSED, symbolS *symbolP, addressT size)
{
addressT align = 0;
if (*input_line_pointer == ',')
{
align = parse_align (0);
if (align == (addressT) -1)
return NULL;
}
S_SET_VALUE (symbolP, size);
S_SET_EXTERNAL (symbolP);
S_SET_SEGMENT (symbolP, bfd_com_section_ptr);
symbol_get_bfdsym (symbolP)->flags |= BSF_OBJECT;
/* There is no S_SET_ALIGN (symbolP, align) in COFF/PE.
Instead we must add a note to the .drectve section. */
if (align)
{
segT current_seg = now_seg;
subsegT current_subseg = now_subseg;
flagword oldflags;
asection *sec;
size_t pfxlen, numlen;
char *frag;
char numbuff[20];
sec = subseg_new (".drectve", 0);
oldflags = bfd_get_section_flags (stdoutput, sec);
if (oldflags == SEC_NO_FLAGS)
{
if (!bfd_set_section_flags (stdoutput, sec,
TC_COFF_SECTION_DEFAULT_ATTRIBUTES))
as_warn (_("error setting flags for \"%s\": %s"),
bfd_section_name (stdoutput, sec),
bfd_errmsg (bfd_get_error ()));
}
/* Emit a string. Note no NUL-termination. */
pfxlen = strlen (" -aligncomm:") + 2 + strlen (S_GET_NAME (symbolP)) + 1;
numlen = snprintf (numbuff, sizeof (numbuff), "%d", (int) align);
frag = frag_more (pfxlen + numlen);
(void) sprintf (frag, " -aligncomm:\"%s\",", S_GET_NAME (symbolP));
memcpy (frag + pfxlen, numbuff, numlen);
/* Restore original subseg. */
subseg_set (current_seg, current_subseg);
}
return symbolP;
}
unsigned int
get_stab_string_offset (const char *string, const char *stabstr_secname)
{
unsigned int length;
unsigned int retval;
segT save_seg;
subsegT save_subseg;
segT seg;
char *p;
if (! SEPARATE_STAB_SECTIONS)
abort ();
length = strlen (string);
save_seg = now_seg;
save_subseg = now_subseg;
/* Create the stab string section. */
seg = subseg_new (stabstr_secname, 0);
retval = seg_info (seg)->stabu.stab_string_size;
if (retval <= 0)
{
/* Make sure the first string is empty. */
p = frag_more (1);
*p = 0;
retval = seg_info (seg)->stabu.stab_string_size = 1;
bfd_set_section_flags (stdoutput, seg, SEC_READONLY | SEC_DEBUGGING);
if (seg->name == stabstr_secname)
seg->name = xstrdup (stabstr_secname);
}
if (length > 0)
{ /* Ordinary case. */
p = frag_more (length + 1);
strcpy (p, string);
seg_info (seg)->stabu.stab_string_size += length + 1;
}
else
retval = 0;
subseg_set (save_seg, save_subseg);
return retval;
}
void
cfi_finish (void)
{
segT cfi_seg;
struct fde_entry *fde;
int save_flag_traditional_format;
if (all_fde_data == 0)
return;
/* Open .eh_frame section. */
cfi_seg = subseg_new (".eh_frame", 0);
bfd_set_section_flags (stdoutput, cfi_seg,
SEC_ALLOC | SEC_LOAD | SEC_DATA
| DWARF2_EH_FRAME_READ_ONLY);
subseg_set (cfi_seg, 0);
record_alignment (cfi_seg, EH_FRAME_ALIGNMENT);
#ifdef md_fix_up_eh_frame
md_fix_up_eh_frame (cfi_seg);
#endif
/* Make sure check_eh_frame doesn't do anything with our output. */
save_flag_traditional_format = flag_traditional_format;
flag_traditional_format = 1;
for (fde = all_fde_data; fde ; fde = fde->next)
{
struct cfi_insn_data *first;
struct cie_entry *cie;
if (fde->end_address == NULL)
{
as_bad (_("open CFI at the end of file; missing .cfi_endproc directive"));
fde->end_address = fde->start_address;
}
cie = select_cie_for_fde (fde, &first);
output_fde (fde, cie, first, fde->next == NULL ? EH_FRAME_ALIGNMENT : 2);
}
flag_traditional_format = save_flag_traditional_format;
}
static segT
get_cfi_seg (segT cseg, const char *base, flagword flags, int align)
{
if (SUPPORT_FRAME_LINKONCE)
{
struct dwcfi_seg_list *l;
l = dwcfi_hash_find_or_make (cseg, base, flags);
cseg = l->seg;
subseg_set (cseg, l->subseg);
}
else
{
cseg = subseg_new (base, 0);
bfd_set_section_flags (stdoutput, cseg, flags);
}
record_alignment (cseg, align);
return cseg;
}
void
dwarf2_finish (void)
{
segT line_seg;
struct line_seg *s;
segT info_seg;
int emit_other_sections = 0;
int empty_debug_line = 0;
info_seg = bfd_get_section_by_name (stdoutput, ".debug_info");
emit_other_sections = info_seg == NULL || !seg_not_empty_p (info_seg);
line_seg = bfd_get_section_by_name (stdoutput, ".debug_line");
empty_debug_line = line_seg == NULL || !seg_not_empty_p (line_seg);
/* We can't construct a new debug_line section if we already have one.
Give an error. */
if (all_segs && !empty_debug_line)
as_fatal ("duplicate .debug_line sections");
if ((!all_segs && emit_other_sections)
|| (!emit_other_sections && !empty_debug_line))
/* If there is no line information and no non-empty .debug_info
section, or if there is both a non-empty .debug_info and a non-empty
.debug_line, then we do nothing. */
return;
/* Calculate the size of an address for the target machine. */
sizeof_address = DWARF2_ADDR_SIZE (stdoutput);
/* Create and switch to the line number section. */
line_seg = subseg_new (".debug_line", 0);
bfd_set_section_flags (stdoutput, line_seg, SEC_READONLY | SEC_DEBUGGING);
/* For each subsection, chain the debug entries together. */
for (s = all_segs; s; s = s->next)
{
struct line_subseg *lss = s->head;
struct line_entry **ptail = lss->ptail;
while ((lss = lss->next) != NULL)
{
*ptail = lss->head;
ptail = lss->ptail;
}
}
out_debug_line (line_seg);
/* If this is assembler generated line info, and there is no
debug_info already, we need .debug_info and .debug_abbrev
sections as well. */
if (emit_other_sections)
{
segT abbrev_seg;
segT aranges_seg;
segT ranges_seg;
gas_assert (all_segs);
info_seg = subseg_new (".debug_info", 0);
abbrev_seg = subseg_new (".debug_abbrev", 0);
aranges_seg = subseg_new (".debug_aranges", 0);
bfd_set_section_flags (stdoutput, info_seg,
SEC_READONLY | SEC_DEBUGGING);
bfd_set_section_flags (stdoutput, abbrev_seg,
SEC_READONLY | SEC_DEBUGGING);
bfd_set_section_flags (stdoutput, aranges_seg,
SEC_READONLY | SEC_DEBUGGING);
record_alignment (aranges_seg, ffs (2 * sizeof_address) - 1);
if (all_segs->next == NULL)
ranges_seg = NULL;
else
{
ranges_seg = subseg_new (".debug_ranges", 0);
bfd_set_section_flags (stdoutput, ranges_seg,
SEC_READONLY | SEC_DEBUGGING);
record_alignment (ranges_seg, ffs (2 * sizeof_address) - 1);
out_debug_ranges (ranges_seg);
}
out_debug_aranges (aranges_seg, info_seg);
out_debug_abbrev (abbrev_seg, info_seg, line_seg);
out_debug_info (info_seg, abbrev_seg, line_seg, ranges_seg);
}
}
void
dwarf2_finish (void)
{
segT line_seg;
struct line_seg *s;
/* We don't need to do anything unless:
- Some debug information was recorded via .file/.loc
- or, we are generating DWARF2 information ourself (--gdwarf2)
- or, there is a user-provided .debug_info section which could
reference the file table in the .debug_line section we generate
below. */
if (all_segs == NULL
&& debug_type != DEBUG_DWARF2
&& bfd_get_section_by_name (stdoutput, ".debug_info") == NULL)
return;
/* Calculate the size of an address for the target machine. */
sizeof_address = DWARF2_ADDR_SIZE (stdoutput);
/* Create and switch to the line number section. */
line_seg = subseg_new (".debug_line", 0);
bfd_set_section_flags (stdoutput, line_seg, SEC_READONLY);
/* For each subsection, chain the debug entries together. */
for (s = all_segs; s; s = s->next)
{
struct line_subseg *ss = s->head;
struct line_entry **ptail = ss->ptail;
while ((ss = ss->next) != NULL)
{
*ptail = ss->head;
ptail = ss->ptail;
}
}
out_debug_line (line_seg);
/* If this is assembler generated line info, we need .debug_info
and .debug_abbrev sections as well. */
if (all_segs != NULL && debug_type == DEBUG_DWARF2)
{
segT abbrev_seg;
segT info_seg;
segT aranges_seg;
info_seg = subseg_new (".debug_info", 0);
abbrev_seg = subseg_new (".debug_abbrev", 0);
aranges_seg = subseg_new (".debug_aranges", 0);
bfd_set_section_flags (stdoutput, info_seg, SEC_READONLY);
bfd_set_section_flags (stdoutput, abbrev_seg, SEC_READONLY);
bfd_set_section_flags (stdoutput, aranges_seg, SEC_READONLY);
record_alignment (aranges_seg, ffs (2 * sizeof_address) - 1);
out_debug_aranges (aranges_seg, info_seg);
out_debug_abbrev (abbrev_seg);
out_debug_info (info_seg, abbrev_seg, line_seg);
}
}
void
dwarf2_finish (void)
{
segT line_seg;
struct line_seg *s;
segT info_seg;
int emit_other_sections = 0;
info_seg = bfd_get_section_by_name (stdoutput, ".debug_info");
emit_other_sections = info_seg == NULL || !seg_not_empty_p (info_seg);
if (!all_segs && emit_other_sections)
/* There is no line information and no non-empty .debug_info
section. */
return;
/* Calculate the size of an address for the target machine. */
sizeof_address = DWARF2_ADDR_SIZE (stdoutput);
/* Create and switch to the line number section. */
line_seg = subseg_new (".debug_line", 0);
bfd_set_section_flags (stdoutput, line_seg, SEC_READONLY | SEC_DEBUGGING);
/* For each subsection, chain the debug entries together. */
for (s = all_segs; s; s = s->next)
{
struct line_subseg *ss = s->head;
struct line_entry **ptail = ss->ptail;
while ((ss = ss->next) != NULL)
{
*ptail = ss->head;
ptail = ss->ptail;
}
}
out_debug_line (line_seg);
/* If this is assembler generated line info, and there is no
debug_info already, we need .debug_info and .debug_abbrev
sections as well. */
if (emit_other_sections)
{
segT abbrev_seg;
segT aranges_seg;
assert (all_segs);
info_seg = subseg_new (".debug_info", 0);
abbrev_seg = subseg_new (".debug_abbrev", 0);
aranges_seg = subseg_new (".debug_aranges", 0);
bfd_set_section_flags (stdoutput, info_seg,
SEC_READONLY | SEC_DEBUGGING);
bfd_set_section_flags (stdoutput, abbrev_seg,
SEC_READONLY | SEC_DEBUGGING);
bfd_set_section_flags (stdoutput, aranges_seg,
SEC_READONLY | SEC_DEBUGGING);
record_alignment (aranges_seg, ffs (2 * sizeof_address) - 1);
out_debug_aranges (aranges_seg, info_seg);
out_debug_abbrev (abbrev_seg);
out_debug_info (info_seg, abbrev_seg, line_seg);
}
}