Commit | Line | Data |
---|---|---|
252b5132 | 1 | /* frags.c - manage frags - |
f7e42eb4 | 2 | Copyright 1987, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, |
aa820537 | 3 | 1999, 2000, 2001, 2003, 2004, 2005, 2006, 2007, 2008, 2009 |
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 | |
ec2655a6 | 10 | the Free Software Foundation; either version 3, or (at your option) |
252b5132 RH |
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 | |
4b4da160 NC |
20 | Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA |
21 | 02110-1301, USA. */ | |
252b5132 RH |
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 | 32 | void |
dd625418 | 33 | frag_init (void) |
252b5132 RH |
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 | 63 | fragS * |
dd625418 | 64 | frag_alloc (struct obstack *ob) |
252b5132 RH |
65 | { |
66 | fragS *ptr; | |
67 | int oalign; | |
68 | ||
69 | (void) obstack_alloc (ob, 0); | |
70 | oalign = obstack_alignment_mask (ob); | |
71 | obstack_alignment_mask (ob) = 0; | |
1e9cc1c2 | 72 | ptr = (fragS *) obstack_alloc (ob, SIZEOF_STRUCT_FRAG); |
252b5132 RH |
73 | obstack_alignment_mask (ob) = oalign; |
74 | memset (ptr, 0, SIZEOF_STRUCT_FRAG); | |
75 | return ptr; | |
76 | } | |
77 | \f | |
179809c0 | 78 | /* Try to augment current frag by NCHARS chars. |
29f8404c | 79 | If there is no room, close of the current frag with a ".fill 0" |
179809c0 | 80 | and begin a new frag. Do not set up any fields of *now_frag. */ |
29f8404c KH |
81 | |
82 | void | |
dd625418 | 83 | frag_grow (unsigned int nchars) |
252b5132 RH |
84 | { |
85 | if (obstack_room (&frchain_now->frch_obstack) < nchars) | |
86 | { | |
252b5132 | 87 | long oldc; |
179809c0 | 88 | long newc; |
252b5132 | 89 | |
179809c0 | 90 | /* Not enough room in this frag. Close it. */ |
252b5132 | 91 | frag_wane (frag_now); |
179809c0 | 92 | |
ee192366 MM |
93 | /* Try to allocate a bit more than needed right now. But don't do |
94 | this if we would waste too much memory. Especially necessary | |
179809c0 | 95 | for extremely big (like 2GB initialized) frags. */ |
ee192366 | 96 | if (nchars < 0x10000) |
179809c0 | 97 | newc = 2 * nchars; |
ee192366 | 98 | else |
179809c0 TG |
99 | newc = nchars + 0x10000; |
100 | newc += SIZEOF_STRUCT_FRAG; | |
101 | ||
102 | if (newc > 0) | |
103 | { | |
104 | /* Force to allocate at least NEWC bytes. */ | |
105 | oldc = obstack_chunk_size (&frchain_now->frch_obstack); | |
106 | obstack_chunk_size (&frchain_now->frch_obstack) = newc; | |
107 | ||
108 | /* Do the real work: create a new frag. */ | |
109 | frag_new (0); | |
110 | ||
111 | /* Restore the old chunk size. */ | |
112 | obstack_chunk_size (&frchain_now->frch_obstack) = oldc; | |
113 | } | |
114 | ||
115 | /* Check for success (also handles negative values of NEWC). */ | |
116 | if (obstack_room (&frchain_now->frch_obstack) < nchars) | |
117 | as_fatal (_("can't extend frag %u chars"), nchars); | |
252b5132 | 118 | } |
252b5132 RH |
119 | } |
120 | \f | |
29f8404c KH |
121 | /* Call this to close off a completed frag, and start up a new (empty) |
122 | frag, in the same subsegment as the old frag. | |
123 | [frchain_now remains the same but frag_now is updated.] | |
124 | Because this calculates the correct value of fr_fix by | |
125 | looking at the obstack 'frags', it needs to know how many | |
126 | characters at the end of the old frag belong to the maximal | |
127 | variable part; The rest must belong to fr_fix. | |
128 | It doesn't actually set up the old frag's fr_var. You may have | |
129 | set fr_var == 1, but allocated 10 chars to the end of the frag; | |
130 | In this case you pass old_frags_var_max_size == 10. | |
131 | In fact, you may use fr_var for something totally unrelated to the | |
132 | size of the variable part of the frag; None of the generic frag | |
133 | handling code makes use of fr_var. | |
134 | ||
135 | Make a new frag, initialising some components. Link new frag at end | |
136 | of frchain_now. */ | |
137 | ||
138 | void | |
dd625418 KH |
139 | frag_new (int old_frags_var_max_size |
140 | /* Number of chars (already allocated on obstack frags) in | |
141 | variable_length part of frag. */) | |
252b5132 RH |
142 | { |
143 | fragS *former_last_fragP; | |
144 | frchainS *frchP; | |
145 | ||
9c2799c2 | 146 | gas_assert (frchain_now->frch_last == frag_now); |
252b5132 RH |
147 | |
148 | /* Fix up old frag's fr_fix. */ | |
bea9907b | 149 | frag_now->fr_fix = frag_now_fix_octets () - old_frags_var_max_size; |
252b5132 | 150 | /* Make sure its type is valid. */ |
9c2799c2 | 151 | gas_assert (frag_now->fr_type != 0); |
252b5132 RH |
152 | |
153 | /* This will align the obstack so the next struct we allocate on it | |
29f8404c | 154 | will begin at a correct boundary. */ |
252b5132 RH |
155 | obstack_finish (&frchain_now->frch_obstack); |
156 | frchP = frchain_now; | |
157 | know (frchP); | |
158 | former_last_fragP = frchP->frch_last; | |
9c2799c2 NC |
159 | gas_assert (former_last_fragP != 0); |
160 | gas_assert (former_last_fragP == frag_now); | |
252b5132 RH |
161 | frag_now = frag_alloc (&frchP->frch_obstack); |
162 | ||
163 | as_where (&frag_now->fr_file, &frag_now->fr_line); | |
164 | ||
165 | /* Generally, frag_now->points to an address rounded up to next | |
166 | alignment. However, characters will add to obstack frags | |
167 | IMMEDIATELY after the struct frag, even if they are not starting | |
29f8404c | 168 | at an alignment address. */ |
252b5132 RH |
169 | former_last_fragP->fr_next = frag_now; |
170 | frchP->frch_last = frag_now; | |
171 | ||
172 | #ifndef NO_LISTING | |
173 | { | |
174 | extern struct list_info_struct *listing_tail; | |
175 | frag_now->line = listing_tail; | |
176 | } | |
177 | #endif | |
178 | ||
9c2799c2 | 179 | gas_assert (frchain_now->frch_last == frag_now); |
252b5132 RH |
180 | |
181 | frag_now->fr_next = NULL; | |
29f8404c | 182 | } |
252b5132 | 183 | \f |
29f8404c KH |
184 | /* Start a new frag unless we have n more chars of room in the current frag. |
185 | Close off the old frag with a .fill 0. | |
186 | ||
187 | Return the address of the 1st char to write into. Advance | |
188 | frag_now_growth past the new chars. */ | |
252b5132 RH |
189 | |
190 | char * | |
dd625418 | 191 | frag_more (int nchars) |
252b5132 RH |
192 | { |
193 | register char *retval; | |
194 | ||
e85ca5bb | 195 | frag_alloc_check (&frchain_now->frch_obstack); |
252b5132 RH |
196 | frag_grow (nchars); |
197 | retval = obstack_next_free (&frchain_now->frch_obstack); | |
198 | obstack_blank_fast (&frchain_now->frch_obstack, nchars); | |
199 | return (retval); | |
29f8404c | 200 | } |
252b5132 | 201 | \f |
29f8404c KH |
202 | /* Start a new frag unless we have max_chars more chars of room in the |
203 | current frag. Close off the old frag with a .fill 0. | |
204 | ||
205 | Set up a machine_dependent relaxable frag, then start a new frag. | |
206 | Return the address of the 1st char of the var part of the old frag | |
207 | to write into. */ | |
252b5132 RH |
208 | |
209 | char * | |
dd625418 KH |
210 | frag_var (relax_stateT type, int max_chars, int var, relax_substateT subtype, |
211 | symbolS *symbol, offsetT offset, char *opcode) | |
252b5132 RH |
212 | { |
213 | register char *retval; | |
214 | ||
215 | frag_grow (max_chars); | |
216 | retval = obstack_next_free (&frchain_now->frch_obstack); | |
217 | obstack_blank_fast (&frchain_now->frch_obstack, max_chars); | |
218 | frag_now->fr_var = var; | |
219 | frag_now->fr_type = type; | |
220 | frag_now->fr_subtype = subtype; | |
221 | frag_now->fr_symbol = symbol; | |
222 | frag_now->fr_offset = offset; | |
223 | frag_now->fr_opcode = opcode; | |
224 | #ifdef USING_CGEN | |
225 | frag_now->fr_cgen.insn = 0; | |
226 | frag_now->fr_cgen.opindex = 0; | |
227 | frag_now->fr_cgen.opinfo = 0; | |
228 | #endif | |
229 | #ifdef TC_FRAG_INIT | |
230 | TC_FRAG_INIT (frag_now); | |
231 | #endif | |
232 | as_where (&frag_now->fr_file, &frag_now->fr_line); | |
233 | frag_new (max_chars); | |
234 | return (retval); | |
235 | } | |
236 | \f | |
29f8404c KH |
237 | /* OVE: This variant of frag_var assumes that space for the tail has been |
238 | allocated by caller. | |
239 | No call to frag_grow is done. */ | |
252b5132 RH |
240 | |
241 | char * | |
dd625418 KH |
242 | frag_variant (relax_stateT type, int max_chars, int var, |
243 | relax_substateT subtype, symbolS *symbol, offsetT offset, | |
244 | char *opcode) | |
252b5132 RH |
245 | { |
246 | register char *retval; | |
247 | ||
248 | retval = obstack_next_free (&frchain_now->frch_obstack); | |
249 | frag_now->fr_var = var; | |
250 | frag_now->fr_type = type; | |
251 | frag_now->fr_subtype = subtype; | |
252 | frag_now->fr_symbol = symbol; | |
253 | frag_now->fr_offset = offset; | |
254 | frag_now->fr_opcode = opcode; | |
255 | #ifdef USING_CGEN | |
256 | frag_now->fr_cgen.insn = 0; | |
257 | frag_now->fr_cgen.opindex = 0; | |
258 | frag_now->fr_cgen.opinfo = 0; | |
259 | #endif | |
260 | #ifdef TC_FRAG_INIT | |
261 | TC_FRAG_INIT (frag_now); | |
262 | #endif | |
263 | as_where (&frag_now->fr_file, &frag_now->fr_line); | |
264 | frag_new (max_chars); | |
265 | return (retval); | |
29f8404c | 266 | } |
252b5132 | 267 | \f |
29f8404c KH |
268 | /* Reduce the variable end of a frag to a harmless state. */ |
269 | ||
270 | void | |
dd625418 | 271 | frag_wane (register fragS *fragP) |
252b5132 RH |
272 | { |
273 | fragP->fr_type = rs_fill; | |
274 | fragP->fr_offset = 0; | |
275 | fragP->fr_var = 0; | |
0530d30a RS |
276 | } |
277 | \f | |
278 | /* Return the number of bytes by which the current frag can be grown. */ | |
279 | ||
280 | int | |
281 | frag_room (void) | |
282 | { | |
283 | return obstack_room (&frchain_now->frch_obstack); | |
252b5132 RH |
284 | } |
285 | \f | |
286 | /* Make an alignment frag. The size of this frag will be adjusted to | |
287 | force the next frag to have the appropriate alignment. ALIGNMENT | |
288 | is the power of two to which to align. FILL_CHARACTER is the | |
289 | character to use to fill in any bytes which are skipped. MAX is | |
290 | the maximum number of characters to skip when doing the alignment, | |
291 | or 0 if there is no maximum. */ | |
292 | ||
29f8404c | 293 | void |
dd625418 | 294 | frag_align (int alignment, int fill_character, int max) |
252b5132 RH |
295 | { |
296 | if (now_seg == absolute_section) | |
297 | { | |
298 | addressT new_off; | |
65e68b04 | 299 | addressT mask; |
252b5132 | 300 | |
29f8404c KH |
301 | mask = (~(addressT) 0) << alignment; |
302 | new_off = (abs_section_offset + ~mask) & mask; | |
252b5132 RH |
303 | if (max == 0 || new_off - abs_section_offset <= (addressT) max) |
304 | abs_section_offset = new_off; | |
305 | } | |
306 | else | |
307 | { | |
308 | char *p; | |
309 | ||
310 | p = frag_var (rs_align, 1, 1, (relax_substateT) max, | |
311 | (symbolS *) 0, (offsetT) alignment, (char *) 0); | |
312 | *p = fill_character; | |
313 | } | |
314 | } | |
315 | ||
316 | /* Make an alignment frag like frag_align, but fill with a repeating | |
317 | pattern rather than a single byte. ALIGNMENT is the power of two | |
318 | to which to align. FILL_PATTERN is the fill pattern to repeat in | |
319 | the bytes which are skipped. N_FILL is the number of bytes in | |
320 | FILL_PATTERN. MAX is the maximum number of characters to skip when | |
321 | doing the alignment, or 0 if there is no maximum. */ | |
322 | ||
29f8404c | 323 | void |
dd625418 KH |
324 | frag_align_pattern (int alignment, const char *fill_pattern, |
325 | int n_fill, int max) | |
252b5132 RH |
326 | { |
327 | char *p; | |
328 | ||
329 | p = frag_var (rs_align, n_fill, n_fill, (relax_substateT) max, | |
330 | (symbolS *) 0, (offsetT) alignment, (char *) 0); | |
331 | memcpy (p, fill_pattern, n_fill); | |
332 | } | |
333 | ||
0a9ef439 RH |
334 | /* The NOP_OPCODE is for the alignment fill value. Fill it with a nop |
335 | instruction so that the disassembler does not choke on it. */ | |
336 | #ifndef NOP_OPCODE | |
337 | #define NOP_OPCODE 0x00 | |
338 | #endif | |
339 | ||
340 | /* Use this to restrict the amount of memory allocated for representing | |
341 | the alignment code. Needs to be large enough to hold any fixed sized | |
342 | prologue plus the replicating portion. */ | |
343 | #ifndef MAX_MEM_FOR_RS_ALIGN_CODE | |
344 | /* Assume that if HANDLE_ALIGN is not defined then no special action | |
345 | is required to code fill, which means that we get just repeat the | |
346 | one NOP_OPCODE byte. */ | |
347 | # ifndef HANDLE_ALIGN | |
348 | # define MAX_MEM_FOR_RS_ALIGN_CODE 1 | |
349 | # else | |
350 | # define MAX_MEM_FOR_RS_ALIGN_CODE ((1 << alignment) - 1) | |
351 | # endif | |
352 | #endif | |
353 | ||
354 | void | |
dd625418 | 355 | frag_align_code (int alignment, int max) |
0a9ef439 RH |
356 | { |
357 | char *p; | |
358 | ||
359 | p = frag_var (rs_align_code, MAX_MEM_FOR_RS_ALIGN_CODE, 1, | |
360 | (relax_substateT) max, (symbolS *) 0, | |
361 | (offsetT) alignment, (char *) 0); | |
362 | *p = NOP_OPCODE; | |
363 | } | |
364 | ||
252b5132 | 365 | addressT |
dd625418 | 366 | frag_now_fix_octets (void) |
252b5132 RH |
367 | { |
368 | if (now_seg == absolute_section) | |
369 | return abs_section_offset; | |
bea9907b | 370 | |
29f8404c KH |
371 | return ((char *) obstack_next_free (&frchain_now->frch_obstack) |
372 | - frag_now->fr_literal); | |
bea9907b TW |
373 | } |
374 | ||
375 | addressT | |
dd625418 | 376 | frag_now_fix (void) |
bea9907b | 377 | { |
29f8404c | 378 | return frag_now_fix_octets () / OCTETS_PER_BYTE; |
252b5132 RH |
379 | } |
380 | ||
381 | void | |
dd625418 | 382 | frag_append_1_char (int datum) |
252b5132 | 383 | { |
e85ca5bb | 384 | frag_alloc_check (&frchain_now->frch_obstack); |
252b5132 RH |
385 | if (obstack_room (&frchain_now->frch_obstack) <= 1) |
386 | { | |
387 | frag_wane (frag_now); | |
388 | frag_new (0); | |
389 | } | |
390 | obstack_1grow (&frchain_now->frch_obstack, datum); | |
391 | } | |
99630778 AM |
392 | |
393 | /* Return TRUE if FRAG1 and FRAG2 have a fixed relationship between | |
394 | their start addresses. Set OFFSET to the difference in address | |
395 | not already accounted for in the frag FR_ADDRESS. */ | |
396 | ||
397 | bfd_boolean | |
6cbe03fb | 398 | frag_offset_fixed_p (const fragS *frag1, const fragS *frag2, bfd_vma *offset) |
99630778 | 399 | { |
6cbe03fb | 400 | const fragS *frag; |
99630778 AM |
401 | bfd_vma off; |
402 | ||
403 | /* Start with offset initialised to difference between the two frags. | |
404 | Prior to assigning frag addresses this will be zero. */ | |
405 | off = frag1->fr_address - frag2->fr_address; | |
406 | if (frag1 == frag2) | |
407 | { | |
408 | *offset = off; | |
409 | return TRUE; | |
410 | } | |
411 | ||
412 | /* Maybe frag2 is after frag1. */ | |
413 | frag = frag1; | |
414 | while (frag->fr_type == rs_fill) | |
415 | { | |
416 | off += frag->fr_fix + frag->fr_offset * frag->fr_var; | |
417 | frag = frag->fr_next; | |
418 | if (frag == NULL) | |
419 | break; | |
420 | if (frag == frag2) | |
421 | { | |
422 | *offset = off; | |
423 | return TRUE; | |
424 | } | |
425 | } | |
426 | ||
427 | /* Maybe frag1 is after frag2. */ | |
ec651a3b | 428 | off = frag1->fr_address - frag2->fr_address; |
99630778 AM |
429 | frag = frag2; |
430 | while (frag->fr_type == rs_fill) | |
431 | { | |
432 | off -= frag->fr_fix + frag->fr_offset * frag->fr_var; | |
433 | frag = frag->fr_next; | |
434 | if (frag == NULL) | |
435 | break; | |
436 | if (frag == frag1) | |
437 | { | |
438 | *offset = off; | |
439 | return TRUE; | |
440 | } | |
441 | } | |
442 | ||
443 | return FALSE; | |
444 | } |