/* write.c - emit .o file
- Copyright (C) 1986-2014 Free Software Foundation, Inc.
+ Copyright (C) 1986-2017 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);
}
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 (symsec == NULL)
abort ();
- if (bfd_is_abs_section (symsec))
+ if (bfd_is_abs_section (symsec)
+ || symsec == reg_section)
{
/* The fixup_segment routine normally will not use this
symbol in a relocation. */
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;
&& r->u.b.r.address < f->fr_address + f->fr_fix)
return f;
+ for (f = seginfo->frchainP->frch_root; f != NULL; f = f->fr_next)
+ if (f->fr_address <= r->u.b.r.address
+ && r->u.b.r.address <= f->fr_address + f->fr_fix)
+ return f;
+
as_bad_where (r->file, r->line,
_("reloc not within (fixed part of) section"));
return NULL;
rp = &r->next;
}
- relocs = (arelent **) xcalloc (n, sizeof (arelent *));
+ relocs = XCNEWVEC (arelent *, n);
n = 0;
r = my_reloc_list;
struct z_stream_s *strm;
int x;
flagword flags = bfd_get_section_flags (abfd, sec);
+ unsigned int header_size, compression_header_size;
if (seginfo == NULL
|| sec->size < 32
if (strm == NULL)
return;
- /* Create a new frag to contain the "ZLIB" header. */
+ if (flag_compress_debug == COMPRESS_DEBUG_GABI_ZLIB)
+ {
+ compression_header_size
+ = bfd_get_compression_header_size (stdoutput, NULL);
+ header_size = compression_header_size;
+ }
+ else
+ {
+ compression_header_size = 0;
+ header_size = 12;
+ }
+
+ /* Create a new frag to contain the compression header. */
first_newf = frag_alloc (ob);
- if (obstack_room (ob) < 12)
+ if (obstack_room (ob) < header_size)
first_newf = frag_alloc (ob);
- if (obstack_room (ob) < 12)
- as_fatal (_("can't extend frag %u chars"), 12);
+ if (obstack_room (ob) < header_size)
+ as_fatal (_("can't extend frag %u chars"), header_size);
last_newf = first_newf;
- obstack_blank_fast (ob, 12);
+ obstack_blank_fast (ob, header_size);
last_newf->fr_type = rs_fill;
- last_newf->fr_fix = 12;
+ last_newf->fr_fix = header_size;
header = last_newf->fr_literal;
- memcpy (header, "ZLIB", 4);
- header[11] = uncompressed_size; uncompressed_size >>= 8;
- header[10] = uncompressed_size; uncompressed_size >>= 8;
- header[9] = uncompressed_size; uncompressed_size >>= 8;
- header[8] = uncompressed_size; uncompressed_size >>= 8;
- header[7] = uncompressed_size; uncompressed_size >>= 8;
- header[6] = uncompressed_size; uncompressed_size >>= 8;
- header[5] = uncompressed_size; uncompressed_size >>= 8;
- header[4] = uncompressed_size;
- compressed_size = 12;
+ 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)
break;
}
+ /* PR binutils/18087: If compression didn't make the section smaller,
+ just keep it uncompressed. */
+ if (compressed_size >= uncompressed_size)
+ return;
+
/* Replace the uncompressed frag list with the compressed frag list. */
seginfo->frchainP->frch_root = first_newf;
seginfo->frchainP->frch_last = last_newf;
/* Update the section size and its name. */
+ bfd_update_compression_header (abfd, (bfd_byte *) header, sec);
x = bfd_set_section_size (abfd, sec, compressed_size);
gas_assert (x);
- compressed_name = (char *) xmalloc (strlen (section_name) + 2);
- compressed_name[0] = '.';
- compressed_name[1] = 'z';
- strcpy (compressed_name + 2, section_name + 1);
- bfd_section_name (stdoutput, sec) = compressed_name;
+ if (!compression_header_size)
+ {
+ compressed_name = concat (".z", section_name + 1, (char *) NULL);
+ bfd_section_name (stdoutput, sec) = compressed_name;
+ }
}
static void
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 (_("can't write %ld bytes to section %s of %s because: '%s'"),
+ (long) f->fr_fix, sec->name,
+ stdoutput->filename,
bfd_errmsg (bfd_get_error ()));
offset += f->fr_fix;
}
(file_ptr) offset,
(bfd_size_type) fill_size);
if (!x)
- as_fatal (_("can't write %s: %s"), stdoutput->filename,
+ as_fatal (_("can't fill %ld bytes in section %s of %s because '%s'"),
+ (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"),
+ as_fatal (_("cannot fill %ld bytes in section %s of %s because: '%s'"),
+ (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. */
of the section. This allows proper nop-filling at the end of
code-bearing sections. */
#define SUB_SEGMENT_ALIGN(SEG, FRCHAIN) \
- (!(FRCHAIN)->frch_next ? get_recorded_alignment (SEG) : 0)
+ (!(FRCHAIN)->frch_next && subseg_text_p (SEG) \
+ && !do_not_pad_sections_to_alignment \
+ ? get_recorded_alignment (SEG) \
+ : 0)
#else
#define SUB_SEGMENT_ALIGN(SEG, FRCHAIN) 0
#endif
#endif
-void
-subsegs_finish (void)
+static void
+subsegs_finish_section (asection *s)
{
struct frchain *frchainP;
- asection *s;
+ segment_info_type *seginfo = seg_info (s);
+ if (!seginfo)
+ return;
- for (s = stdoutput->sections; s; s = s->next)
+ for (frchainP = seginfo->frchainP;
+ frchainP != NULL;
+ frchainP = frchainP->frch_next)
{
- segment_info_type *seginfo = seg_info (s);
- if (!seginfo)
- continue;
+ int alignment;
- for (frchainP = seginfo->frchainP;
- frchainP != NULL;
- frchainP = frchainP->frch_next)
- {
- int alignment = 0;
+ subseg_set (s, frchainP->frch_subseg);
- 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 ())
+ do_not_pad_sections_to_alignment = 1;
- /* 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;
+ 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;
- while ((entsize & 1) == 0)
- {
- ++entalign;
- entsize >>= 1;
- }
- if (entalign > alignment)
- alignment = entalign;
- }
+ while ((entsize & 1) == 0)
+ {
+ ++entalign;
+ entsize >>= 1;
}
- if (subseg_text_p (now_seg))
- frag_align_code (alignment, 0);
- else
- frag_align (alignment, 0, 0);
+ if (entalign > alignment)
+ alignment = entalign;
+ }
- /* frag_align will have left a new frag.
- Use this last frag for an empty ".fill".
+ if (subseg_text_p (now_seg))
+ frag_align_code (alignment, 0);
+ else
+ frag_align (alignment, 0, 0);
- For this segment ...
- Create a last frag. Do not leave a "being filled in frag". */
- frag_wane (frag_now);
- frag_now->fr_fix = 0;
- know (frag_now->fr_next == NULL);
- }
+ /* frag_align will have left a new frag.
+ Use this last frag for an empty ".fill".
+
+ For this segment ...
+ Create a last frag. Do not leave a "being filled in frag". */
+ frag_wane (frag_now);
+ frag_now->fr_fix = 0;
+ know (frag_now->fr_next == NULL);
}
}
+static void
+subsegs_finish (void)
+{
+ asection *s;
+
+ for (s = stdoutput->sections; s; s = s->next)
+ subsegs_finish_section (s);
+}
+
+#ifdef OBJ_ELF
+static void
+create_obj_attrs_section (void)
+{
+ segT s;
+ char *p;
+ offsetT size;
+ const char *name;
+
+ size = bfd_elf_obj_attr_size (stdoutput);
+ if (size)
+ {
+ name = get_elf_backend_data (stdoutput)->obj_attrs_section;
+ if (!name)
+ name = ".gnu.attributes";
+ s = subseg_new (name, 0);
+ elf_section_type (s)
+ = get_elf_backend_data (stdoutput)->obj_attrs_section_type;
+ bfd_set_section_flags (stdoutput, s, SEC_READONLY | SEC_DATA);
+ frag_now_fix ();
+ p = frag_more (size);
+ bfd_elf_set_obj_attr_contents (stdoutput, (bfd_byte *)p, size);
+
+ subsegs_finish_section (s);
+ relax_segment (seg_info (s)->frchainP->frch_root, s, 0);
+ size_seg (stdoutput, s, NULL);
+ }
+}
+#endif
+
/* Write the object file. */
void
fragS *fragP; /* Track along all frags. */
#endif
+ subsegs_finish ();
+
#ifdef md_pre_output_hook
md_pre_output_hook;
#endif
- /* Do we really want to write it? */
- {
- int n_warns, n_errs;
- n_warns = had_warnings ();
- n_errs = had_errors ();
- /* The -Z flag indicates that an object file should be generated,
- regardless of warnings and errors. */
- if (flag_always_generate_output)
- {
- if (n_warns || n_errs)
- as_warn (_("%d error%s, %d warning%s, generating bad object file"),
- n_errs, n_errs == 1 ? "" : "s",
- n_warns, n_warns == 1 ? "" : "s");
- }
- else
- {
- if (n_errs)
- as_fatal (_("%d error%s, %d warning%s, no object file generated"),
- n_errs, n_errs == 1 ? "" : "s",
- n_warns, n_warns == 1 ? "" : "s");
- }
- }
-
#ifdef md_pre_relax_hook
md_pre_relax_hook;
#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
+#ifdef OBJ_ELF
+ if (IS_ELF)
+ create_obj_attrs_section ();
+#endif
+
#ifndef WORKING_DOT_WORD
{
struct broken_word *lie;
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);
}
/* Relax_align. Advance location counter to next address that has 'alignment'
lowest order bits all 0s, return size of adjustment made. */
static relax_addressT
-relax_align (register relax_addressT address, /* Address now. */
- register int alignment /* Alignment (binary). */)
+relax_align (relax_addressT address, /* Address now. */
+ int alignment /* Alignment (binary). */)
{
relax_addressT mask;
relax_addressT new_address;
- mask = ~((~0) << alignment);
+ mask = ~((relax_addressT) ~0 << alignment);
new_address = (address + mask) & (~mask);
#ifdef LINKER_RELAXING_SHRINKS_ONLY
if (linkrelax)
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"));