a2acbf8d12
(frag_now_fix): In absolute_section, return abs_section_offset. * subsegs.c (subseg_change): If switching to absolute_section, just set now_seg and now_subseg. (subseg_set_rest): Special handling when switching to or from absolute_section.
315 lines
8.1 KiB
C
315 lines
8.1 KiB
C
/* frags.c - manage frags -
|
||
|
||
Copyright (C) 1987, 1990, 1991, 1992 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
|
||
the Free Software Foundation; either version 2, or (at your option)
|
||
any later version.
|
||
|
||
GAS is distributed in the hope that it will be useful,
|
||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||
GNU General Public License for more details.
|
||
|
||
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. */
|
||
|
||
#include "as.h"
|
||
#include "subsegs.h"
|
||
#include "obstack.h"
|
||
|
||
struct obstack frags; /* All, and only, frags live here. */
|
||
|
||
extern fragS zero_address_frag;
|
||
extern fragS bss_address_frag;
|
||
|
||
/* Initialization for frag routines. */
|
||
void
|
||
frag_init ()
|
||
{
|
||
zero_address_frag.fr_type = rs_fill;
|
||
bss_address_frag.fr_type = rs_fill;
|
||
obstack_begin (&frags, 5000);
|
||
}
|
||
|
||
/*
|
||
* frag_grow()
|
||
*
|
||
* 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 (nchars)
|
||
unsigned int nchars;
|
||
{
|
||
if (obstack_room (&frags) < nchars)
|
||
{
|
||
unsigned int n, oldn;
|
||
long oldc;
|
||
|
||
frag_wane (frag_now);
|
||
frag_new (0);
|
||
oldn = (unsigned) -1;
|
||
oldc = frags.chunk_size;
|
||
frags.chunk_size = 2 * nchars;
|
||
while ((n = obstack_room (&frags)) < nchars && n < oldn)
|
||
{
|
||
frag_wane (frag_now);
|
||
frag_new (0);
|
||
oldn = n;
|
||
}
|
||
frags.chunk_size = oldc;
|
||
}
|
||
if (obstack_room (&frags) < nchars)
|
||
as_fatal ("Can't extend frag %d. chars", nchars);
|
||
} /* frag_grow() */
|
||
|
||
/*
|
||
* frag_new()
|
||
*
|
||
* Call this to close off a completed frag, and start up a new (empty)
|
||
* frag, in the same subsegment as the old frag.
|
||
* [frchain_now remains the same but frag_now is updated.]
|
||
* Because this calculates the correct value of fr_fix by
|
||
* looking at the obstack 'frags', it needs to know how many
|
||
* characters at the end of the old frag belong to (the maximal)
|
||
* fr_var: the rest must belong to fr_fix.
|
||
* It doesn't actually set up the old frag's fr_var: you may have
|
||
* set fr_var == 1, but allocated 10 chars to the end of the frag:
|
||
* in this case you pass old_frags_var_max_size == 10.
|
||
*
|
||
* Make a new frag, initialising some components. Link new frag at end
|
||
* of frchain_now.
|
||
*/
|
||
void
|
||
frag_new (old_frags_var_max_size)
|
||
int old_frags_var_max_size;/* Number of chars (already allocated on
|
||
obstack frags) */
|
||
/* in variable_length part of frag. */
|
||
{
|
||
register fragS *former_last_fragP;
|
||
register frchainS *frchP;
|
||
long tmp;
|
||
|
||
frag_now->fr_fix = frag_now_fix () - old_frags_var_max_size;
|
||
/* Fix up old frag's fr_fix. */
|
||
|
||
obstack_finish (&frags);
|
||
/* This will align the obstack so the next struct we allocate on it
|
||
will begin at a correct boundary. */
|
||
frchP = frchain_now;
|
||
know (frchP);
|
||
former_last_fragP = frchP->frch_last;
|
||
know (former_last_fragP);
|
||
know (former_last_fragP == frag_now);
|
||
obstack_blank (&frags, SIZEOF_STRUCT_FRAG);
|
||
/* We expect this will begin at a correct boundary for a struct. */
|
||
tmp = obstack_alignment_mask (&frags);
|
||
obstack_alignment_mask (&frags) = 0; /* Turn off alignment */
|
||
/* If we ever hit a machine where strings must be aligned, we Lose
|
||
Big. */
|
||
frag_now = (fragS *) obstack_finish (&frags);
|
||
obstack_alignment_mask (&frags) = tmp; /* Restore alignment */
|
||
|
||
/* Just in case we don't get zero'd bytes */
|
||
memset (frag_now, '\0', SIZEOF_STRUCT_FRAG);
|
||
|
||
/* Generally, frag_now->points to an address rounded up to next
|
||
alignment. However, characters will add to obstack frags
|
||
IMMEDIATELY after the struct frag, even if they are not starting
|
||
at an alignment address. */
|
||
former_last_fragP->fr_next = frag_now;
|
||
frchP->frch_last = frag_now;
|
||
|
||
#ifndef NO_LISTING
|
||
{
|
||
extern struct list_info_struct *listing_tail;
|
||
frag_now->line = listing_tail;
|
||
}
|
||
#endif
|
||
|
||
frag_now->fr_next = NULL;
|
||
} /* frag_new() */
|
||
|
||
/*
|
||
* frag_more()
|
||
*
|
||
* Start a new frag unless we have n more chars of room in the current frag.
|
||
* Close off the old frag with a .fill 0.
|
||
*
|
||
* Return the address of the 1st char to write into. Advance
|
||
* frag_now_growth past the new chars.
|
||
*/
|
||
|
||
char *
|
||
frag_more (nchars)
|
||
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_grow (nchars);
|
||
retval = obstack_next_free (&frags);
|
||
obstack_blank_fast (&frags, nchars);
|
||
return (retval);
|
||
} /* frag_more() */
|
||
|
||
/*
|
||
* frag_var()
|
||
*
|
||
* 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 (type, max_chars, var, subtype, symbol, offset, opcode)
|
||
relax_stateT type;
|
||
int max_chars;
|
||
int var;
|
||
relax_substateT subtype;
|
||
symbolS *symbol;
|
||
long offset;
|
||
char *opcode;
|
||
{
|
||
register char *retval;
|
||
|
||
frag_grow (max_chars);
|
||
retval = obstack_next_free (&frags);
|
||
obstack_blank_fast (&frags, max_chars);
|
||
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;
|
||
/* default these to zero. */
|
||
frag_now->fr_pcrel_adjust = 0;
|
||
frag_now->fr_bsr = 0;
|
||
frag_new (max_chars);
|
||
return (retval);
|
||
}
|
||
|
||
/*
|
||
* frag_variant()
|
||
*
|
||
* OVE: This variant of frag_var assumes that space for the tail has been
|
||
* allocated by caller.
|
||
* No call to frag_grow is done.
|
||
* Two new arguments have been added.
|
||
*/
|
||
|
||
char *
|
||
frag_variant (type, max_chars, var, subtype, symbol, offset, opcode)
|
||
relax_stateT type;
|
||
int max_chars;
|
||
int var;
|
||
relax_substateT subtype;
|
||
symbolS *symbol;
|
||
long offset;
|
||
char *opcode;
|
||
{
|
||
register char *retval;
|
||
|
||
retval = obstack_next_free (&frags);
|
||
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;
|
||
frag_now->fr_pcrel_adjust = 0;
|
||
frag_now->fr_bsr = 0;
|
||
frag_new (max_chars);
|
||
return (retval);
|
||
} /* frag_variant() */
|
||
|
||
/*
|
||
* frag_wane()
|
||
*
|
||
* Reduce the variable end of a frag to a harmless state.
|
||
*/
|
||
void
|
||
frag_wane (fragP)
|
||
register fragS *fragP;
|
||
{
|
||
fragP->fr_type = rs_fill;
|
||
fragP->fr_offset = 0;
|
||
fragP->fr_var = 0;
|
||
}
|
||
|
||
/*
|
||
* frag_align()
|
||
*
|
||
* Make a frag for ".align foo,bar". Call is "frag_align (foo,bar);".
|
||
* Foo & bar are absolute integers.
|
||
*
|
||
* Call to close off the current frag with a ".align", then start a new
|
||
* (so far empty) frag, in the same subsegment as the last frag.
|
||
*/
|
||
|
||
void
|
||
frag_align (alignment, fill_character)
|
||
int alignment;
|
||
int fill_character;
|
||
{
|
||
char *p;
|
||
p = frag_var (rs_align, 1, 1, (relax_substateT) 0,
|
||
(symbolS *) 0, (long) alignment, (char *) 0);
|
||
*p = fill_character;
|
||
}
|
||
|
||
void
|
||
frag_align_pattern (alignment, fill_pattern, n_fill)
|
||
int alignment;
|
||
const char *fill_pattern;
|
||
int n_fill;
|
||
{
|
||
char *p;
|
||
p = frag_var (rs_align, n_fill, n_fill, (relax_substateT) 0,
|
||
(symbolS *) 0, (long) alignment, (char *) 0);
|
||
memcpy (p, fill_pattern, n_fill);
|
||
}
|
||
|
||
int
|
||
frag_now_fix ()
|
||
{
|
||
if (now_seg == absolute_section)
|
||
return abs_section_offset;
|
||
return (char*)obstack_next_free (&frags) - frag_now->fr_literal;
|
||
}
|
||
|
||
void
|
||
frag_append_1_char (datum)
|
||
int datum;
|
||
{
|
||
if (obstack_room (&frags) <= 1)
|
||
{
|
||
frag_wane (frag_now);
|
||
frag_new (0);
|
||
}
|
||
obstack_1grow (&frags, datum);
|
||
}
|
||
|
||
/* end of frags.c */
|