/* frags.c - manage frags -
Copyright 1987, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
- 1999, 2000
+ 1999, 2000, 2001, 2003, 2004, 2005, 2006
Free Software Foundation, Inc.
This file is part of GAS, the GNU Assembler.
You should have received a copy of the GNU General Public License
along with GAS; see the file COPYING. If not, write to the Free
- Software Foundation, 59 Temple Place - Suite 330, Boston, MA
- 02111-1307, USA. */
+ Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
+ 02110-1301, USA. */
#include "as.h"
#include "subsegs.h"
/* Initialization for frag routines. */
void
-frag_init ()
+frag_init (void)
{
zero_address_frag.fr_type = rs_fill;
bss_address_frag.fr_type = rs_fill;
}
\f
+/* Check that we're not trying to assemble into a section that can't
+ allocate frags (currently, this is only possible in the absolute
+ section), or into an mri common. */
+
+static void
+frag_alloc_check (const struct obstack *ob)
+{
+ if (ob->chunk_size == 0)
+ {
+ as_bad (_("attempt to allocate data in absolute section"));
+ subseg_set (text_section, 0);
+ }
+
+ if (mri_common_symbol != NULL)
+ {
+ as_bad (_("attempt to allocate data in common section"));
+ mri_common_symbol = NULL;
+ }
+}
+
/* Allocate a frag on the specified obstack.
Call this routine from everywhere else, so that all the weird alignment
hackery can be done in just one place. */
fragS *
-frag_alloc (ob)
- struct obstack *ob;
+frag_alloc (struct obstack *ob)
{
fragS *ptr;
int oalign;
do not return. Do not set up any fields of *now_frag. */
void
-frag_grow (nchars)
- unsigned int nchars;
+frag_grow (unsigned int nchars)
{
if (obstack_room (&frchain_now->frch_obstack) < nchars)
{
frag_wane (frag_now);
frag_new (0);
oldc = frchain_now->frch_obstack.chunk_size;
- frchain_now->frch_obstack.chunk_size = 2 * nchars + SIZEOF_STRUCT_FRAG;
+ /* 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. */
+ if (nchars < 0x10000)
+ frchain_now->frch_obstack.chunk_size = 2 * nchars;
+ 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)
of frchain_now. */
void
-frag_new (old_frags_var_max_size)
- /* Number of chars (already allocated on obstack frags) in
- variable_length part of frag. */
- int old_frags_var_max_size;
+frag_new (int 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;
frag_now_growth past the new chars. */
char *
-frag_more (nchars)
- int nchars;
+frag_more (int nchars)
{
register char *retval;
- if (now_seg == absolute_section)
- {
- as_bad (_("attempt to allocate data in absolute section"));
- subseg_set (text_section, 0);
- }
-
- if (mri_common_symbol != NULL)
- {
- as_bad (_("attempt to allocate data in common section"));
- mri_common_symbol = NULL;
- }
-
+ 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);
to write into. */
char *
-frag_var (type, max_chars, var, subtype, symbol, offset, opcode)
- relax_stateT type;
- int max_chars;
- int var;
- relax_substateT subtype;
- symbolS *symbol;
- offsetT offset;
- char *opcode;
+frag_var (relax_stateT type, int max_chars, int var, relax_substateT subtype,
+ symbolS *symbol, offsetT offset, char *opcode)
{
register char *retval;
No call to frag_grow is done. */
char *
-frag_variant (type, max_chars, var, subtype, symbol, offset, opcode)
- relax_stateT type;
- int max_chars;
- int var;
- relax_substateT subtype;
- symbolS *symbol;
- offsetT offset;
- char *opcode;
+frag_variant (relax_stateT type, int max_chars, int var,
+ relax_substateT subtype, symbolS *symbol, offsetT offset,
+ char *opcode)
{
register char *retval;
/* Reduce the variable end of a frag to a harmless state. */
void
-frag_wane (fragP)
- register fragS *fragP;
+frag_wane (register fragS *fragP)
{
fragP->fr_type = rs_fill;
fragP->fr_offset = 0;
fragP->fr_var = 0;
}
\f
+/* Return the number of bytes by which the current frag can be grown. */
+
+int
+frag_room (void)
+{
+ return obstack_room (&frchain_now->frch_obstack);
+}
+\f
/* Make an alignment frag. The size of this frag will be adjusted to
force the next frag to have the appropriate alignment. ALIGNMENT
is the power of two to which to align. FILL_CHARACTER is the
or 0 if there is no maximum. */
void
-frag_align (alignment, fill_character, max)
- int alignment;
- int fill_character;
- int max;
+frag_align (int alignment, int fill_character, int max)
{
if (now_seg == absolute_section)
{
doing the alignment, or 0 if there is no maximum. */
void
-frag_align_pattern (alignment, fill_pattern, n_fill, max)
- int alignment;
- const char *fill_pattern;
- int n_fill;
- int max;
+frag_align_pattern (int alignment, const char *fill_pattern,
+ int n_fill, int max)
{
char *p;
#endif
void
-frag_align_code (alignment, max)
- int alignment;
- int max;
+frag_align_code (int alignment, int max)
{
char *p;
}
addressT
-frag_now_fix_octets ()
+frag_now_fix_octets (void)
{
if (now_seg == absolute_section)
return abs_section_offset;
}
addressT
-frag_now_fix ()
+frag_now_fix (void)
{
return frag_now_fix_octets () / OCTETS_PER_BYTE;
}
void
-frag_append_1_char (datum)
- int datum;
+frag_append_1_char (int datum)
{
+ frag_alloc_check (&frchain_now->frch_obstack);
if (obstack_room (&frchain_now->frch_obstack) <= 1)
{
frag_wane (frag_now);
}
obstack_1grow (&frchain_now->frch_obstack, datum);
}
+
+/* Return TRUE if FRAG1 and FRAG2 have a fixed relationship between
+ their start addresses. Set OFFSET to the difference in address
+ not already accounted for in the frag FR_ADDRESS. */
+
+bfd_boolean
+frag_offset_fixed_p (const fragS *frag1, const fragS *frag2, bfd_vma *offset)
+{
+ const fragS *frag;
+ bfd_vma off;
+
+ /* Start with offset initialised to difference between the two frags.
+ Prior to assigning frag addresses this will be zero. */
+ off = frag1->fr_address - frag2->fr_address;
+ if (frag1 == frag2)
+ {
+ *offset = off;
+ return TRUE;
+ }
+
+ /* Maybe frag2 is after frag1. */
+ frag = frag1;
+ while (frag->fr_type == rs_fill)
+ {
+ off += frag->fr_fix + frag->fr_offset * frag->fr_var;
+ frag = frag->fr_next;
+ if (frag == NULL)
+ break;
+ if (frag == frag2)
+ {
+ *offset = off;
+ return TRUE;
+ }
+ }
+
+ /* Maybe frag1 is after frag2. */
+ off = frag1->fr_address - frag2->fr_address;
+ frag = frag2;
+ while (frag->fr_type == rs_fill)
+ {
+ off -= frag->fr_fix + frag->fr_offset * frag->fr_var;
+ frag = frag->fr_next;
+ if (frag == NULL)
+ break;
+ if (frag == frag1)
+ {
+ *offset = off;
+ return TRUE;
+ }
+ }
+
+ return FALSE;
+}
projects / deliverable / binutils-gdb.git / blobdiff