Commit | Line | Data |
---|---|---|
252b5132 | 1 | /* frags.c - manage frags - |
5a327c7a | 2 | Copyright (C) 1987, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 2000 |
252b5132 RH |
3 | Free Software Foundation, Inc. |
4 | ||
5 | This file is part of GAS, the GNU Assembler. | |
6 | ||
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. | |
11 | ||
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. | |
16 | ||
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. */ | |
21 | ||
22 | #include "as.h" | |
23 | #include "subsegs.h" | |
24 | #include "obstack.h" | |
25 | ||
26 | extern fragS zero_address_frag; | |
27 | extern fragS bss_address_frag; | |
28 | \f | |
29 | /* Initialization for frag routines. */ | |
30 | void | |
31 | frag_init () | |
32 | { | |
33 | zero_address_frag.fr_type = rs_fill; | |
34 | bss_address_frag.fr_type = rs_fill; | |
35 | } | |
36 | \f | |
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; | |
43 | { | |
44 | fragS *ptr; | |
45 | int oalign; | |
46 | ||
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; | |
54 | } | |
55 | \f | |
56 | /* | |
57 | * frag_grow() | |
58 | * | |
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. | |
63 | */ | |
64 | void | |
65 | frag_grow (nchars) | |
66 | unsigned int nchars; | |
67 | { | |
68 | if (obstack_room (&frchain_now->frch_obstack) < nchars) | |
69 | { | |
70 | unsigned int n; | |
71 | long oldc; | |
72 | ||
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; | |
3f9b03b5 AM |
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) | |
80 | { | |
81 | frag_wane (frag_now); | |
82 | frag_new (0); | |
83 | } | |
252b5132 RH |
84 | frchain_now->frch_obstack.chunk_size = oldc; |
85 | } | |
86 | if (obstack_room (&frchain_now->frch_obstack) < nchars) | |
87 | as_fatal (_("Can't extend frag %d. chars"), nchars); | |
88 | } | |
89 | \f | |
90 | /* | |
91 | * frag_new() | |
92 | * | |
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 | |
ee7fcc42 AM |
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. | |
252b5132 RH |
106 | * |
107 | * Make a new frag, initialising some components. Link new frag at end | |
108 | * of frchain_now. | |
109 | */ | |
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; | |
115 | { | |
116 | fragS *former_last_fragP; | |
117 | frchainS *frchP; | |
118 | ||
119 | assert (frchain_now->frch_last == frag_now); | |
120 | ||
121 | /* Fix up old frag's fr_fix. */ | |
bea9907b | 122 | frag_now->fr_fix = frag_now_fix_octets () - old_frags_var_max_size; |
252b5132 RH |
123 | /* Make sure its type is valid. */ |
124 | assert (frag_now->fr_type != 0); | |
125 | ||
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); | |
135 | ||
136 | as_where (&frag_now->fr_file, &frag_now->fr_line); | |
137 | ||
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; | |
144 | ||
145 | #ifndef NO_LISTING | |
146 | { | |
147 | extern struct list_info_struct *listing_tail; | |
148 | frag_now->line = listing_tail; | |
149 | } | |
150 | #endif | |
151 | ||
152 | assert (frchain_now->frch_last == frag_now); | |
153 | ||
154 | frag_now->fr_next = NULL; | |
155 | } /* frag_new() */ | |
156 | \f | |
157 | /* | |
158 | * frag_more() | |
159 | * | |
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. | |
162 | * | |
163 | * Return the address of the 1st char to write into. Advance | |
164 | * frag_now_growth past the new chars. | |
165 | */ | |
166 | ||
167 | char * | |
168 | frag_more (nchars) | |
169 | int nchars; | |
170 | { | |
171 | register char *retval; | |
172 | ||
173 | if (now_seg == absolute_section) | |
174 | { | |
175 | as_bad (_("attempt to allocate data in absolute section")); | |
176 | subseg_set (text_section, 0); | |
177 | } | |
178 | ||
179 | if (mri_common_symbol != NULL) | |
180 | { | |
181 | as_bad (_("attempt to allocate data in common section")); | |
182 | mri_common_symbol = NULL; | |
183 | } | |
184 | ||
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() */ | |
190 | \f | |
191 | /* | |
192 | * frag_var() | |
193 | * | |
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. | |
196 | * | |
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. | |
200 | */ | |
201 | ||
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; | |
211 | { | |
212 | register char *retval; | |
213 | ||
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); | |
234 | } | |
235 | \f | |
236 | /* | |
237 | * frag_variant() | |
238 | * | |
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. | |
242 | */ | |
243 | ||
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; | |
253 | { | |
254 | register char *retval; | |
255 | ||
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() */ | |
275 | \f | |
276 | /* | |
277 | * frag_wane() | |
278 | * | |
279 | * Reduce the variable end of a frag to a harmless state. | |
280 | */ | |
281 | void | |
282 | frag_wane (fragP) | |
283 | register fragS *fragP; | |
284 | { | |
285 | fragP->fr_type = rs_fill; | |
286 | fragP->fr_offset = 0; | |
287 | fragP->fr_var = 0; | |
288 | } | |
289 | \f | |
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. */ | |
296 | ||
297 | void | |
298 | frag_align (alignment, fill_character, max) | |
299 | int alignment; | |
300 | int fill_character; | |
301 | int max; | |
302 | { | |
303 | if (now_seg == absolute_section) | |
304 | { | |
305 | addressT new_off; | |
306 | ||
307 | new_off = ((abs_section_offset + alignment - 1) | |
308 | &~ ((1 << alignment) - 1)); | |
309 | if (max == 0 || new_off - abs_section_offset <= (addressT) max) | |
310 | abs_section_offset = new_off; | |
311 | } | |
312 | else | |
313 | { | |
314 | char *p; | |
315 | ||
316 | p = frag_var (rs_align, 1, 1, (relax_substateT) max, | |
317 | (symbolS *) 0, (offsetT) alignment, (char *) 0); | |
318 | *p = fill_character; | |
319 | } | |
320 | } | |
321 | ||
322 | /* Make an alignment frag like frag_align, but fill with a repeating | |
323 | pattern rather than a single byte. ALIGNMENT is the power of two | |
324 | to which to align. FILL_PATTERN is the fill pattern to repeat in | |
325 | the bytes which are skipped. N_FILL is the number of bytes in | |
326 | FILL_PATTERN. MAX is the maximum number of characters to skip when | |
327 | doing the alignment, or 0 if there is no maximum. */ | |
328 | ||
329 | void | |
330 | frag_align_pattern (alignment, fill_pattern, n_fill, max) | |
331 | int alignment; | |
332 | const char *fill_pattern; | |
333 | int n_fill; | |
334 | int max; | |
335 | { | |
336 | char *p; | |
337 | ||
338 | p = frag_var (rs_align, n_fill, n_fill, (relax_substateT) max, | |
339 | (symbolS *) 0, (offsetT) alignment, (char *) 0); | |
340 | memcpy (p, fill_pattern, n_fill); | |
341 | } | |
342 | ||
343 | addressT | |
bea9907b | 344 | frag_now_fix_octets () |
252b5132 RH |
345 | { |
346 | if (now_seg == absolute_section) | |
347 | return abs_section_offset; | |
bea9907b TW |
348 | |
349 | return ((char*) obstack_next_free (&frchain_now->frch_obstack) | |
350 | - frag_now->fr_literal); | |
351 | } | |
352 | ||
353 | addressT | |
354 | frag_now_fix () | |
355 | { | |
356 | return frag_now_fix_octets() / OCTETS_PER_BYTE; | |
252b5132 RH |
357 | } |
358 | ||
359 | void | |
360 | frag_append_1_char (datum) | |
361 | int datum; | |
362 | { | |
363 | if (obstack_room (&frchain_now->frch_obstack) <= 1) | |
364 | { | |
365 | frag_wane (frag_now); | |
366 | frag_new (0); | |
367 | } | |
368 | obstack_1grow (&frchain_now->frch_obstack, datum); | |
369 | } | |
370 | ||
371 | /* end of frags.c */ |