1 /* frags.c - manage frags -
2 Copyright (C) 1987, 90, 91, 92, 93, 94, 95, 96, 97, 1998
3 Free Software Foundation, Inc.
5 This file is part of GAS, the GNU Assembler.
7 GAS is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GAS is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GAS; see the file COPYING. If not, write to the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
26 extern fragS zero_address_frag;
27 extern fragS bss_address_frag;
29 /* Initialization for frag routines. */
33 zero_address_frag.fr_type = rs_fill;
34 bss_address_frag.fr_type = rs_fill;
37 /* Allocate a frag on the specified obstack.
38 Call this routine from everywhere else, so that all the weird alignment
39 hackery can be done in just one place. */
47 (void) obstack_alloc (ob, 0);
48 oalign = obstack_alignment_mask (ob);
49 obstack_alignment_mask (ob) = 0;
50 ptr = (fragS *) obstack_alloc (ob, SIZEOF_STRUCT_FRAG);
51 obstack_alignment_mask (ob) = oalign;
52 memset (ptr, 0, SIZEOF_STRUCT_FRAG);
59 * Try to augment current frag by nchars chars.
60 * If there is no room, close of the current frag with a ".fill 0"
61 * and begin a new frag. Unless the new frag has nchars chars available
62 * do not return. Do not set up any fields of *now_frag.
68 if (obstack_room (&frchain_now->frch_obstack) < nchars)
75 oldc = frchain_now->frch_obstack.chunk_size;
76 frchain_now->frch_obstack.chunk_size = 2 * nchars + SIZEOF_STRUCT_FRAG;
77 if (frchain_now->frch_obstack.chunk_size > 0)
78 while ((n = obstack_room (&frchain_now->frch_obstack)) < nchars
79 && (unsigned long) frchain_now->frch_obstack.chunk_size > nchars)
84 frchain_now->frch_obstack.chunk_size = oldc;
86 if (obstack_room (&frchain_now->frch_obstack) < nchars)
87 as_fatal (_("Can't extend frag %d. chars"), nchars);
93 * Call this to close off a completed frag, and start up a new (empty)
94 * frag, in the same subsegment as the old frag.
95 * [frchain_now remains the same but frag_now is updated.]
96 * Because this calculates the correct value of fr_fix by
97 * looking at the obstack 'frags', it needs to know how many
98 * characters at the end of the old frag belong to (the maximal)
99 * fr_var: the rest must belong to fr_fix.
100 * It doesn't actually set up the old frag's fr_var: you may have
101 * set fr_var == 1, but allocated 10 chars to the end of the frag:
102 * in this case you pass old_frags_var_max_size == 10.
104 * Make a new frag, initialising some components. Link new frag at end
108 frag_new (old_frags_var_max_size)
109 /* Number of chars (already allocated on obstack frags) in
110 variable_length part of frag. */
111 int old_frags_var_max_size;
113 fragS *former_last_fragP;
116 assert (frchain_now->frch_last == frag_now);
118 /* Fix up old frag's fr_fix. */
119 frag_now->fr_fix = frag_now_fix_octets () - old_frags_var_max_size;
120 /* Make sure its type is valid. */
121 assert (frag_now->fr_type != 0);
123 /* This will align the obstack so the next struct we allocate on it
124 will begin at a correct boundary. */
125 obstack_finish (&frchain_now->frch_obstack);
128 former_last_fragP = frchP->frch_last;
129 assert (former_last_fragP != 0);
130 assert (former_last_fragP == frag_now);
131 frag_now = frag_alloc (&frchP->frch_obstack);
133 as_where (&frag_now->fr_file, &frag_now->fr_line);
135 /* Generally, frag_now->points to an address rounded up to next
136 alignment. However, characters will add to obstack frags
137 IMMEDIATELY after the struct frag, even if they are not starting
138 at an alignment address. */
139 former_last_fragP->fr_next = frag_now;
140 frchP->frch_last = frag_now;
144 extern struct list_info_struct *listing_tail;
145 frag_now->line = listing_tail;
149 assert (frchain_now->frch_last == frag_now);
151 frag_now->fr_next = NULL;
157 * Start a new frag unless we have n more chars of room in the current frag.
158 * Close off the old frag with a .fill 0.
160 * Return the address of the 1st char to write into. Advance
161 * frag_now_growth past the new chars.
168 register char *retval;
170 if (now_seg == absolute_section)
172 as_bad (_("attempt to allocate data in absolute section"));
173 subseg_set (text_section, 0);
176 if (mri_common_symbol != NULL)
178 as_bad (_("attempt to allocate data in common section"));
179 mri_common_symbol = NULL;
183 retval = obstack_next_free (&frchain_now->frch_obstack);
184 obstack_blank_fast (&frchain_now->frch_obstack, nchars);
191 * Start a new frag unless we have max_chars more chars of room in the current frag.
192 * Close off the old frag with a .fill 0.
194 * Set up a machine_dependent relaxable frag, then start a new frag.
195 * Return the address of the 1st char of the var part of the old frag
200 frag_var (type, max_chars, var, subtype, symbol, offset, opcode)
204 relax_substateT subtype;
209 register char *retval;
211 frag_grow (max_chars);
212 retval = obstack_next_free (&frchain_now->frch_obstack);
213 obstack_blank_fast (&frchain_now->frch_obstack, max_chars);
214 frag_now->fr_var = var;
215 frag_now->fr_type = type;
216 frag_now->fr_subtype = subtype;
217 frag_now->fr_symbol = symbol;
218 frag_now->fr_offset = offset;
219 frag_now->fr_opcode = opcode;
221 frag_now->fr_cgen.insn = 0;
222 frag_now->fr_cgen.opindex = 0;
223 frag_now->fr_cgen.opinfo = 0;
226 TC_FRAG_INIT (frag_now);
228 as_where (&frag_now->fr_file, &frag_now->fr_line);
229 frag_new (max_chars);
236 * OVE: This variant of frag_var assumes that space for the tail has been
237 * allocated by caller.
238 * No call to frag_grow is done.
242 frag_variant (type, max_chars, var, subtype, symbol, offset, opcode)
246 relax_substateT subtype;
251 register char *retval;
253 retval = obstack_next_free (&frchain_now->frch_obstack);
254 frag_now->fr_var = var;
255 frag_now->fr_type = type;
256 frag_now->fr_subtype = subtype;
257 frag_now->fr_symbol = symbol;
258 frag_now->fr_offset = offset;
259 frag_now->fr_opcode = opcode;
261 frag_now->fr_cgen.insn = 0;
262 frag_now->fr_cgen.opindex = 0;
263 frag_now->fr_cgen.opinfo = 0;
266 TC_FRAG_INIT (frag_now);
268 as_where (&frag_now->fr_file, &frag_now->fr_line);
269 frag_new (max_chars);
271 } /* frag_variant() */
276 * Reduce the variable end of a frag to a harmless state.
280 register fragS *fragP;
282 fragP->fr_type = rs_fill;
283 fragP->fr_offset = 0;
287 /* Make an alignment frag. The size of this frag will be adjusted to
288 force the next frag to have the appropriate alignment. ALIGNMENT
289 is the power of two to which to align. FILL_CHARACTER is the
290 character to use to fill in any bytes which are skipped. MAX is
291 the maximum number of characters to skip when doing the alignment,
292 or 0 if there is no maximum. */
295 frag_align (alignment, fill_character, max)
300 if (now_seg == absolute_section)
304 new_off = ((abs_section_offset + alignment - 1)
305 &~ ((1 << alignment) - 1));
306 if (max == 0 || new_off - abs_section_offset <= (addressT) max)
307 abs_section_offset = new_off;
313 p = frag_var (rs_align, 1, 1, (relax_substateT) max,
314 (symbolS *) 0, (offsetT) alignment, (char *) 0);
319 /* Make an alignment frag like frag_align, but fill with a repeating
320 pattern rather than a single byte. ALIGNMENT is the power of two
321 to which to align. FILL_PATTERN is the fill pattern to repeat in
322 the bytes which are skipped. N_FILL is the number of bytes in
323 FILL_PATTERN. MAX is the maximum number of characters to skip when
324 doing the alignment, or 0 if there is no maximum. */
327 frag_align_pattern (alignment, fill_pattern, n_fill, max)
329 const char *fill_pattern;
335 p = frag_var (rs_align, n_fill, n_fill, (relax_substateT) max,
336 (symbolS *) 0, (offsetT) alignment, (char *) 0);
337 memcpy (p, fill_pattern, n_fill);
341 frag_now_fix_octets ()
343 if (now_seg == absolute_section)
344 return abs_section_offset;
346 return ((char*) obstack_next_free (&frchain_now->frch_obstack)
347 - frag_now->fr_literal);
353 return frag_now_fix_octets() / OCTETS_PER_BYTE;
357 frag_append_1_char (datum)
360 if (obstack_room (&frchain_now->frch_obstack) <= 1)
362 frag_wane (frag_now);
365 obstack_1grow (&frchain_now->frch_obstack, datum);