1 /* frags.c - manage frags -
2 Copyright 1987, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
4 Free Software Foundation, Inc.
6 This file is part of GAS, the GNU Assembler.
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)
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.
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
27 extern fragS zero_address_frag
;
28 extern fragS bss_address_frag
;
30 /* Initialization for frag routines. */
35 zero_address_frag
.fr_type
= rs_fill
;
36 bss_address_frag
.fr_type
= rs_fill
;
39 /* Allocate a frag on the specified obstack.
40 Call this routine from everywhere else, so that all the weird alignment
41 hackery can be done in just one place. */
50 (void) obstack_alloc (ob
, 0);
51 oalign
= obstack_alignment_mask (ob
);
52 obstack_alignment_mask (ob
) = 0;
53 ptr
= (fragS
*) obstack_alloc (ob
, SIZEOF_STRUCT_FRAG
);
54 obstack_alignment_mask (ob
) = oalign
;
55 memset (ptr
, 0, SIZEOF_STRUCT_FRAG
);
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. */
68 /* Try really hard to grow the obstack. Creating a new obstack can
69 disable expression optimisations that would otherwise occur if
70 two symbols were located in the same obstack. */
71 if (obstack_room (&frchain_now
->frch_obstack
) < nchars
)
72 obstack_make_room (& frchain_now
->frch_obstack
, 2 * nchars
);
74 if (obstack_room (&frchain_now
->frch_obstack
) < nchars
)
81 oldc
= frchain_now
->frch_obstack
.chunk_size
;
82 frchain_now
->frch_obstack
.chunk_size
= 2 * nchars
+ SIZEOF_STRUCT_FRAG
;
83 if (frchain_now
->frch_obstack
.chunk_size
> 0)
84 while ((n
= obstack_room (&frchain_now
->frch_obstack
)) < nchars
85 && (unsigned long) frchain_now
->frch_obstack
.chunk_size
> nchars
)
90 frchain_now
->frch_obstack
.chunk_size
= oldc
;
92 if (obstack_room (&frchain_now
->frch_obstack
) < nchars
)
93 as_fatal (_("can't extend frag %u chars"), nchars
);
96 /* Call this to close off a completed frag, and start up a new (empty)
97 frag, in the same subsegment as the old frag.
98 [frchain_now remains the same but frag_now is updated.]
99 Because this calculates the correct value of fr_fix by
100 looking at the obstack 'frags', it needs to know how many
101 characters at the end of the old frag belong to the maximal
102 variable part; The rest must belong to fr_fix.
103 It doesn't actually set up the old frag's fr_var. You may have
104 set fr_var == 1, but allocated 10 chars to the end of the frag;
105 In this case you pass old_frags_var_max_size == 10.
106 In fact, you may use fr_var for something totally unrelated to the
107 size of the variable part of the frag; None of the generic frag
108 handling code makes use of fr_var.
110 Make a new frag, initialising some components. Link new frag at end
114 frag_new (old_frags_var_max_size
)
115 /* Number of chars (already allocated on obstack frags) in
116 variable_length part of frag. */
117 int old_frags_var_max_size
;
119 fragS
*former_last_fragP
;
122 assert (frchain_now
->frch_last
== frag_now
);
124 /* Fix up old frag's fr_fix. */
125 frag_now
->fr_fix
= frag_now_fix_octets () - old_frags_var_max_size
;
126 /* Make sure its type is valid. */
127 assert (frag_now
->fr_type
!= 0);
129 /* This will align the obstack so the next struct we allocate on it
130 will begin at a correct boundary. */
131 obstack_finish (&frchain_now
->frch_obstack
);
134 former_last_fragP
= frchP
->frch_last
;
135 assert (former_last_fragP
!= 0);
136 assert (former_last_fragP
== frag_now
);
137 frag_now
= frag_alloc (&frchP
->frch_obstack
);
139 as_where (&frag_now
->fr_file
, &frag_now
->fr_line
);
141 /* Generally, frag_now->points to an address rounded up to next
142 alignment. However, characters will add to obstack frags
143 IMMEDIATELY after the struct frag, even if they are not starting
144 at an alignment address. */
145 former_last_fragP
->fr_next
= frag_now
;
146 frchP
->frch_last
= frag_now
;
150 extern struct list_info_struct
*listing_tail
;
151 frag_now
->line
= listing_tail
;
155 assert (frchain_now
->frch_last
== frag_now
);
157 frag_now
->fr_next
= NULL
;
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. */
170 register char *retval
;
172 if (now_seg
== absolute_section
)
174 as_bad (_("attempt to allocate data in absolute section"));
175 subseg_set (text_section
, 0);
178 if (mri_common_symbol
!= NULL
)
180 as_bad (_("attempt to allocate data in common section"));
181 mri_common_symbol
= NULL
;
185 retval
= obstack_next_free (&frchain_now
->frch_obstack
);
186 obstack_blank_fast (&frchain_now
->frch_obstack
, nchars
);
190 /* Start a new frag unless we have max_chars more chars of room in the
191 current frag. Close off the old frag with a .fill 0.
193 Set up a machine_dependent relaxable frag, then start a new frag.
194 Return the address of the 1st char of the var part of the old frag
198 frag_var (type
, max_chars
, var
, subtype
, symbol
, offset
, opcode
)
202 relax_substateT subtype
;
207 register char *retval
;
209 frag_grow (max_chars
);
210 retval
= obstack_next_free (&frchain_now
->frch_obstack
);
211 obstack_blank_fast (&frchain_now
->frch_obstack
, max_chars
);
212 frag_now
->fr_var
= var
;
213 frag_now
->fr_type
= type
;
214 frag_now
->fr_subtype
= subtype
;
215 frag_now
->fr_symbol
= symbol
;
216 frag_now
->fr_offset
= offset
;
217 frag_now
->fr_opcode
= opcode
;
219 frag_now
->fr_cgen
.insn
= 0;
220 frag_now
->fr_cgen
.opindex
= 0;
221 frag_now
->fr_cgen
.opinfo
= 0;
224 TC_FRAG_INIT (frag_now
);
226 as_where (&frag_now
->fr_file
, &frag_now
->fr_line
);
227 frag_new (max_chars
);
231 /* OVE: This variant of frag_var assumes that space for the tail has been
233 No call to frag_grow is done. */
236 frag_variant (type
, max_chars
, var
, subtype
, symbol
, offset
, opcode
)
240 relax_substateT subtype
;
245 register char *retval
;
247 retval
= obstack_next_free (&frchain_now
->frch_obstack
);
248 frag_now
->fr_var
= var
;
249 frag_now
->fr_type
= type
;
250 frag_now
->fr_subtype
= subtype
;
251 frag_now
->fr_symbol
= symbol
;
252 frag_now
->fr_offset
= offset
;
253 frag_now
->fr_opcode
= opcode
;
255 frag_now
->fr_cgen
.insn
= 0;
256 frag_now
->fr_cgen
.opindex
= 0;
257 frag_now
->fr_cgen
.opinfo
= 0;
260 TC_FRAG_INIT (frag_now
);
262 as_where (&frag_now
->fr_file
, &frag_now
->fr_line
);
263 frag_new (max_chars
);
267 /* Reduce the variable end of a frag to a harmless state. */
271 register fragS
*fragP
;
273 fragP
->fr_type
= rs_fill
;
274 fragP
->fr_offset
= 0;
278 /* Make an alignment frag. The size of this frag will be adjusted to
279 force the next frag to have the appropriate alignment. ALIGNMENT
280 is the power of two to which to align. FILL_CHARACTER is the
281 character to use to fill in any bytes which are skipped. MAX is
282 the maximum number of characters to skip when doing the alignment,
283 or 0 if there is no maximum. */
286 frag_align (alignment
, fill_character
, max
)
291 if (now_seg
== absolute_section
)
296 mask
= (~(addressT
) 0) << alignment
;
297 new_off
= (abs_section_offset
+ ~mask
) & mask
;
298 if (max
== 0 || new_off
- abs_section_offset
<= (addressT
) max
)
299 abs_section_offset
= new_off
;
305 p
= frag_var (rs_align
, 1, 1, (relax_substateT
) max
,
306 (symbolS
*) 0, (offsetT
) alignment
, (char *) 0);
311 /* Make an alignment frag like frag_align, but fill with a repeating
312 pattern rather than a single byte. ALIGNMENT is the power of two
313 to which to align. FILL_PATTERN is the fill pattern to repeat in
314 the bytes which are skipped. N_FILL is the number of bytes in
315 FILL_PATTERN. MAX is the maximum number of characters to skip when
316 doing the alignment, or 0 if there is no maximum. */
319 frag_align_pattern (alignment
, fill_pattern
, n_fill
, max
)
321 const char *fill_pattern
;
327 p
= frag_var (rs_align
, n_fill
, n_fill
, (relax_substateT
) max
,
328 (symbolS
*) 0, (offsetT
) alignment
, (char *) 0);
329 memcpy (p
, fill_pattern
, n_fill
);
332 /* The NOP_OPCODE is for the alignment fill value. Fill it with a nop
333 instruction so that the disassembler does not choke on it. */
335 #define NOP_OPCODE 0x00
338 /* Use this to restrict the amount of memory allocated for representing
339 the alignment code. Needs to be large enough to hold any fixed sized
340 prologue plus the replicating portion. */
341 #ifndef MAX_MEM_FOR_RS_ALIGN_CODE
342 /* Assume that if HANDLE_ALIGN is not defined then no special action
343 is required to code fill, which means that we get just repeat the
344 one NOP_OPCODE byte. */
345 # ifndef HANDLE_ALIGN
346 # define MAX_MEM_FOR_RS_ALIGN_CODE 1
348 # define MAX_MEM_FOR_RS_ALIGN_CODE ((1 << alignment) - 1)
353 frag_align_code (alignment
, max
)
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);
366 frag_now_fix_octets ()
368 if (now_seg
== absolute_section
)
369 return abs_section_offset
;
371 return ((char *) obstack_next_free (&frchain_now
->frch_obstack
)
372 - frag_now
->fr_literal
);
378 return frag_now_fix_octets () / OCTETS_PER_BYTE
;
382 frag_append_1_char (datum
)
385 if (obstack_room (&frchain_now
->frch_obstack
) <= 1)
387 frag_wane (frag_now
);
390 obstack_1grow (&frchain_now
->frch_obstack
, datum
);