/* frags.c - manage frags -
Copyright (C) 1987 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 1, or (at your option)
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, 675 Mass Ave, Cambridge, MA 02139, USA. */
#include "struc-symbol.h"
struct obstack frags
; /* All, and only, frags live here. */
fragS zero_address_frag
= {
fragS bss_address_frag
= {
0, /* fr_address. Gets filled in to make up
* 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.
if (obstack_room (&frags
) < nchars
) {
frags
.chunk_size
=2*nchars
;
while((n
=obstack_room(&frags
))<nchars
&& n
<oldn
) {
if (obstack_room (&frags
) < nchars
)
as_fatal ("Can't extend frag %d. chars", nchars
);
* 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
frag_new (old_frags_var_max_size
)
int old_frags_var_max_size
; /* Number of chars (already allocated on
/* in variable_length part of frag. */
register fragS
* former_last_fragP
;
/* char *throw_away_pointer; JF unused */
register frchainS
* frchP
;
frag_now
->fr_fix
= (char *) (obstack_next_free (&frags
)) -
(frag_now
->fr_literal
) - old_frags_var_max_size
;
/* Fix up old frag's fr_fix. */
/* This will align the obstack so the */
/* next struct we allocate on it will */
/* begin at a correct boundary. */
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
frag_now
=(fragS
*)obstack_finish(&frags
);
obstack_alignment_mask(&frags
)=tmp
; /* Restore alignment */
/* Just in case we don't get zero'd bytes */
bzero(frag_now
, SIZEOF_STRUCT_FRAG
);
/* obstack_unaligned_done (&frags, &frag_now); */
/* know (frags.obstack_c_next_free == frag_now->fr_literal); */
/* 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 */
former_last_fragP
->fr_next
= frag_now
;
frchP
->frch_last
= frag_now
;
frag_now
->fr_next
= NULL
;
* 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.
retval
= obstack_next_free (&frags
);
obstack_blank_fast (&frags
, nchars
);
* 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
frag_var (type
, max_chars
, var
, subtype
, symbol
, offset
, opcode
)
retval
= obstack_next_free (&frags
);
obstack_blank_fast (&frags
, max_chars
);
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;
* OVE: This variant of frag_var assumes that space for the tail has been
* No call to frag_grow is done.
* Two new arguments have been added.
frag_variant (type
, max_chars
, var
, subtype
, symbol
, offset
, opcode
, pcrel_adjust
,bsr
)
/* frag_grow (max_chars); */
retval
= obstack_next_free (&frags
);
/* obstack_blank_fast (&frags, max_chars); */ /* OVE: so far the only diff */
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
= pcrel_adjust
;
* Reduce the variable end of a frag to a harmless state.
fragP
->fr_type
= rs_fill
;
* 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.
frag_align (alignment
, fill_character
)
*(frag_var (rs_align
, 1, 1, (relax_substateT
)0, (symbolS
*)0,
(long)alignment
, (char *)0)) = fill_character
;