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

 /* frags.c - manage frags -
-   Copyright 1987, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
-, 2000, 2001, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2011, 2012
-   Free Software Foundation, Inc.
+   Copyright (C) 1987-2015 Free Software Foundation, Inc.
    This file is part of GAS, the GNU Assembler.
 #include "obstack.h"
 extern fragS zero_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.  */
 void
   oalign = obstack_alignment_mask (ob);
   obstack_alignment_mask (ob) = 0;
   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.
    If there is no room, close of the current frag with a ".fill 0"
    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;
+      size_t oldc;
-      long newc;
+      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
       else
         newc = nchars + 0x10000;
       newc += SIZEOF_STRUCT_FRAG;
       /* Check for possible overflow.  */
-      if (newc < 0)
+      if (newc < nchars)
-        as_fatal (_("can't extend frag %u chars"), 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.  */
    Make a new frag, initialising some components. Link new frag at end
    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.  */)
+{
    Return the address of the 1st char to write into. Advance
    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;
+}
 /* Close the current frag, setting its fields for a relaxable frag.  Start a
    new frag.  */
 static void
-frag_var_init (relax_stateT type, int max_chars, int var,
+frag_var_init (relax_stateT type, size_t max_chars, size_t var,
-               relax_substateT subtype, symbolS *symbol, offsetT offset,
+	       relax_substateT subtype, symbolS *symbol, offsetT offset,
    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,
+frag_var (relax_stateT type, size_t max_chars, size_t var,
+	  relax_substateT subtype, symbolS *symbol, offsetT offset,
-	  symbolS *symbol, offsetT offset, char *opcode)
+	  char *opcode)
 {
-  register char *retval;
+  char *retval;
   frag_grow (max_chars);
   retval = obstack_next_free (&frchain_now->frch_obstack);
 /* OVE: This variant of frag_var assumes that space for the tail has been
 	allocated by caller.
 	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_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;
   fragP->fr_var = 0;
+}
 /* Return the number of bytes by which the current frag can be grown.  */
-int
+size_t
    FILL_PATTERN.  MAX is the maximum number of characters to skip when
    doing the alignment, or 0 if there is no maximum.  */
 void
 frag_align_pattern (int alignment, const char *fill_pattern,
-		    int n_fill, int max)
+		    size_t n_fill, int max)
+{
   char *p;

Subversion Repositories Kolibri OS

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