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
;
113 subseg_new (SEG_BSS
, 0);
114 bss0_frchainP
= frchain_now
;
123 * Change the subsegment we are in, BUT DO NOT MAKE A NEW FRAG for the
124 * subsegment. If we are already in the correct subsegment, change nothing.
125 * This is used eg as a worker for subseg_new [which does make a new frag_now]
126 * and for changing segments after we have read the source. We construct eg
127 * fixSs even after the source file is read, so we do have to keep the
128 * segment context correct.
131 subseg_change (seg
, subseg
)
138 seg_fix_rootP
= & segment_info
[seg
].fix_root
;
139 seg_fix_tailP
= & segment_info
[seg
].fix_tail
;
143 seg_fix_rootP
= & data_fix_root
;
144 seg_fix_tailP
= & data_fix_tail
;
146 else if (seg
== SEG_TEXT
)
148 seg_fix_rootP
= & text_fix_root
;
149 seg_fix_tailP
= & text_fix_tail
;
152 know (seg
== SEG_BSS
);
153 seg_fix_rootP
= & bss_fix_root
;
154 seg_fix_tailP
= & bss_fix_tail
;
162 * If you attempt to change to the current subsegment, nothing happens.
164 * In: segT, subsegT code for new subsegment.
165 * frag_now -> incomplete frag for current subsegment.
166 * If frag_now==NULL, then there is no old, incomplete frag, so
167 * the old frag is not closed off.
169 * Out: now_subseg, now_seg updated.
170 * Frchain_now points to the (possibly new) struct frchain for this
172 * Frchain_root updated if needed.
176 subseg_new (seg
, subseg
) /* begin assembly for a new sub-segment */
177 register segT seg
; /* SEG_DATA or SEG_TEXT */
178 register subsegT subseg
;
180 long tmp
; /* JF for obstack alignment hacking */
181 #ifndef MANY_SEGMENTS
182 know(seg
== SEG_DATA
|| seg
== SEG_TEXT
|| seg
== SEG_BSS
);
185 /* If -R specifed, always put stuff into the data section */
195 if (seg
!= now_seg
|| subseg
!= now_subseg
)
196 { /* we just changed sub-segments */
197 register frchainS
* frcP
; /* crawl frchain chain */
198 register frchainS
** lastPP
; /* address of last pointer */
199 frchainS
* newP
; /* address of new frchain */
200 register fragS
* former_last_fragP
;
201 register fragS
* new_fragP
;
203 if (frag_now
) /* If not bootstrapping. */
205 frag_now
-> fr_fix
= obstack_next_free(& frags
) - frag_now
-> fr_literal
;
206 frag_wane(frag_now
); /* Close off any frag in old subseg. */
209 * It would be nice to keep an obstack for each subsegment, if we swap
210 * subsegments a lot. Hence we would have much fewer frag_wanes().
214 obstack_finish( &frags
);
216 * If we don't do the above, the next object we put on obstack frags
217 * will appear to start at the fr_literal of the current frag.
218 * Also, above ensures that the next object will begin on a
219 * address that is aligned correctly for the engine that runs
223 subseg_change (seg
, (int)subseg
);
225 * Attempt to find or make a frchain for that sub seg.
226 * Crawl along chain of frchainSs, begins @ frchain_root.
227 * If we need to make a frchainS, link it into correct
228 * position of chain rooted in frchain_root.
230 for (frcP
= * (lastPP
= & frchain_root
);
232 && (int)(frcP
-> frch_seg
) <= (int)seg
;
233 frcP
= * ( lastPP
= & frcP
-> frch_next
)
236 if ( (int)(frcP
-> frch_seg
) == (int)seg
237 && frcP
-> frch_subseg
>= subseg
)
243 * frcP: Address of the 1st frchainS in correct segment with
244 * frch_subseg >= subseg.
245 * We want to either use this frchainS, or we want
246 * to insert a new frchainS just before it.
248 * If frcP==NULL, then we are at the end of the chain
249 * of frchainS-s. A NULL frcP means we fell off the end
250 * of the chain looking for a
251 * frch_subseg >= subseg, so we
252 * must make a new frchainS.
254 * If we ever maintain a pointer to
255 * the last frchainS in the chain, we change that pointer
256 * ONLY when frcP==NULL.
258 * lastPP: Address of the pointer with value frcP;
260 * May point to frchain_root.
264 || ( (int)(frcP
-> frch_seg
) > (int)seg
265 || frcP
->frch_subseg
> subseg
)) /* Kinky logic only works with 2 segments. */
268 * This should be the only code that creates a frchainS.
270 newP
=(frchainS
*)obstack_alloc(&frags
,sizeof(frchainS
));
271 memset(newP
, sizeof(frchainS
), 0);
272 /* This begines on a good boundary */
273 /* because a obstack_done() preceeded it. */
274 /* It implies an obstack_done(), so we */
275 /* expect the next object allocated to */
276 /* begin on a correct boundary. */
278 newP
-> frch_next
= frcP
; /* perhaps NULL */
279 (frcP
= newP
) -> frch_subseg
= subseg
;
280 newP
-> frch_seg
= seg
;
281 newP
-> frch_last
= NULL
;
284 * Here with frcP ->ing to the frchainS for subseg.
288 * Make a fresh frag for the subsegment.
290 /* We expect this to happen on a correct */
291 /* boundary since it was proceeded by a */
292 /* obstack_done(). */
293 tmp
=obstack_alignment_mask(&frags
); /* JF disable alignment */
294 obstack_alignment_mask(&frags
)=0;
295 frag_now
=(fragS
*)obstack_alloc(&frags
,SIZEOF_STRUCT_FRAG
);
296 obstack_alignment_mask(&frags
)=tmp
;
297 /* know( frags . obstack_c_next_free == frag_now -> fr_literal ); */
298 /* But we want any more chars to come */
299 /* immediately after the structure we just made. */
300 new_fragP
= frag_now
;
301 new_fragP
-> fr_next
= NULL
;
303 * Append new frag to current frchain.
305 former_last_fragP
= frcP
-> frch_last
;
306 if (former_last_fragP
)
308 know( former_last_fragP
-> fr_next
== NULL
);
309 know( frchain_now
-> frch_root
);
310 former_last_fragP
-> fr_next
= new_fragP
;
314 frcP
-> frch_root
= new_fragP
;
316 frcP
-> frch_last
= new_fragP
;
317 } /* if (changing subsegments) */
327 /* end of subsegs.c */