Add R_X86_64_RELATIVE64.

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

diff --git a/gas/frags.c b/gas/frags.c
index a0a0a298c996d577d7f926aad885b7a6bed653fc..fb3c02d3b5d4af868f83ab7f7351d8d8b8cd1294 100644 (file)
--- a/gas/frags.c
+++ b/gas/frags.c
@@ -75,9 +75,10 @@ frag_alloc (struct obstack *ob)
   return ptr;
 }
 \f
-/* 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)
@@ -87,9 +88,6 @@ frag_grow (unsigned int nchars)
       long oldc;
       long newc;
 
-      /* Not enough room in this frag.  Close it.  */
-      frag_wane (frag_now);
-
       /* 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.  */
@@ -99,22 +97,25 @@ 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 < 0)
+        as_fatal (_("can't extend frag %u chars"), nchars);
 
-          /* Do the real work: create a new frag.  */
-          frag_new (0);
+      /* Force to allocate at least NEWC bytes.  */
+      oldc = obstack_chunk_size (&frchain_now->frch_obstack);
+      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;
     }
 }
 \f
@@ -199,22 +200,14 @@ frag_more (int nchars)
   return (retval);
 }
 \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.
-
-   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, int max_chars, int 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;
@@ -230,8 +223,28 @@ frag_var (relax_stateT type, int max_chars, int var, relax_substateT subtype,
   TC_FRAG_INIT (frag_now);
 #endif
   as_where (&frag_now->fr_file, &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, int max_chars, int 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_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
@@ -246,23 +259,9 @@ frag_variant (relax_stateT type, int max_chars, int var,
   register 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;
 }
 \f
 /* Reduce the variable end of a frag to a harmless state.  */