2000-08-29 Michael Snyder <msnyder@seadog.cygnus.com>
[binutils.git] / gas / frags.c
blob5c31b7e89318d527d9154691b739c7a442aff131
1 /* frags.c - manage frags -
2 Copyright (C) 1987, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 2000
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)
10 any later version.
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
20 02111-1307, USA. */
22 #include "as.h"
23 #include "subsegs.h"
24 #include "obstack.h"
26 extern fragS zero_address_frag;
27 extern fragS bss_address_frag;
29 /* Initialization for frag routines. */
30 void
31 frag_init ()
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. */
40 fragS *
41 frag_alloc (ob)
42 struct obstack *ob;
44 fragS *ptr;
45 int oalign;
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);
53 return ptr;
57 * frag_grow()
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.
64 void
65 frag_grow (nchars)
66 unsigned int nchars;
68 if (obstack_room (&frchain_now->frch_obstack) < nchars)
70 unsigned int n;
71 long oldc;
73 frag_wane (frag_now);
74 frag_new (0);
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)
81 frag_wane (frag_now);
82 frag_new (0);
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);
91 * frag_new()
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 * variable part; 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.
103 * In fact, you may use fr_var for something totally unrelated to the
104 * size of the variable part of the frag; None of the generic frag
105 * handling code makes use of fr_var.
107 * Make a new frag, initialising some components. Link new frag at end
108 * of frchain_now.
110 void
111 frag_new (old_frags_var_max_size)
112 /* Number of chars (already allocated on obstack frags) in
113 variable_length part of frag. */
114 int old_frags_var_max_size;
116 fragS *former_last_fragP;
117 frchainS *frchP;
119 assert (frchain_now->frch_last == frag_now);
121 /* Fix up old frag's fr_fix. */
122 frag_now->fr_fix = frag_now_fix_octets () - old_frags_var_max_size;
123 /* Make sure its type is valid. */
124 assert (frag_now->fr_type != 0);
126 /* This will align the obstack so the next struct we allocate on it
127 will begin at a correct boundary. */
128 obstack_finish (&frchain_now->frch_obstack);
129 frchP = frchain_now;
130 know (frchP);
131 former_last_fragP = frchP->frch_last;
132 assert (former_last_fragP != 0);
133 assert (former_last_fragP == frag_now);
134 frag_now = frag_alloc (&frchP->frch_obstack);
136 as_where (&frag_now->fr_file, &frag_now->fr_line);
138 /* Generally, frag_now->points to an address rounded up to next
139 alignment. However, characters will add to obstack frags
140 IMMEDIATELY after the struct frag, even if they are not starting
141 at an alignment address. */
142 former_last_fragP->fr_next = frag_now;
143 frchP->frch_last = frag_now;
145 #ifndef NO_LISTING
147 extern struct list_info_struct *listing_tail;
148 frag_now->line = listing_tail;
150 #endif
152 assert (frchain_now->frch_last == frag_now);
154 frag_now->fr_next = NULL;
155 } /* frag_new() */
158 * frag_more()
160 * Start a new frag unless we have n more chars of room in the current frag.
161 * Close off the old frag with a .fill 0.
163 * Return the address of the 1st char to write into. Advance
164 * frag_now_growth past the new chars.
167 char *
168 frag_more (nchars)
169 int nchars;
171 register char *retval;
173 if (now_seg == absolute_section)
175 as_bad (_("attempt to allocate data in absolute section"));
176 subseg_set (text_section, 0);
179 if (mri_common_symbol != NULL)
181 as_bad (_("attempt to allocate data in common section"));
182 mri_common_symbol = NULL;
185 frag_grow (nchars);
186 retval = obstack_next_free (&frchain_now->frch_obstack);
187 obstack_blank_fast (&frchain_now->frch_obstack, nchars);
188 return (retval);
189 } /* frag_more() */
192 * frag_var()
194 * Start a new frag unless we have max_chars more chars of room in the current frag.
195 * Close off the old frag with a .fill 0.
197 * Set up a machine_dependent relaxable frag, then start a new frag.
198 * Return the address of the 1st char of the var part of the old frag
199 * to write into.
202 char *
203 frag_var (type, max_chars, var, subtype, symbol, offset, opcode)
204 relax_stateT type;
205 int max_chars;
206 int var;
207 relax_substateT subtype;
208 symbolS *symbol;
209 offsetT offset;
210 char *opcode;
212 register char *retval;
214 frag_grow (max_chars);
215 retval = obstack_next_free (&frchain_now->frch_obstack);
216 obstack_blank_fast (&frchain_now->frch_obstack, max_chars);
217 frag_now->fr_var = var;
218 frag_now->fr_type = type;
219 frag_now->fr_subtype = subtype;
220 frag_now->fr_symbol = symbol;
221 frag_now->fr_offset = offset;
222 frag_now->fr_opcode = opcode;
223 #ifdef USING_CGEN
224 frag_now->fr_cgen.insn = 0;
225 frag_now->fr_cgen.opindex = 0;
226 frag_now->fr_cgen.opinfo = 0;
227 #endif
228 #ifdef TC_FRAG_INIT
229 TC_FRAG_INIT (frag_now);
230 #endif
231 as_where (&frag_now->fr_file, &frag_now->fr_line);
232 frag_new (max_chars);
233 return (retval);
237 * frag_variant()
239 * OVE: This variant of frag_var assumes that space for the tail has been
240 * allocated by caller.
241 * No call to frag_grow is done.
244 char *
245 frag_variant (type, max_chars, var, subtype, symbol, offset, opcode)
246 relax_stateT type;
247 int max_chars;
248 int var;
249 relax_substateT subtype;
250 symbolS *symbol;
251 offsetT offset;
252 char *opcode;
254 register char *retval;
256 retval = obstack_next_free (&frchain_now->frch_obstack);
257 frag_now->fr_var = var;
258 frag_now->fr_type = type;
259 frag_now->fr_subtype = subtype;
260 frag_now->fr_symbol = symbol;
261 frag_now->fr_offset = offset;
262 frag_now->fr_opcode = opcode;
263 #ifdef USING_CGEN
264 frag_now->fr_cgen.insn = 0;
265 frag_now->fr_cgen.opindex = 0;
266 frag_now->fr_cgen.opinfo = 0;
267 #endif
268 #ifdef TC_FRAG_INIT
269 TC_FRAG_INIT (frag_now);
270 #endif
271 as_where (&frag_now->fr_file, &frag_now->fr_line);
272 frag_new (max_chars);
273 return (retval);
274 } /* frag_variant() */
277 * frag_wane()
279 * Reduce the variable end of a frag to a harmless state.
281 void
282 frag_wane (fragP)
283 register fragS *fragP;
285 fragP->fr_type = rs_fill;
286 fragP->fr_offset = 0;
287 fragP->fr_var = 0;
290 /* Make an alignment frag. The size of this frag will be adjusted to
291 force the next frag to have the appropriate alignment. ALIGNMENT
292 is the power of two to which to align. FILL_CHARACTER is the
293 character to use to fill in any bytes which are skipped. MAX is
294 the maximum number of characters to skip when doing the alignment,
295 or 0 if there is no maximum. */
297 void
298 frag_align (alignment, fill_character, max)
299 int alignment;
300 int fill_character;
301 int max;
303 if (now_seg == absolute_section)
305 addressT new_off;
306 addressT mask;
308 mask = (~ (addressT) 0) << alignment;
309 new_off = (abs_section_offset + ~ mask) & mask;
310 if (max == 0 || new_off - abs_section_offset <= (addressT) max)
311 abs_section_offset = new_off;
313 else
315 char *p;
317 p = frag_var (rs_align, 1, 1, (relax_substateT) max,
318 (symbolS *) 0, (offsetT) alignment, (char *) 0);
319 *p = fill_character;
323 /* Make an alignment frag like frag_align, but fill with a repeating
324 pattern rather than a single byte. ALIGNMENT is the power of two
325 to which to align. FILL_PATTERN is the fill pattern to repeat in
326 the bytes which are skipped. N_FILL is the number of bytes in
327 FILL_PATTERN. MAX is the maximum number of characters to skip when
328 doing the alignment, or 0 if there is no maximum. */
330 void
331 frag_align_pattern (alignment, fill_pattern, n_fill, max)
332 int alignment;
333 const char *fill_pattern;
334 int n_fill;
335 int max;
337 char *p;
339 p = frag_var (rs_align, n_fill, n_fill, (relax_substateT) max,
340 (symbolS *) 0, (offsetT) alignment, (char *) 0);
341 memcpy (p, fill_pattern, n_fill);
344 addressT
345 frag_now_fix_octets ()
347 if (now_seg == absolute_section)
348 return abs_section_offset;
350 return ((char*) obstack_next_free (&frchain_now->frch_obstack)
351 - frag_now->fr_literal);
354 addressT
355 frag_now_fix ()
357 return frag_now_fix_octets() / OCTETS_PER_BYTE;
360 void
361 frag_append_1_char (datum)
362 int datum;
364 if (obstack_room (&frchain_now->frch_obstack) <= 1)
366 frag_wane (frag_now);
367 frag_new (0);
369 obstack_1grow (&frchain_now->frch_obstack, datum);
372 /* end of frags.c */