X-Git-Url: http://drtracing.org/?a=blobdiff_plain;ds=sidebyside;f=gas%2Ffrags.c;h=9ff577fc633a1334f4ff113edf4ac4fca0d49903;hb=16a1fa25be5705102b84ef0ea6eea71312328c2c;hp=a0a0a298c996d577d7f926aad885b7a6bed653fc;hpb=179809c050ff97d2f72bab90b8b6fdc7f95eb0b7;p=deliverable%2Fbinutils-gdb.git

diff --git a/gas/frags.c b/gas/frags.c
index a0a0a298c9..9ff577fc63 100644
--- a/gas/frags.c
+++ b/gas/frags.c
@@ -1,7 +1,5 @@
 /* frags.c - manage frags -
-   Copyright 1987, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
-   1999, 2000, 2001, 2003, 2004, 2005, 2006, 2007, 2008, 2009
-   Free Software Foundation, Inc.
+   Copyright (C) 1987-2016 Free Software Foundation, Inc.
 
    This file is part of GAS, the GNU Assembler.
 
@@ -25,7 +23,21 @@
 #include "obstack.h"
 
 extern fragS zero_address_frag;
-extern fragS bss_address_frag;
+extern fragS predefined_address_frag;
+
+static int totalfrags;
+
+int
+get_frag_count (void)
+{
+  return totalfrags;
+}
+
+void
+clear_frag_count (void)
+{
+  totalfrags = 0;
+}
 
 /* Initialization for frag routines.  */
 
@@ -33,7 +45,7 @@ void
 frag_init (void)
 {
   zero_address_frag.fr_type = rs_fill;
-  bss_address_frag.fr_type = rs_fill;
+  predefined_address_frag.fr_type = rs_fill;
 }
 
 /* Check that we're not trying to assemble into a section that can't
@@ -72,23 +84,22 @@ frag_alloc (struct obstack *ob)
   ptr = (fragS *) obstack_alloc (ob, SIZEOF_STRUCT_FRAG);
   obstack_alignment_mask (ob) = oalign;
   memset (ptr, 0, SIZEOF_STRUCT_FRAG);
+  totalfrags++;
   return ptr;
 }
 
-/* Try to augment current frag by NCHARS chars.
+/* Try to augment current frag by nchars chars.
    If there is no room, close of the current frag with a ".fill 0"
-   and begin a new frag.  Do not set up any fields of *now_frag.  */
+   and begin a new frag. Unless the new frag has nchars chars available
+   do not return. Do not set up any fields of *now_frag.  */
 
 void
-frag_grow (unsigned int nchars)
+frag_grow (size_t nchars)
 {
   if (obstack_room (&frchain_now->frch_obstack) < nchars)
     {
-      long oldc;
-      long newc;
-
-      /* Not enough room in this frag.  Close it.  */
-      frag_wane (frag_now);
+      size_t oldc;
+      size_t newc;
 
       /* Try to allocate a bit more than needed right now.  But don't do
          this if we would waste too much memory.  Especially necessary
@@ -99,22 +110,27 @@ frag_grow (unsigned int nchars)
         newc = nchars + 0x10000;
       newc += SIZEOF_STRUCT_FRAG;
 
-      if (newc > 0)
-        {
-          /* Force to allocate at least NEWC bytes.  */
-          oldc = obstack_chunk_size (&frchain_now->frch_obstack);
-          obstack_chunk_size (&frchain_now->frch_obstack) = newc;
+      /* Check for possible overflow.  */
+      if (newc < nchars)
+        as_fatal (_("can't extend frag %lu chars"), (unsigned long) nchars);
 
-          /* Do the real work: create a new frag.  */
-          frag_new (0);
+      /* Force to allocate at least NEWC bytes, but not less than the
+         default.  */
+      oldc = obstack_chunk_size (&frchain_now->frch_obstack);
+      if (newc > oldc)
+	obstack_chunk_size (&frchain_now->frch_obstack) = newc;
 
-          /* Restore the old chunk size.  */
-          obstack_chunk_size (&frchain_now->frch_obstack) = oldc;
+      while (obstack_room (&frchain_now->frch_obstack) < nchars)
+        {
+          /* Not enough room in this frag.  Close it and start a new one.
+             This must be done in a loop because the created frag may not
+             be big enough if the current obstack chunk is used.  */
+          frag_wane (frag_now);
+          frag_new (0);
         }
 
-      /* Check for success (also handles negative values of NEWC).  */
-      if (obstack_room (&frchain_now->frch_obstack) < nchars)
-        as_fatal (_("can't extend frag %u chars"), nchars);
+      /* Restore the old chunk size.  */
+      obstack_chunk_size (&frchain_now->frch_obstack) = oldc;
     }
 }
 
@@ -136,7 +152,7 @@ frag_grow (unsigned int nchars)
    of frchain_now.  */
 
 void
-frag_new (int old_frags_var_max_size
+frag_new (size_t old_frags_var_max_size
 	  /* Number of chars (already allocated on obstack frags) in
 	     variable_length part of frag.  */)
 {
@@ -160,7 +176,7 @@ frag_new (int old_frags_var_max_size
   gas_assert (former_last_fragP == frag_now);
   frag_now = frag_alloc (&frchP->frch_obstack);
 
-  as_where (&frag_now->fr_file, &frag_now->fr_line);
+  frag_now->fr_file = as_where (&frag_now->fr_line);
 
   /* Generally, frag_now->points to an address rounded up to next
      alignment.  However, characters will add to obstack frags
@@ -188,33 +204,25 @@ frag_new (int old_frags_var_max_size
    frag_now_growth past the new chars.  */
 
 char *
-frag_more (int nchars)
+frag_more (size_t nchars)
 {
-  register char *retval;
+  char *retval;
 
   frag_alloc_check (&frchain_now->frch_obstack);
   frag_grow (nchars);
   retval = obstack_next_free (&frchain_now->frch_obstack);
   obstack_blank_fast (&frchain_now->frch_obstack, nchars);
-  return (retval);
+  return retval;
 }
 
-/* Start a new frag unless we have max_chars more chars of room in the
-   current frag.  Close off the old frag with a .fill 0.
-
-   Set up a machine_dependent relaxable frag, then start a new frag.
-   Return the address of the 1st char of the var part of the old frag
-   to write into.  */
+/* Close the current frag, setting its fields for a relaxable frag.  Start a
+   new frag.  */
 
-char *
-frag_var (relax_stateT type, int max_chars, int var, relax_substateT subtype,
-	  symbolS *symbol, offsetT offset, char *opcode)
+static void
+frag_var_init (relax_stateT type, size_t max_chars, size_t var,
+	       relax_substateT subtype, symbolS *symbol, offsetT offset,
+               char *opcode)
 {
-  register char *retval;
-
-  frag_grow (max_chars);
-  retval = obstack_next_free (&frchain_now->frch_obstack);
-  obstack_blank_fast (&frchain_now->frch_obstack, max_chars);
   frag_now->fr_var = var;
   frag_now->fr_type = type;
   frag_now->fr_subtype = subtype;
@@ -229,9 +237,30 @@ frag_var (relax_stateT type, int max_chars, int var, relax_substateT subtype,
 #ifdef TC_FRAG_INIT
   TC_FRAG_INIT (frag_now);
 #endif
-  as_where (&frag_now->fr_file, &frag_now->fr_line);
+  frag_now->fr_file = as_where (&frag_now->fr_line);
+
   frag_new (max_chars);
-  return (retval);
+}
+
+/* Start a new frag unless we have max_chars more chars of room in the
+   current frag.  Close off the old frag with a .fill 0.
+
+   Set up a machine_dependent relaxable frag, then start a new frag.
+   Return the address of the 1st char of the var part of the old frag
+   to write into.  */
+
+char *
+frag_var (relax_stateT type, size_t max_chars, size_t var,
+	  relax_substateT subtype, symbolS *symbol, offsetT offset,
+	  char *opcode)
+{
+  char *retval;
+
+  frag_grow (max_chars);
+  retval = obstack_next_free (&frchain_now->frch_obstack);
+  obstack_blank_fast (&frchain_now->frch_obstack, max_chars);
+  frag_var_init (type, max_chars, var, subtype, symbol, offset, opcode);
+  return retval;
 }
 
 /* OVE: This variant of frag_var assumes that space for the tail has been
@@ -239,36 +268,22 @@ frag_var (relax_stateT type, int max_chars, int var, relax_substateT subtype,
 	No call to frag_grow is done.  */
 
 char *
-frag_variant (relax_stateT type, int max_chars, int var,
+frag_variant (relax_stateT type, size_t max_chars, size_t var,
 	      relax_substateT subtype, symbolS *symbol, offsetT offset,
 	      char *opcode)
 {
-  register char *retval;
+  char *retval;
 
   retval = obstack_next_free (&frchain_now->frch_obstack);
-  frag_now->fr_var = var;
-  frag_now->fr_type = type;
-  frag_now->fr_subtype = subtype;
-  frag_now->fr_symbol = symbol;
-  frag_now->fr_offset = offset;
-  frag_now->fr_opcode = opcode;
-#ifdef USING_CGEN
-  frag_now->fr_cgen.insn = 0;
-  frag_now->fr_cgen.opindex = 0;
-  frag_now->fr_cgen.opinfo = 0;
-#endif
-#ifdef TC_FRAG_INIT
-  TC_FRAG_INIT (frag_now);
-#endif
-  as_where (&frag_now->fr_file, &frag_now->fr_line);
-  frag_new (max_chars);
-  return (retval);
+  frag_var_init (type, max_chars, var, subtype, symbol, offset, opcode);
+
+  return retval;
 }
 
 /* Reduce the variable end of a frag to a harmless state.  */
 
 void
-frag_wane (register fragS *fragP)
+frag_wane (fragS *fragP)
 {
   fragP->fr_type = rs_fill;
   fragP->fr_offset = 0;
@@ -277,7 +292,7 @@ frag_wane (register fragS *fragP)
 
 /* Return the number of bytes by which the current frag can be grown.  */
 
-int
+size_t
 frag_room (void)
 {
   return obstack_room (&frchain_now->frch_obstack);
@@ -322,7 +337,7 @@ frag_align (int alignment, int fill_character, int max)
 
 void
 frag_align_pattern (int alignment, const char *fill_pattern,
-		    int n_fill, int max)
+		    size_t n_fill, int max)
 {
   char *p;
 
@@ -395,10 +410,10 @@ frag_append_1_char (int datum)
    not already accounted for in the frag FR_ADDRESS.  */
 
 bfd_boolean
-frag_offset_fixed_p (const fragS *frag1, const fragS *frag2, bfd_vma *offset)
+frag_offset_fixed_p (const fragS *frag1, const fragS *frag2, offsetT *offset)
 {
   const fragS *frag;
-  bfd_vma off;
+  offsetT off;
 
   /* Start with offset initialised to difference between the two frags.
      Prior to assigning frag addresses this will be zero.  */