1 /* subsegs.c - subsegments -
2 Copyright (C) 1987, 1990, 1991, 1992 Free Software Foundation, Inc.
4 This file is part of GAS, the GNU Assembler.
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)
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.
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. */
21 * Segments & sub-segments.
30 segment_info_type segment_info[SEG_MAXIMUM_ORDINAL];
32 frchainS* frchain_root,
36 frchainS* frchain_root,
37 * frchain_now, /* Commented in "subsegs.h". */
42 char * const /* in: segT out: char* */
46 "e0","e1","e2","e3","e4","e5","e6","e7","e8","e9",
55 "ASSEMBLER-INTERNAL-LOGIC-ERROR!",
59 "transfert vector preload",
60 "transfert vector postload",
63 }; /* Used by error reporters, dumpers etc. */
69 /* Check table(s) seg_name[], seg_N_TYPE[] is in correct order */
72 know( SEG_ABSOLUTE == 0 );
73 know( SEG_TEXT == 1 );
74 know( SEG_DATA == 2 );
76 know( SEG_UNKNOWN == 4 );
77 know( SEG_ABSENT == 5 );
78 know( SEG_PASS1 == 6 );
79 know( SEG_GOOF == 7 );
81 know( SEG_DIFFERENCE == 9 );
82 know( SEG_DEBUG == 10 );
83 know( SEG_NTV == 11 );
84 know( SEG_PTV == 12 );
85 know( SEG_REGISTER == 13 );
86 know( SEG_MAXIMUM_ORDINAL == SEG_REGISTER );
87 /* know( segment_name (SEG_MAXIMUM_ORDINAL + 1) [0] == 0 );*/
90 obstack_begin( &frags, 5000);
92 frchain_now = NULL; /* Warn new_subseg() that we are booting. */
93 /* Fake up 1st frag. */
94 /* It won't be used=> is ok if obstack... */
95 /* pads the end of it for alignment. */
96 frag_now=(fragS *)obstack_alloc(&frags,SIZEOF_STRUCT_FRAG);
97 memset(frag_now, SIZEOF_STRUCT_FRAG, 0);
98 /* This 1st frag will not be in any frchain. */
99 /* We simply give subseg_new somewhere to scribble. */
100 now_subseg = 42; /* Lie for 1st call to subseg_new. */
104 for (i = SEG_E0; i < SEG_UNKNOWN; i++) {
106 segment_info[i].frchainP = frchain_now;
110 subseg_new (SEG_DATA, 0); /* .data 0 */
111 data0_frchainP = frchain_now;
112 subseg_new (SEG_BSS, 0);
113 bss0_frchainP = frchain_now;
121 * Change the subsegment we are in, BUT DO NOT MAKE A NEW FRAG for the
122 * subsegment. If we are already in the correct subsegment, change nothing.
123 * This is used eg as a worker for subseg_new [which does make a new frag_now]
124 * and for changing segments after we have read the source. We construct eg
125 * fixSs even after the source file is read, so we do have to keep the
126 * segment context correct.
129 subseg_change (seg, subseg)
136 seg_fix_rootP = & segment_info[seg].fix_root;
137 seg_fix_tailP = & segment_info[seg].fix_tail;
141 seg_fix_rootP = & bss_fix_root;
142 seg_fix_tailP = & bss_fix_tail;
144 else if (seg == SEG_DATA)
146 seg_fix_rootP = & data_fix_root;
147 seg_fix_tailP = & data_fix_tail;
151 know (seg == SEG_TEXT);
152 seg_fix_rootP = & text_fix_root;
153 seg_fix_tailP = & text_fix_tail;
161 * If you attempt to change to the current subsegment, nothing happens.
163 * In: segT, subsegT code for new subsegment.
164 * frag_now -> incomplete frag for current subsegment.
165 * If frag_now==NULL, then there is no old, incomplete frag, so
166 * the old frag is not closed off.
168 * Out: now_subseg, now_seg updated.
169 * Frchain_now points to the (possibly new) struct frchain for this
171 * Frchain_root updated if needed.
175 subseg_new (seg, subseg) /* begin assembly for a new sub-segment */
176 register segT seg; /* SEG_DATA or SEG_TEXT or SEG_BSS */
177 register subsegT subseg;
179 long tmp; /* JF for obstack alignment hacking */
180 #ifndef MANY_SEGMENTS
181 know( seg == SEG_DATA || seg == SEG_TEXT || seg == SEG_BSS);
183 if (seg != now_seg || subseg != now_subseg)
184 { /* we just changed sub-segments */
185 register frchainS * frcP; /* crawl frchain chain */
186 register frchainS** lastPP; /* address of last pointer */
187 frchainS * newP; /* address of new frchain */
188 register fragS * former_last_fragP;
189 register fragS * new_fragP;
191 if (frag_now) /* If not bootstrapping. */
193 frag_now -> fr_fix = obstack_next_free(& frags) - frag_now -> fr_literal;
194 frag_wane(frag_now); /* Close off any frag in old subseg. */
197 * It would be nice to keep an obstack for each subsegment, if we swap
198 * subsegments a lot. Hence we would have much fewer frag_wanes().
202 obstack_finish( &frags);
204 * If we don't do the above, the next object we put on obstack frags
205 * will appear to start at the fr_literal of the current frag.
206 * Also, above ensures that the next object will begin on a
207 * address that is aligned correctly for the engine that runs
211 subseg_change (seg, (int)subseg);
213 * Attempt to find or make a frchain for that sub seg.
214 * Crawl along chain of frchainSs, begins @ frchain_root.
215 * If we need to make a frchainS, link it into correct
216 * position of chain rooted in frchain_root.
218 for (frcP = * (lastPP = & frchain_root);
220 && (int)(frcP -> frch_seg) <= (int)seg;
221 frcP = * ( lastPP = & frcP -> frch_next)
224 if ( (int)(frcP -> frch_seg) == (int)seg
225 && frcP -> frch_subseg >= subseg)
231 * frcP: Address of the 1st frchainS in correct segment with
232 * frch_subseg >= subseg.
233 * We want to either use this frchainS, or we want
234 * to insert a new frchainS just before it.
236 * If frcP==NULL, then we are at the end of the chain
237 * of frchainS-s. A NULL frcP means we fell off the end
238 * of the chain looking for a
239 * frch_subseg >= subseg, so we
240 * must make a new frchainS.
242 * If we ever maintain a pointer to
243 * the last frchainS in the chain, we change that pointer
244 * ONLY when frcP==NULL.
246 * lastPP: Address of the pointer with value frcP;
248 * May point to frchain_root.
252 || ( (int)(frcP -> frch_seg) > (int)seg
253 || frcP->frch_subseg > subseg)) /* Kinky logic only works with 2 segments. */
256 * This should be the only code that creates a frchainS.
258 newP=(frchainS *)obstack_alloc(&frags,sizeof(frchainS));
259 memset(newP, sizeof(frchainS), 0);
260 /* This begines on a good boundary */
261 /* because a obstack_done() preceeded it. */
262 /* It implies an obstack_done(), so we */
263 /* expect the next object allocated to */
264 /* begin on a correct boundary. */
266 newP -> frch_next = frcP; /* perhaps NULL */
267 (frcP = newP) -> frch_subseg = subseg;
268 newP -> frch_seg = seg;
269 newP -> frch_last = NULL;
272 * Here with frcP ->ing to the frchainS for subseg.
276 * Make a fresh frag for the subsegment.
278 /* We expect this to happen on a correct */
279 /* boundary since it was proceeded by a */
280 /* obstack_done(). */
281 tmp=obstack_alignment_mask(&frags); /* JF disable alignment */
282 obstack_alignment_mask(&frags)=0;
283 frag_now=(fragS *)obstack_alloc(&frags,SIZEOF_STRUCT_FRAG);
284 obstack_alignment_mask(&frags)=tmp;
285 /* know( frags . obstack_c_next_free == frag_now -> fr_literal ); */
286 /* But we want any more chars to come */
287 /* immediately after the structure we just made. */
288 new_fragP = frag_now;
289 new_fragP -> fr_next = NULL;
291 * Append new frag to current frchain.
293 former_last_fragP = frcP -> frch_last;
294 if (former_last_fragP)
296 know( former_last_fragP -> fr_next == NULL );
297 know( frchain_now -> frch_root );
298 former_last_fragP -> fr_next = new_fragP;
302 frcP -> frch_root = new_fragP;
304 frcP -> frch_last = new_fragP;
305 } /* if (changing subsegments) */
315 /* end of subsegs.c */