Commit | Line | Data |
---|---|---|
252b5132 | 1 | /* frags.c - manage frags - |
f7e42eb4 | 2 | Copyright 1987, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, |
e85ca5bb | 3 | 1999, 2000, 2001, 2003 |
252b5132 RH |
4 | Free Software Foundation, Inc. |
5 | ||
6 | This file is part of GAS, the GNU Assembler. | |
7 | ||
8 | GAS is free software; you can redistribute it and/or modify | |
9 | it under the terms of the GNU General Public License as published by | |
10 | the Free Software Foundation; either version 2, or (at your option) | |
11 | any later version. | |
12 | ||
13 | GAS is distributed in the hope that it will be useful, | |
14 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
15 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
16 | GNU General Public License for more details. | |
17 | ||
18 | You should have received a copy of the GNU General Public License | |
19 | along with GAS; see the file COPYING. If not, write to the Free | |
20 | Software Foundation, 59 Temple Place - Suite 330, Boston, MA | |
21 | 02111-1307, USA. */ | |
22 | ||
23 | #include "as.h" | |
24 | #include "subsegs.h" | |
25 | #include "obstack.h" | |
26 | ||
27 | extern fragS zero_address_frag; | |
28 | extern fragS bss_address_frag; | |
29 | \f | |
30 | /* Initialization for frag routines. */ | |
29f8404c | 31 | |
252b5132 RH |
32 | void |
33 | frag_init () | |
34 | { | |
35 | zero_address_frag.fr_type = rs_fill; | |
36 | bss_address_frag.fr_type = rs_fill; | |
37 | } | |
38 | \f | |
e85ca5bb AM |
39 | /* Check that we're not trying to assemble into a section that can't |
40 | allocate frags (currently, this is only possible in the absolute | |
41 | section), or into an mri common. */ | |
42 | ||
43 | static void | |
44 | frag_alloc_check (const struct obstack *ob) | |
45 | { | |
46 | if (ob->chunk_size == 0) | |
47 | { | |
48 | as_bad (_("attempt to allocate data in absolute section")); | |
49 | subseg_set (text_section, 0); | |
50 | } | |
51 | ||
52 | if (mri_common_symbol != NULL) | |
53 | { | |
54 | as_bad (_("attempt to allocate data in common section")); | |
55 | mri_common_symbol = NULL; | |
56 | } | |
57 | } | |
58 | ||
252b5132 RH |
59 | /* Allocate a frag on the specified obstack. |
60 | Call this routine from everywhere else, so that all the weird alignment | |
61 | hackery can be done in just one place. */ | |
29f8404c | 62 | |
252b5132 RH |
63 | fragS * |
64 | frag_alloc (ob) | |
65 | struct obstack *ob; | |
66 | { | |
67 | fragS *ptr; | |
68 | int oalign; | |
69 | ||
70 | (void) obstack_alloc (ob, 0); | |
71 | oalign = obstack_alignment_mask (ob); | |
72 | obstack_alignment_mask (ob) = 0; | |
73 | ptr = (fragS *) obstack_alloc (ob, SIZEOF_STRUCT_FRAG); | |
74 | obstack_alignment_mask (ob) = oalign; | |
75 | memset (ptr, 0, SIZEOF_STRUCT_FRAG); | |
76 | return ptr; | |
77 | } | |
78 | \f | |
29f8404c KH |
79 | /* Try to augment current frag by nchars chars. |
80 | If there is no room, close of the current frag with a ".fill 0" | |
81 | and begin a new frag. Unless the new frag has nchars chars available | |
82 | do not return. Do not set up any fields of *now_frag. */ | |
83 | ||
84 | void | |
252b5132 RH |
85 | frag_grow (nchars) |
86 | unsigned int nchars; | |
87 | { | |
88 | if (obstack_room (&frchain_now->frch_obstack) < nchars) | |
89 | { | |
90 | unsigned int n; | |
91 | long oldc; | |
92 | ||
93 | frag_wane (frag_now); | |
94 | frag_new (0); | |
95 | oldc = frchain_now->frch_obstack.chunk_size; | |
96 | frchain_now->frch_obstack.chunk_size = 2 * nchars + SIZEOF_STRUCT_FRAG; | |
3f9b03b5 AM |
97 | if (frchain_now->frch_obstack.chunk_size > 0) |
98 | while ((n = obstack_room (&frchain_now->frch_obstack)) < nchars | |
99 | && (unsigned long) frchain_now->frch_obstack.chunk_size > nchars) | |
100 | { | |
101 | frag_wane (frag_now); | |
102 | frag_new (0); | |
103 | } | |
252b5132 RH |
104 | frchain_now->frch_obstack.chunk_size = oldc; |
105 | } | |
106 | if (obstack_room (&frchain_now->frch_obstack) < nchars) | |
0e389e77 | 107 | as_fatal (_("can't extend frag %u chars"), nchars); |
252b5132 RH |
108 | } |
109 | \f | |
29f8404c KH |
110 | /* Call this to close off a completed frag, and start up a new (empty) |
111 | frag, in the same subsegment as the old frag. | |
112 | [frchain_now remains the same but frag_now is updated.] | |
113 | Because this calculates the correct value of fr_fix by | |
114 | looking at the obstack 'frags', it needs to know how many | |
115 | characters at the end of the old frag belong to the maximal | |
116 | variable part; The rest must belong to fr_fix. | |
117 | It doesn't actually set up the old frag's fr_var. You may have | |
118 | set fr_var == 1, but allocated 10 chars to the end of the frag; | |
119 | In this case you pass old_frags_var_max_size == 10. | |
120 | In fact, you may use fr_var for something totally unrelated to the | |
121 | size of the variable part of the frag; None of the generic frag | |
122 | handling code makes use of fr_var. | |
123 | ||
124 | Make a new frag, initialising some components. Link new frag at end | |
125 | of frchain_now. */ | |
126 | ||
127 | void | |
252b5132 RH |
128 | frag_new (old_frags_var_max_size) |
129 | /* Number of chars (already allocated on obstack frags) in | |
29f8404c | 130 | variable_length part of frag. */ |
252b5132 RH |
131 | int old_frags_var_max_size; |
132 | { | |
133 | fragS *former_last_fragP; | |
134 | frchainS *frchP; | |
135 | ||
136 | assert (frchain_now->frch_last == frag_now); | |
137 | ||
138 | /* Fix up old frag's fr_fix. */ | |
bea9907b | 139 | frag_now->fr_fix = frag_now_fix_octets () - old_frags_var_max_size; |
252b5132 RH |
140 | /* Make sure its type is valid. */ |
141 | assert (frag_now->fr_type != 0); | |
142 | ||
143 | /* This will align the obstack so the next struct we allocate on it | |
29f8404c | 144 | will begin at a correct boundary. */ |
252b5132 RH |
145 | obstack_finish (&frchain_now->frch_obstack); |
146 | frchP = frchain_now; | |
147 | know (frchP); | |
148 | former_last_fragP = frchP->frch_last; | |
149 | assert (former_last_fragP != 0); | |
150 | assert (former_last_fragP == frag_now); | |
151 | frag_now = frag_alloc (&frchP->frch_obstack); | |
152 | ||
153 | as_where (&frag_now->fr_file, &frag_now->fr_line); | |
154 | ||
155 | /* Generally, frag_now->points to an address rounded up to next | |
156 | alignment. However, characters will add to obstack frags | |
157 | IMMEDIATELY after the struct frag, even if they are not starting | |
29f8404c | 158 | at an alignment address. */ |
252b5132 RH |
159 | former_last_fragP->fr_next = frag_now; |
160 | frchP->frch_last = frag_now; | |
161 | ||
162 | #ifndef NO_LISTING | |
163 | { | |
164 | extern struct list_info_struct *listing_tail; | |
165 | frag_now->line = listing_tail; | |
166 | } | |
167 | #endif | |
168 | ||
169 | assert (frchain_now->frch_last == frag_now); | |
170 | ||
171 | frag_now->fr_next = NULL; | |
29f8404c | 172 | } |
252b5132 | 173 | \f |
29f8404c KH |
174 | /* Start a new frag unless we have n more chars of room in the current frag. |
175 | Close off the old frag with a .fill 0. | |
176 | ||
177 | Return the address of the 1st char to write into. Advance | |
178 | frag_now_growth past the new chars. */ | |
252b5132 RH |
179 | |
180 | char * | |
181 | frag_more (nchars) | |
182 | int nchars; | |
183 | { | |
184 | register char *retval; | |
185 | ||
e85ca5bb | 186 | frag_alloc_check (&frchain_now->frch_obstack); |
252b5132 RH |
187 | frag_grow (nchars); |
188 | retval = obstack_next_free (&frchain_now->frch_obstack); | |
189 | obstack_blank_fast (&frchain_now->frch_obstack, nchars); | |
190 | return (retval); | |
29f8404c | 191 | } |
252b5132 | 192 | \f |
29f8404c KH |
193 | /* Start a new frag unless we have max_chars more chars of room in the |
194 | current frag. Close off the old frag with a .fill 0. | |
195 | ||
196 | Set up a machine_dependent relaxable frag, then start a new frag. | |
197 | Return the address of the 1st char of the var part of the old frag | |
198 | to write into. */ | |
252b5132 RH |
199 | |
200 | char * | |
201 | frag_var (type, max_chars, var, subtype, symbol, offset, opcode) | |
202 | relax_stateT type; | |
203 | int max_chars; | |
204 | int var; | |
205 | relax_substateT subtype; | |
206 | symbolS *symbol; | |
207 | offsetT offset; | |
208 | char *opcode; | |
209 | { | |
210 | register char *retval; | |
211 | ||
212 | frag_grow (max_chars); | |
213 | retval = obstack_next_free (&frchain_now->frch_obstack); | |
214 | obstack_blank_fast (&frchain_now->frch_obstack, max_chars); | |
215 | frag_now->fr_var = var; | |
216 | frag_now->fr_type = type; | |
217 | frag_now->fr_subtype = subtype; | |
218 | frag_now->fr_symbol = symbol; | |
219 | frag_now->fr_offset = offset; | |
220 | frag_now->fr_opcode = opcode; | |
221 | #ifdef USING_CGEN | |
222 | frag_now->fr_cgen.insn = 0; | |
223 | frag_now->fr_cgen.opindex = 0; | |
224 | frag_now->fr_cgen.opinfo = 0; | |
225 | #endif | |
226 | #ifdef TC_FRAG_INIT | |
227 | TC_FRAG_INIT (frag_now); | |
228 | #endif | |
229 | as_where (&frag_now->fr_file, &frag_now->fr_line); | |
230 | frag_new (max_chars); | |
231 | return (retval); | |
232 | } | |
233 | \f | |
29f8404c KH |
234 | /* OVE: This variant of frag_var assumes that space for the tail has been |
235 | allocated by caller. | |
236 | No call to frag_grow is done. */ | |
252b5132 RH |
237 | |
238 | char * | |
239 | frag_variant (type, max_chars, var, subtype, symbol, offset, opcode) | |
240 | relax_stateT type; | |
241 | int max_chars; | |
242 | int var; | |
243 | relax_substateT subtype; | |
244 | symbolS *symbol; | |
245 | offsetT offset; | |
246 | char *opcode; | |
247 | { | |
248 | register char *retval; | |
249 | ||
250 | retval = obstack_next_free (&frchain_now->frch_obstack); | |
251 | frag_now->fr_var = var; | |
252 | frag_now->fr_type = type; | |
253 | frag_now->fr_subtype = subtype; | |
254 | frag_now->fr_symbol = symbol; | |
255 | frag_now->fr_offset = offset; | |
256 | frag_now->fr_opcode = opcode; | |
257 | #ifdef USING_CGEN | |
258 | frag_now->fr_cgen.insn = 0; | |
259 | frag_now->fr_cgen.opindex = 0; | |
260 | frag_now->fr_cgen.opinfo = 0; | |
261 | #endif | |
262 | #ifdef TC_FRAG_INIT | |
263 | TC_FRAG_INIT (frag_now); | |
264 | #endif | |
265 | as_where (&frag_now->fr_file, &frag_now->fr_line); | |
266 | frag_new (max_chars); | |
267 | return (retval); | |
29f8404c | 268 | } |
252b5132 | 269 | \f |
29f8404c KH |
270 | /* Reduce the variable end of a frag to a harmless state. */ |
271 | ||
272 | void | |
252b5132 RH |
273 | frag_wane (fragP) |
274 | register fragS *fragP; | |
275 | { | |
276 | fragP->fr_type = rs_fill; | |
277 | fragP->fr_offset = 0; | |
278 | fragP->fr_var = 0; | |
279 | } | |
280 | \f | |
281 | /* Make an alignment frag. The size of this frag will be adjusted to | |
282 | force the next frag to have the appropriate alignment. ALIGNMENT | |
283 | is the power of two to which to align. FILL_CHARACTER is the | |
284 | character to use to fill in any bytes which are skipped. MAX is | |
285 | the maximum number of characters to skip when doing the alignment, | |
286 | or 0 if there is no maximum. */ | |
287 | ||
29f8404c | 288 | void |
252b5132 RH |
289 | frag_align (alignment, fill_character, max) |
290 | int alignment; | |
291 | int fill_character; | |
292 | int max; | |
293 | { | |
294 | if (now_seg == absolute_section) | |
295 | { | |
296 | addressT new_off; | |
65e68b04 | 297 | addressT mask; |
252b5132 | 298 | |
29f8404c KH |
299 | mask = (~(addressT) 0) << alignment; |
300 | new_off = (abs_section_offset + ~mask) & mask; | |
252b5132 RH |
301 | if (max == 0 || new_off - abs_section_offset <= (addressT) max) |
302 | abs_section_offset = new_off; | |
303 | } | |
304 | else | |
305 | { | |
306 | char *p; | |
307 | ||
308 | p = frag_var (rs_align, 1, 1, (relax_substateT) max, | |
309 | (symbolS *) 0, (offsetT) alignment, (char *) 0); | |
310 | *p = fill_character; | |
311 | } | |
312 | } | |
313 | ||
314 | /* Make an alignment frag like frag_align, but fill with a repeating | |
315 | pattern rather than a single byte. ALIGNMENT is the power of two | |
316 | to which to align. FILL_PATTERN is the fill pattern to repeat in | |
317 | the bytes which are skipped. N_FILL is the number of bytes in | |
318 | FILL_PATTERN. MAX is the maximum number of characters to skip when | |
319 | doing the alignment, or 0 if there is no maximum. */ | |
320 | ||
29f8404c | 321 | void |
252b5132 RH |
322 | frag_align_pattern (alignment, fill_pattern, n_fill, max) |
323 | int alignment; | |
324 | const char *fill_pattern; | |
325 | int n_fill; | |
326 | int max; | |
327 | { | |
328 | char *p; | |
329 | ||
330 | p = frag_var (rs_align, n_fill, n_fill, (relax_substateT) max, | |
331 | (symbolS *) 0, (offsetT) alignment, (char *) 0); | |
332 | memcpy (p, fill_pattern, n_fill); | |
333 | } | |
334 | ||
0a9ef439 RH |
335 | /* The NOP_OPCODE is for the alignment fill value. Fill it with a nop |
336 | instruction so that the disassembler does not choke on it. */ | |
337 | #ifndef NOP_OPCODE | |
338 | #define NOP_OPCODE 0x00 | |
339 | #endif | |
340 | ||
341 | /* Use this to restrict the amount of memory allocated for representing | |
342 | the alignment code. Needs to be large enough to hold any fixed sized | |
343 | prologue plus the replicating portion. */ | |
344 | #ifndef MAX_MEM_FOR_RS_ALIGN_CODE | |
345 | /* Assume that if HANDLE_ALIGN is not defined then no special action | |
346 | is required to code fill, which means that we get just repeat the | |
347 | one NOP_OPCODE byte. */ | |
348 | # ifndef HANDLE_ALIGN | |
349 | # define MAX_MEM_FOR_RS_ALIGN_CODE 1 | |
350 | # else | |
351 | # define MAX_MEM_FOR_RS_ALIGN_CODE ((1 << alignment) - 1) | |
352 | # endif | |
353 | #endif | |
354 | ||
355 | void | |
356 | frag_align_code (alignment, max) | |
357 | int alignment; | |
358 | int max; | |
359 | { | |
360 | char *p; | |
361 | ||
362 | p = frag_var (rs_align_code, MAX_MEM_FOR_RS_ALIGN_CODE, 1, | |
363 | (relax_substateT) max, (symbolS *) 0, | |
364 | (offsetT) alignment, (char *) 0); | |
365 | *p = NOP_OPCODE; | |
366 | } | |
367 | ||
252b5132 | 368 | addressT |
bea9907b | 369 | frag_now_fix_octets () |
252b5132 RH |
370 | { |
371 | if (now_seg == absolute_section) | |
372 | return abs_section_offset; | |
bea9907b | 373 | |
29f8404c KH |
374 | return ((char *) obstack_next_free (&frchain_now->frch_obstack) |
375 | - frag_now->fr_literal); | |
bea9907b TW |
376 | } |
377 | ||
378 | addressT | |
379 | frag_now_fix () | |
380 | { | |
29f8404c | 381 | return frag_now_fix_octets () / OCTETS_PER_BYTE; |
252b5132 RH |
382 | } |
383 | ||
384 | void | |
385 | frag_append_1_char (datum) | |
386 | int datum; | |
387 | { | |
e85ca5bb | 388 | frag_alloc_check (&frchain_now->frch_obstack); |
252b5132 RH |
389 | if (obstack_room (&frchain_now->frch_obstack) <= 1) |
390 | { | |
391 | frag_wane (frag_now); | |
392 | frag_new (0); | |
393 | } | |
394 | obstack_1grow (&frchain_now->frch_obstack, datum); | |
395 | } |