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