rx: make field type enum

[deliverable/binutils-gdb.git] / gas / frags.c

diff --git a/gas/frags.c b/gas/frags.c
index cfd183fb3d41ec63d70add20111b0a97161e7430..9ff577fc633a1334f4ff113edf4ac4fca0d49903 100644 (file)
--- a/gas/frags.c
+++ b/gas/frags.c
@@ -1,13 +1,11 @@
 /* frags.c - manage frags -
 /* frags.c - manage frags -

-   Copyright 1987, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
-   1999, 2000, 2001, 2003, 2004, 2005, 2006
-   Free Software Foundation, Inc.
+   Copyright (C) 1987-2016 Free Software Foundation, Inc.

 
    This file is part of GAS, the GNU Assembler.
 
    GAS is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
 
    This file is part of GAS, the GNU Assembler.
 
    GAS is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by

-   the Free Software Foundation; either version 2, or (at your option)
+   the Free Software Foundation; either version 3, or (at your option)

    any later version.
 
    GAS is distributed in the hope that it will be useful,
    any later version.
 
    GAS is distributed in the hope that it will be useful,


@@ -25,7 +23,21 @@
 #include "obstack.h"
 
 extern fragS zero_address_frag;
 #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;
+}

 \f
 /* Initialization for frag routines.  */
 
 \f
 /* Initialization for frag routines.  */
 


@@ -33,7 +45,7 @@ void
 frag_init (void)
 {
   zero_address_frag.fr_type = rs_fill;
 frag_init (void)
 {
   zero_address_frag.fr_type = rs_fill;

-  bss_address_frag.fr_type = rs_fill;
+  predefined_address_frag.fr_type = rs_fill;

 }
 \f
 /* Check that we're not trying to assemble into a section that can't
 }
 \f
 /* Check that we're not trying to assemble into a section that can't


@@ -72,6 +84,7 @@ frag_alloc (struct obstack *ob)
   ptr = (fragS *) obstack_alloc (ob, SIZEOF_STRUCT_FRAG);
   obstack_alignment_mask (ob) = oalign;
   memset (ptr, 0, SIZEOF_STRUCT_FRAG);
   ptr = (fragS *) obstack_alloc (ob, SIZEOF_STRUCT_FRAG);
   obstack_alignment_mask (ob) = oalign;
   memset (ptr, 0, SIZEOF_STRUCT_FRAG);

+  totalfrags++;

   return ptr;
 }
 \f
   return ptr;
 }
 \f


@@ -81,35 +94,44 @@ frag_alloc (struct obstack *ob)
    do not return. Do not set up any fields of *now_frag.  */
 
 void
    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)
     {
 {
   if (obstack_room (&frchain_now->frch_obstack) < nchars)
     {

-      unsigned int n;
-      long oldc;
+      size_t oldc;
+      size_t newc;

 
 

-      frag_wane (frag_now);
-      frag_new (0);
-      oldc = frchain_now->frch_obstack.chunk_size;

       /* Try to allocate a bit more than needed right now.  But don't do
          this if we would waste too much memory.  Especially necessary
       /* Try to allocate a bit more than needed right now.  But don't do
          this if we would waste too much memory.  Especially necessary

-        for extremely big (like 2GB initialized) frags.  */
+         for extremely big (like 2GB initialized) frags.  */

       if (nchars < 0x10000)
       if (nchars < 0x10000)

-       frchain_now->frch_obstack.chunk_size = 2 * nchars;
+        newc = 2 * nchars;

       else
       else

-        frchain_now->frch_obstack.chunk_size = nchars + 0x10000;
-      frchain_now->frch_obstack.chunk_size += SIZEOF_STRUCT_FRAG;
-      if (frchain_now->frch_obstack.chunk_size > 0)
-       while ((n = obstack_room (&frchain_now->frch_obstack)) < nchars
-              && (unsigned long) frchain_now->frch_obstack.chunk_size > nchars)
-         {
-           frag_wane (frag_now);
-           frag_new (0);
-         }
-      frchain_now->frch_obstack.chunk_size = oldc;
+        newc = nchars + 0x10000;
+      newc += SIZEOF_STRUCT_FRAG;
+
+      /* Check for possible overflow.  */
+      if (newc < nchars)
+        as_fatal (_("can't extend frag %lu chars"), (unsigned long) nchars);
+
+      /* 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;
+
+      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);
+        }
+
+      /* Restore the old chunk size.  */
+      obstack_chunk_size (&frchain_now->frch_obstack) = oldc;

     }
     }

-  if (obstack_room (&frchain_now->frch_obstack) < nchars)
-    as_fatal (_("can't extend frag %u chars"), nchars);

 }
 \f
 /* Call this to close off a completed frag, and start up a new (empty)
 }
 \f
 /* Call this to close off a completed frag, and start up a new (empty)


@@ -130,19 +152,19 @@ frag_grow (unsigned int nchars)
    of frchain_now.  */
 
 void
    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.  */)
 {
   fragS *former_last_fragP;
   frchainS *frchP;
 
          /* Number of chars (already allocated on obstack frags) in
             variable_length part of frag.  */)
 {
   fragS *former_last_fragP;
   frchainS *frchP;
 

-  assert (frchain_now->frch_last == frag_now);
+  gas_assert (frchain_now->frch_last == frag_now);

 
   /* Fix up old frag's fr_fix.  */
   frag_now->fr_fix = frag_now_fix_octets () - old_frags_var_max_size;
   /* Make sure its type is valid.  */
 
   /* Fix up old frag's fr_fix.  */
   frag_now->fr_fix = frag_now_fix_octets () - old_frags_var_max_size;
   /* Make sure its type is valid.  */

-  assert (frag_now->fr_type != 0);
+  gas_assert (frag_now->fr_type != 0);

 
   /* This will align the obstack so the next struct we allocate on it
      will begin at a correct boundary.  */
 
   /* This will align the obstack so the next struct we allocate on it
      will begin at a correct boundary.  */


@@ -150,11 +172,11 @@ frag_new (int old_frags_var_max_size
   frchP = frchain_now;
   know (frchP);
   former_last_fragP = frchP->frch_last;
   frchP = frchain_now;
   know (frchP);
   former_last_fragP = frchP->frch_last;

-  assert (former_last_fragP != 0);
-  assert (former_last_fragP == frag_now);
+  gas_assert (former_last_fragP != 0);
+  gas_assert (former_last_fragP == frag_now);

   frag_now = frag_alloc (&frchP->frch_obstack);
 
   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
 
   /* Generally, frag_now->points to an address rounded up to next
      alignment.  However, characters will add to obstack frags


@@ -170,7 +192,7 @@ frag_new (int old_frags_var_max_size
   }
 #endif
 
   }
 #endif
 

-  assert (frchain_now->frch_last == frag_now);
+  gas_assert (frchain_now->frch_last == frag_now);

 
   frag_now->fr_next = NULL;
 }
 
   frag_now->fr_next = NULL;
 }


@@ -182,33 +204,25 @@ frag_new (int old_frags_var_max_size
    frag_now_growth past the new chars.  */
 
 char *
    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);
 
   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;

 }
 \f
 }
 \f

-/* 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.
+/* Close the current frag, setting its fields for a relaxable frag.  Start a
+   new frag.  */

 
 

-   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, 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;
   frag_now->fr_var = var;
   frag_now->fr_type = type;
   frag_now->fr_subtype = subtype;


@@ -223,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
 #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);
   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;

 }
 \f
 /* OVE: This variant of frag_var assumes that space for the tail has been
 }
 \f
 /* OVE: This variant of frag_var assumes that space for the tail has been


@@ -233,36 +268,22 @@ frag_var (relax_stateT type, int max_chars, int var, relax_substateT subtype,
        No call to frag_grow is done.  */
 
 char *
        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)
 {
              relax_substateT subtype, symbolS *symbol, offsetT offset,
              char *opcode)
 {

-  register char *retval;
+  char *retval;

 
   retval = obstack_next_free (&frchain_now->frch_obstack);
 
   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;

 }
 \f
 /* Reduce the variable end of a frag to a harmless state.  */
 
 void
 }
 \f
 /* 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;
 {
   fragP->fr_type = rs_fill;
   fragP->fr_offset = 0;


@@ -271,7 +292,7 @@ frag_wane (register fragS *fragP)
 \f
 /* Return the number of bytes by which the current frag can be grown.  */
 
 \f
 /* 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);
 frag_room (void)
 {
   return obstack_room (&frchain_now->frch_obstack);


@@ -316,7 +337,7 @@ frag_align (int alignment, int fill_character, int max)
 
 void
 frag_align_pattern (int alignment, const char *fill_pattern,
 
 void
 frag_align_pattern (int alignment, const char *fill_pattern,

-                   int n_fill, int max)
+                   size_t n_fill, int max)

 {
   char *p;
 
 {
   char *p;
 


@@ -389,10 +410,10 @@ frag_append_1_char (int datum)
    not already accounted for in the frag FR_ADDRESS.  */
 
 bfd_boolean
    not already accounted for in the frag FR_ADDRESS.  */
 
 bfd_boolean

-frag_offset_fixed_p (fragS *frag1, fragS *frag2, bfd_vma *offset)
+frag_offset_fixed_p (const fragS *frag1, const fragS *frag2, offsetT *offset)

 {
 {

-  fragS *frag;
-  bfd_vma off;
+  const fragS *frag;
+  offsetT off;

 
   /* Start with offset initialised to difference between the two frags.
      Prior to assigning frag addresses this will be zero.  */
 
   /* Start with offset initialised to difference between the two frags.
      Prior to assigning frag addresses this will be zero.  */


@@ -419,6 +440,7 @@ frag_offset_fixed_p (fragS *frag1, fragS *frag2, bfd_vma *offset)
     }
 
   /* Maybe frag1 is after frag2.  */
     }
 
   /* Maybe frag1 is after frag2.  */

+  off = frag1->fr_address - frag2->fr_address;

   frag = frag2;
   while (frag->fr_type == rs_fill)
     {
   frag = frag2;
   while (frag->fr_type == rs_fill)
     {