* subsegs.c (subseg_change): allow and handle a change into SEG_BSS.
[deliverable/binutils-gdb.git] / gas / frags.c
CommitLineData
fecd2382
RP
1/* frags.c - manage frags -
2 Copyright (C) 1987, 1990, 1991 Free Software Foundation, Inc.
a39116f1
RP
3
4 This file is part of GAS, the GNU Assembler.
5
6 GAS is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
9 any later version.
10
11 GAS is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with GAS; see the file COPYING. If not, write to
18 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
fecd2382
RP
19
20#include "as.h"
21#include "subsegs.h"
22#include "obstack.h"
23
24struct obstack frags; /* All, and only, frags live here. */
25
26fragS zero_address_frag = {
27 0, /* fr_address */
28 NULL, /* fr_next */
29 0, /* fr_fix */
30 0, /* fr_var */
31 0, /* fr_symbol */
32 0, /* fr_offset */
33 NULL, /* fr_opcode */
34 rs_fill, /* fr_type */
35 0, /* fr_subtype */
36 0, /* fr_pcrel_adjust */
37 0, /* fr_bsr */
38 0 /* fr_literal [0] */
a39116f1 39 };
fecd2382
RP
40
41fragS bss_address_frag = {
42 0, /* fr_address. Gets filled in to make up
43 sy_value-s. */
44 NULL, /* fr_next */
45 0, /* fr_fix */
46 0, /* fr_var */
47 0, /* fr_symbol */
48 0, /* fr_offset */
49 NULL, /* fr_opcode */
50 rs_fill, /* fr_type */
51 0, /* fr_subtype */
52 0, /* fr_pcrel_adjust */
53 0, /* fr_bsr */
54 0 /* fr_literal [0] */
a39116f1 55 };
fecd2382
RP
56\f
57/*
58 * frag_grow()
59 *
60 * Internal.
61 * Try to augment current frag by nchars chars.
62 * If there is no room, close of the current frag with a ".fill 0"
63 * and begin a new frag. Unless the new frag has nchars chars available
64 * do not return. Do not set up any fields of *now_frag.
65 */
66static void frag_grow(nchars)
67unsigned int nchars;
68{
a39116f1
RP
69 if (obstack_room (&frags) < nchars) {
70 unsigned int n,oldn;
71 long oldc;
72
fecd2382
RP
73 frag_wane(frag_now);
74 frag_new(0);
a39116f1
RP
75 oldn=(unsigned)-1;
76 oldc=frags.chunk_size;
77 frags.chunk_size=2*nchars;
78 while((n=obstack_room(&frags))<nchars && n<oldn) {
79 frag_wane(frag_now);
80 frag_new(0);
81 oldn=n;
82 }
83 frags.chunk_size=oldc;
fecd2382 84 }
a39116f1
RP
85 if (obstack_room (&frags) < nchars)
86 as_fatal("Can't extend frag %d. chars", nchars);
fecd2382
RP
87} /* frag_grow() */
88\f
89/*
90 * frag_new()
91 *
92 * Call this to close off a completed frag, and start up a new (empty)
93 * frag, in the same subsegment as the old frag.
94 * [frchain_now remains the same but frag_now is updated.]
95 * Because this calculates the correct value of fr_fix by
96 * looking at the obstack 'frags', it needs to know how many
97 * characters at the end of the old frag belong to (the maximal)
98 * fr_var: the rest must belong to fr_fix.
99 * It doesn't actually set up the old frag's fr_var: you may have
100 * set fr_var == 1, but allocated 10 chars to the end of the frag:
101 * in this case you pass old_frags_var_max_size == 10.
102 *
103 * Make a new frag, initialising some components. Link new frag at end
104 * of frchain_now.
105 */
106void frag_new(old_frags_var_max_size)
107int old_frags_var_max_size; /* Number of chars (already allocated on
108 obstack frags) */
a39116f1 109/* in variable_length part of frag. */
fecd2382 110{
a39116f1
RP
111 register fragS * former_last_fragP;
112 /* char *throw_away_pointer; JF unused */
113 register frchainS * frchP;
114 long tmp; /* JF */
115
116 frag_now->fr_fix = (char *) (obstack_next_free (&frags)) -
117 (frag_now->fr_literal) - old_frags_var_max_size;
118 /* Fix up old frag's fr_fix. */
119
120 obstack_finish (&frags);
121 /* This will align the obstack so the */
122 /* next struct we allocate on it will */
123 /* begin at a correct boundary. */
124 frchP = frchain_now;
125 know (frchP);
126 former_last_fragP = frchP->frch_last;
127 know (former_last_fragP);
128 know (former_last_fragP == frag_now);
129 obstack_blank (&frags, SIZEOF_STRUCT_FRAG);
130 /* We expect this will begin at a correct */
131 /* boundary for a struct. */
132 tmp=obstack_alignment_mask(&frags);
133 obstack_alignment_mask(&frags)=0; /* Turn off alignment */
134 /* If we ever hit a machine
135 where strings must be
136 aligned, we Lose Big */
137 frag_now=(fragS *)obstack_finish(&frags);
138 obstack_alignment_mask(&frags)=tmp; /* Restore alignment */
139
140 /* Just in case we don't get zero'd bytes */
141 bzero(frag_now, SIZEOF_STRUCT_FRAG);
142
143 /* obstack_unaligned_done (&frags, &frag_now); */
144 /* know (frags.obstack_c_next_free == frag_now->fr_literal); */
145 /* Generally, frag_now->points to an */
146 /* address rounded up to next alignment. */
147 /* However, characters will add to obstack */
148 /* frags IMMEDIATELY after the struct frag, */
149 /* even if they are not starting at an */
150 /* alignment address. */
151 former_last_fragP->fr_next = frag_now;
152 frchP->frch_last = frag_now;
153
154#ifndef NO_LISTING
155 {
156 extern struct list_info_struct *listing_tail;
157 frag_now->line = listing_tail;
158 }
159#endif
160
161 frag_now->fr_next = NULL;
fecd2382
RP
162} /* frag_new() */
163\f
164/*
165 * frag_more()
166 *
167 * Start a new frag unless we have n more chars of room in the current frag.
168 * Close off the old frag with a .fill 0.
169 *
170 * Return the address of the 1st char to write into. Advance
171 * frag_now_growth past the new chars.
172 */
173
174char *frag_more (nchars)
175int nchars;
176{
a39116f1
RP
177 register char *retval;
178
179 frag_grow (nchars);
180 retval = obstack_next_free (&frags);
181 obstack_blank_fast (&frags, nchars);
182 return (retval);
fecd2382
RP
183} /* frag_more() */
184\f
185/*
186 * frag_var()
187 *
188 * Start a new frag unless we have max_chars more chars of room in the current frag.
189 * Close off the old frag with a .fill 0.
190 *
191 * Set up a machine_dependent relaxable frag, then start a new frag.
192 * Return the address of the 1st char of the var part of the old frag
193 * to write into.
194 */
195
196char *frag_var(type, max_chars, var, subtype, symbol, offset, opcode)
197relax_stateT type;
198int max_chars;
199int var;
200relax_substateT subtype;
201symbolS *symbol;
202long offset;
203char *opcode;
204{
a39116f1
RP
205 register char *retval;
206
207 frag_grow (max_chars);
208 retval = obstack_next_free (&frags);
209 obstack_blank_fast (&frags, max_chars);
210 frag_now->fr_var = var;
211 frag_now->fr_type = type;
212 frag_now->fr_subtype = subtype;
213 frag_now->fr_symbol = symbol;
214 frag_now->fr_offset = offset;
215 frag_now->fr_opcode = opcode;
216 /* default these to zero. */
217 frag_now->fr_pcrel_adjust = 0;
218 frag_now->fr_bsr = 0;
219 frag_new (max_chars);
220 return (retval);
fecd2382
RP
221} /* frag_var() */
222\f
223/*
224 * frag_variant()
225 *
226 * OVE: This variant of frag_var assumes that space for the tail has been
227 * allocated by caller.
228 * No call to frag_grow is done.
229 * Two new arguments have been added.
230 */
231
232char *frag_variant(type, max_chars, var, subtype, symbol, offset, opcode, pcrel_adjust,bsr)
a39116f1
RP
233relax_stateT type;
234int max_chars;
235int var;
236relax_substateT subtype;
237symbolS *symbol;
238long offset;
239char *opcode;
240int pcrel_adjust;
241char bsr;
fecd2382 242{
a39116f1
RP
243 register char *retval;
244
245 /* frag_grow (max_chars); */
246 retval = obstack_next_free (&frags);
247 /* obstack_blank_fast (&frags, max_chars); */ /* OVE: so far the only diff */
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;
254 frag_now->fr_pcrel_adjust = pcrel_adjust;
255 frag_now->fr_bsr = bsr;
256 frag_new (max_chars);
257 return (retval);
fecd2382
RP
258} /* frag_variant() */
259\f
260/*
261 * frag_wane()
262 *
263 * Reduce the variable end of a frag to a harmless state.
264 */
265void frag_wane(fragP)
266register fragS * fragP;
267{
a39116f1
RP
268 fragP->fr_type = rs_fill;
269 fragP->fr_offset = 0;
270 fragP->fr_var = 0;
fecd2382
RP
271}
272\f
273/*
274 * frag_align()
275 *
276 * Make a frag for ".align foo,bar". Call is "frag_align (foo,bar);".
277 * Foo & bar are absolute integers.
278 *
279 * Call to close off the current frag with a ".align", then start a new
280 * (so far empty) frag, in the same subsegment as the last frag.
281 */
282
283void frag_align(alignment, fill_character)
284int alignment;
285int fill_character;
286{
a39116f1
RP
287 *(frag_var (rs_align, 1, 1, (relax_substateT)0, (symbolS *)0,
288 (long)alignment, (char *)0)) = fill_character;
fecd2382
RP
289} /* frag_align() */
290
8b228fe9 291/* end of frags.c */
This page took 0.061538 seconds and 4 git commands to generate.