WebSVN – Kolibri OS – Diff – /contrib/toolchain/binutils/gas/write.c

 /* write.c - emit .o file
-   Copyright 1986, 1987, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
-, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
-, 2011, 2012 Free Software Foundation, Inc.
+   Copyright (C) 1986-2015 Free Software Foundation, Inc.
    This file is part of GAS, the GNU Assembler.
 	symsec = S_GET_SEGMENT (sym);
 	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.  */
   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;
+  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;
   char *compressed_name;
   char *header;
   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
       || (flags & (SEC_ALLOC | SEC_HAS_CONTENTS)) == SEC_ALLOC)
   strm = compress_init ();
   if (strm == NULL)
+    return;
+  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;
-    return;
+    }
-  /* Create a new frag to contain the "ZLIB" header.  */
+  /* 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)
+  if (obstack_room (ob) < header_size)
-    as_fatal (_("can't extend frag %u chars"), 12);
+    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;
-  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;
+  last_newf->fr_fix = header_size;
-  header[4] = uncompressed_size;
+  header = last_newf->fr_literal;
-  compressed_size = 12;
+  compressed_size = header_size;
   /* Stream the frags through the compression engine, adding new frags
       if (x == 0)
 	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;
   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);
-  /* Update the section size and its name.  */
+  gas_assert (x);
-  x = bfd_set_section_size (abfd, sec, compressed_size);
+  if (!compression_header_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);
-  strcpy (compressed_name + 2, section_name + 1);
+  bfd_section_name (stdoutput, sec) = compressed_name;
   bfd_section_name (stdoutput, sec) = compressed_name;
+}
+	{
 	  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 (_("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;
+	}
       fill_literal = f->fr_literal + f->fr_fix;
       fill_size = f->fr_var;
 		  x = bfd_set_section_contents (stdoutput, sec,
 						fill_literal,
 						(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;
+		}
+	    }
 	  else
 		  n_per_buf = n_per_buf > count ? count : n_per_buf;
 		  x = bfd_set_section_contents
 		    (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;
+		}
+	    }
 #ifdef HANDLE_ALIGN
 /* The last subsegment gets an alignment corresponding to the alignment
    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)				\
+   ? get_recorded_alignment (SEG)					\
+   : 0)
 #else
 #define SUB_SEGMENT_ALIGN(SEG, FRCHAIN) 0
 #endif
 #endif
-void
+static void
-subsegs_finish (void)
+subsegs_finish_section (asection *s)
+{
-  struct frchain *frchainP;
-  asection *s;
-  for (s = stdoutput->sections; s; s = s->next)
   struct frchain *frchainP;
       segment_info_type *seginfo = seg_info (s);
       if (!seginfo)
-	continue;
+    return;
       for (frchainP = seginfo->frchainP;
 	   frchainP != NULL;
 		  while ((entsize & 1) == 0)
+		    {
 		      ++entalign;
 		      entsize >>= 1;
+		    }
 		  if (entalign > alignment)
 		    alignment = entalign;
+		}
+	    }
 	  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.  */
   struct relax_seg_info rsi;
 #ifndef WORKING_DOT_WORD
   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");
-      }
 #endif
 #ifdef md_pre_relax_hook
   md_pre_relax_hook;
 #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
+  {
 	  exp.X_op_symbol = lie->sub;
 	  exp.X_add_number = lie->addnum;
 #ifdef TC_CONS_FIX_NEW
 	  TC_CONS_FIX_NEW (lie->frag,
 			   lie->word_goes_here - lie->frag->fr_literal,
-, &exp);
+, &exp, TC_PARSE_CONS_RETURN_NONE);
 #else
 	  fix_new_exp (lie->frag,
 		       lie->word_goes_here - lie->frag->fr_literal,
 , &exp, 0, BFD_RELOC_16);
 #endif
 #endif /* defined (TC_GENERIC_RELAX_TABLE)  */
 /* 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.  */
+relax_align (relax_addressT address,	/* Address now.  */
-	     register int alignment	/* Alignment (binary).  */)
+	     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)

Subversion Repositories Kolibri OS

(root)/contrib/toolchain/binutils/gas/write.c – Rev 5222 → 6324