/* write.c - emit .o file
- Copyright (C) 1986-2015 Free Software Foundation, Inc.
+ Copyright (C) 1986-2018 Free Software Foundation, Inc.
This file is part of GAS, the GNU Assembler.
Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
02110-1301, USA. */
-/* This thing should be set up to do byteordering correctly. But... */
+/* This thing should be set up to do byte ordering correctly. But... */
#include "as.h"
#include "subsegs.h"
#include "obstack.h"
#include "output-file.h"
#include "dwarf2dbg.h"
-#include "libbfd.h"
#include "compress-debug.h"
#ifndef TC_FORCE_RELOCATION
(TC_FORCE_RELOCATION (FIX))
#endif
-#ifndef TC_FORCE_RELOCATION_LOCAL
-#define TC_FORCE_RELOCATION_LOCAL(FIX) \
+#define GENERIC_FORCE_RELOCATION_LOCAL(FIX) \
(!(FIX)->fx_pcrel \
|| TC_FORCE_RELOCATION (FIX))
+#ifndef TC_FORCE_RELOCATION_LOCAL
+#define TC_FORCE_RELOCATION_LOCAL GENERIC_FORCE_RELOCATION_LOCAL
#endif
+#define GENERIC_FORCE_RELOCATION_SUB_SAME(FIX, SEG) \
+ (!SEG_NORMAL (SEG))
#ifndef TC_FORCE_RELOCATION_SUB_SAME
-#define TC_FORCE_RELOCATION_SUB_SAME(FIX, SEG) \
- (! SEG_NORMAL (SEG))
+#define TC_FORCE_RELOCATION_SUB_SAME GENERIC_FORCE_RELOCATION_SUB_SAME
#endif
#ifndef md_register_arithmetic
TC_INIT_FIX_DATA (fixP);
#endif
- as_where (&fixP->fx_file, &fixP->fx_line);
+ fixP->fx_file = as_where (&fixP->fx_line);
{
segT seg,
/* Alignment, as a power of 2 (e.g., 1 => 2-byte
boundary, 2 => 4-byte boundary, etc.) */
- int align)
+ unsigned int align)
{
if (seg == absolute_section)
return;
- if ((unsigned int) align > bfd_get_section_alignment (stdoutput, seg))
+ if (align > bfd_get_section_alignment (stdoutput, seg))
bfd_set_section_alignment (stdoutput, seg, align);
}
{
switch (fragP->fr_type)
{
+ case rs_space_nop:
+ goto skip_align;
case rs_align:
case rs_align_code:
case rs_align_test:
#ifdef HANDLE_ALIGN
HANDLE_ALIGN (fragP);
#endif
+skip_align:
know (fragP->fr_next != NULL);
fragP->fr_offset = (fragP->fr_next->fr_address
- fragP->fr_address
if (fragP->fr_offset < 0)
{
as_bad_where (fragP->fr_file, fragP->fr_line,
- _("attempt to .org/.space backwards? (%ld)"),
+ _("attempt to .org/.space/.nops backwards? (%ld)"),
(long) fragP->fr_offset);
fragP->fr_offset = 0;
}
- fragP->fr_type = rs_fill;
+ if (fragP->fr_type == rs_space_nop)
+ fragP->fr_type = rs_fill_nop;
+ else
+ fragP->fr_type = rs_fill;
break;
case rs_fill:
+ case rs_fill_nop:
break;
case rs_leb128:
valueT value = S_GET_VALUE (fragP->fr_symbol);
int size;
+ if (!S_IS_DEFINED (fragP->fr_symbol))
+ {
+ as_bad_where (fragP->fr_file, fragP->fr_line,
+ _("leb128 operand is an undefined symbol: %s"),
+ S_GET_NAME (fragP->fr_symbol));
+ }
+
size = output_leb128 (fragP->fr_literal + fragP->fr_fix, value,
fragP->fr_subtype);
x = bfd_set_section_flags (abfd, sec, flags);
gas_assert (x);
- newsize = md_section_align (sec, size);
+ /* If permitted, allow the backend to pad out the section
+ to some alignment boundary. */
+ if (do_not_pad_sections_to_alignment)
+ newsize = size;
+ else
+ newsize = md_section_align (sec, size);
x = bfd_set_section_size (abfd, sec, newsize);
gas_assert (x);
as_bad_where (r->file, r->line, _("invalid reloc expression"));
sec = NULL;
}
- else if (sym != NULL)
+ else if (sym != NULL && sec != NULL)
{
/* Convert relocs against local symbols to refer to the
corresponding section symbol plus offset instead. Keep
/* If the linker is doing the relaxing, we must not do any fixups.
Well, strictly speaking that's not true -- we could do any that
- are PC-relative and don't cross regions that could change size.
- And for the i960 we might be able to turn callx/callj into bal
- anyways in cases where we know the maximum displacement. */
+ are PC-relative and don't cross regions that could change size. */
if (linkrelax && TC_LINKRELAX_FIXUP (this_segment))
{
for (; fixP; fixP = fixP->fx_next)
else
sprintf (buf2, "%ld", (long) add_number);
as_bad_where (fixP->fx_file, fixP->fx_line,
- _("value of %s too large for field of %d bytes at %s"),
+ ngettext ("value of %s too large for field "
+ "of %d byte at %s",
+ "value of %s too large for field "
+ "of %d bytes at %s",
+ fixP->fx_size),
buf2, fixP->fx_size, buf);
} /* Generic error checking. */
}
static void
install_reloc (asection *sec, arelent *reloc, fragS *fragp,
- char *file, unsigned int line)
+ const char *file, unsigned int line)
{
char *err;
bfd_reloc_status_type s;
rp = &r->next;
}
- relocs = (arelent **) xcalloc (n, sizeof (arelent *));
+ relocs = XCNEWVEC (arelent *, n);
n = 0;
r = my_reloc_list;
if (flag_compress_debug == COMPRESS_DEBUG_GABI_ZLIB)
{
- stdoutput->flags |= BFD_COMPRESS | BFD_COMPRESS_GABI;
compression_header_size
= bfd_get_compression_header_size (stdoutput, NULL);
header_size = compression_header_size;
}
else
{
- stdoutput->flags |= BFD_COMPRESS;
compression_header_size = 0;
header_size = 12;
}
if (obstack_room (ob) < header_size)
first_newf = frag_alloc (ob);
if (obstack_room (ob) < header_size)
- as_fatal (_("can't extend frag %u chars"), header_size);
+ as_fatal (ngettext ("can't extend frag %lu char",
+ "can't extend frag %lu chars",
+ (unsigned long) header_size),
+ (unsigned long) header_size);
last_newf = first_newf;
obstack_blank_fast (ob, header_size);
last_newf->fr_type = rs_fill;
compressed_size = header_size;
/* Stream the frags through the compression engine, adding new frags
- as necessary to accomodate the compressed output. */
+ as necessary to accommodate the compressed output. */
for (f = seginfo->frchainP->frch_root;
f;
f = f->fr_next)
gas_assert (x);
if (!compression_header_size)
{
- compressed_name = (char *) xmalloc (strlen (section_name) + 2);
- compressed_name[0] = '.';
- compressed_name[1] = 'z';
- strcpy (compressed_name + 2, section_name + 1);
+ compressed_name = concat (".z", section_name + 1, (char *) NULL);
bfd_section_name (stdoutput, sec) = compressed_name;
}
}
+#ifndef md_generate_nops
+/* Genenerate COUNT bytes of no-op instructions to WHERE. A target
+ backend must override this with proper no-op instructions. */
+
+static void
+md_generate_nops (fragS *f ATTRIBUTE_UNUSED,
+ char *where ATTRIBUTE_UNUSED,
+ offsetT count ATTRIBUTE_UNUSED,
+ int control ATTRIBUTE_UNUSED)
+{
+ as_bad (_("unimplemented .nops directive"));
+}
+#endif
+
static void
write_contents (bfd *abfd ATTRIBUTE_UNUSED,
asection *sec,
char *fill_literal;
offsetT count;
- gas_assert (f->fr_type == rs_fill);
+ gas_assert (f->fr_type == rs_fill || f->fr_type == rs_fill_nop);
if (f->fr_fix)
{
x = bfd_set_section_contents (stdoutput, sec,
f->fr_literal, (file_ptr) offset,
(bfd_size_type) f->fr_fix);
if (!x)
- as_fatal (_("can't write %s: %s"), stdoutput->filename,
+ as_fatal (ngettext ("can't write %ld byte "
+ "to section %s of %s: '%s'",
+ "can't write %ld bytes "
+ "to section %s of %s: '%s'",
+ (long) f->fr_fix),
+ (long) f->fr_fix,
+ sec->name, stdoutput->filename,
bfd_errmsg (bfd_get_error ()));
offset += f->fr_fix;
}
- fill_literal = f->fr_literal + f->fr_fix;
+
fill_size = f->fr_var;
count = f->fr_offset;
+ fill_literal = f->fr_literal + f->fr_fix;
+
+ if (f->fr_type == rs_fill_nop)
+ {
+ gas_assert (count >= 0 && fill_size == 1);
+ if (count > 0)
+ {
+ char *buf = xmalloc (count);
+ md_generate_nops (f, buf, count, *fill_literal);
+ x = bfd_set_section_contents
+ (stdoutput, sec, buf, (file_ptr) offset,
+ (bfd_size_type) count);
+ if (!x)
+ as_fatal (ngettext ("can't fill %ld byte "
+ "in section %s of %s: '%s'",
+ "can't fill %ld bytes "
+ "in section %s of %s: '%s'",
+ (long) count), (long) count,
+ sec->name, stdoutput->filename,
+ bfd_errmsg (bfd_get_error ()));
+ offset += count;
+ free (buf);
+ }
+ continue;
+ }
+
gas_assert (count >= 0);
if (fill_size && count)
{
(file_ptr) offset,
(bfd_size_type) fill_size);
if (!x)
- as_fatal (_("can't write %s: %s"), stdoutput->filename,
+ as_fatal (ngettext ("can't fill %ld byte "
+ "in section %s of %s: '%s'",
+ "can't fill %ld bytes "
+ "in section %s of %s: '%s'",
+ (long) fill_size),
+ (long) fill_size,
+ sec->name, stdoutput->filename,
bfd_errmsg (bfd_get_error ()));
offset += fill_size;
}
(stdoutput, sec, buf, (file_ptr) offset,
(bfd_size_type) n_per_buf * fill_size);
if (!x)
- as_fatal (_("cannot write to output file '%s': %s"),
- stdoutput->filename,
+ as_fatal (ngettext ("can't fill %ld byte "
+ "in section %s of %s: '%s'",
+ "can't fill %ld bytes "
+ "in section %s of %s: '%s'",
+ (long) (n_per_buf * fill_size)),
+ (long) (n_per_buf * fill_size),
+ sec->name, stdoutput->filename,
bfd_errmsg (bfd_get_error ()));
offset += n_per_buf * fill_size;
}
}
/* Finish the subsegments. After every sub-segment, we fake an
- ".align ...". This conforms to BSD4.2 brane-damage. We then fake
+ ".align ...". This conforms to BSD4.2 brain-damage. We then fake
".fill 0" because that is the kind of frag that requires least
thought. ".align" frags like to have a following frag since that
makes calculating their intended length trivial. */
code-bearing sections. */
#define SUB_SEGMENT_ALIGN(SEG, FRCHAIN) \
(!(FRCHAIN)->frch_next && subseg_text_p (SEG) \
+ && !do_not_pad_sections_to_alignment \
? get_recorded_alignment (SEG) \
: 0)
#else
frchainP != NULL;
frchainP = frchainP->frch_next)
{
- int alignment = 0;
+ int alignment;
subseg_set (s, frchainP->frch_subseg);
/* This now gets called even if we had errors. In that case,
any alignment is meaningless, and, moreover, will look weird
if we are generating a listing. */
- if (!had_errors ())
- {
- alignment = SUB_SEGMENT_ALIGN (now_seg, frchainP);
- if ((bfd_get_section_flags (now_seg->owner, now_seg) & SEC_MERGE)
- && now_seg->entsize)
- {
- unsigned int entsize = now_seg->entsize;
- int entalign = 0;
+ if (had_errors ())
+ do_not_pad_sections_to_alignment = 1;
- while ((entsize & 1) == 0)
- {
- ++entalign;
- entsize >>= 1;
- }
+ alignment = SUB_SEGMENT_ALIGN (now_seg, frchainP);
+ if ((bfd_get_section_flags (now_seg->owner, now_seg) & SEC_MERGE)
+ && now_seg->entsize)
+ {
+ unsigned int entsize = now_seg->entsize;
+ int entalign = 0;
- if (entalign > alignment)
- alignment = entalign;
+ while ((entsize & 1) == 0)
+ {
+ ++entalign;
+ entsize >>= 1;
}
+
+ if (entalign > alignment)
+ alignment = entalign;
}
if (subseg_text_p (now_seg))
#endif
/* From now on, we don't care about sub-segments. Build one frag chain
- for each segment. Linked thru fr_next. */
+ for each segment. Linked through fr_next. */
/* Remove the sections created by gas for its own purposes. */
{
/* Relaxation has completed. Freeze all syms. */
finalize_syms = 1;
+ dwarf2dbg_final_check ();
+
#ifdef md_post_relax_hook
md_post_relax_hook;
#endif
if (S_IS_COMMON (symp)
&& !TC_FAKE_LABEL (sname)
- && !S_IS_WEAKREFR (symp)
- && (!S_IS_EXTERNAL (symp) || S_IS_LOCAL (symp)))
+ && !S_IS_WEAKREFR (symp))
{
expressionS *e = symbol_get_value_expression (symp);
- as_bad (_("Local symbol `%s' can't be equated to common symbol `%s'"),
+ as_bad (_("`%s' can't be equated to common symbol `%s'"),
sname, S_GET_NAME (e->X_add_symbol));
}
if (S_GET_SEGMENT (symp) == reg_section)
obj_frob_file_after_relocs ();
#endif
+#if defined OBJ_ELF || defined OBJ_MAYBE_ELF
+ if (IS_ELF && flag_use_elf_stt_common)
+ stdoutput->flags |= BFD_CONVERT_ELF_COMMON | BFD_USE_ELF_STT_COMMON;
+#endif
+
/* Once all relocations have been written, we can compress the
contents of the debug sections. This needs to be done before
we start writing any sections, because it will affect the file
layout, which is fixed once we start writing contents. */
if (flag_compress_debug)
- bfd_map_over_sections (stdoutput, compress_debug, (char *) 0);
+ {
+ if (flag_compress_debug == COMPRESS_DEBUG_GABI_ZLIB)
+ stdoutput->flags |= BFD_COMPRESS | BFD_COMPRESS_GABI;
+ else
+ stdoutput->flags |= BFD_COMPRESS;
+ bfd_map_over_sections (stdoutput, compress_debug, (char *) 0);
+ }
bfd_map_over_sections (stdoutput, write_contents, (char *) 0);
}
if (offset % fragP->fr_var != 0)
{
as_bad_where (fragP->fr_file, fragP->fr_line,
- _("alignment padding (%lu bytes) not a multiple of %ld"),
+ ngettext ("alignment padding (%lu byte) "
+ "not a multiple of %ld",
+ "alignment padding (%lu bytes) "
+ "not a multiple of %ld",
+ (unsigned long) offset),
(unsigned long) offset, (long) fragP->fr_var);
offset -= (offset % fragP->fr_var);
}
break;
case rs_space:
+ case rs_space_nop:
break;
case rs_machine_dependent:
know (fragP->fr_next);
after = fragP->fr_next->fr_address + stretch;
growth = target - after;
- if (growth < 0)
+
+ /* Growth may be negative, but variable part of frag
+ cannot have fewer than 0 chars. That is, we can't
+ .org backwards. */
+ if (address + fragP->fr_fix > target)
{
growth = 0;
break;
}
- /* Growth may be negative, but variable part of frag
- cannot have fewer than 0 chars. That is, we can't
- .org backwards. */
as_bad_where (fragP->fr_file, fragP->fr_line,
_("attempt to move .org backwards"));
break;
case rs_space:
+ case rs_space_nop:
growth = 0;
if (symbolP)
{
}
as_warn_where (fragP->fr_file, fragP->fr_line,
- _(".space or .fill with negative value, ignored"));
+ _(".space, .nops or .fill with negative value, ignored"));
fragP->fr_symbol = 0;
}
else