* subsegs.c (subseg_set_rest): Always set seginfp->frchainP if NULL.
[external/binutils.git] / gas / subsegs.c
1 /* subsegs.c - subsegments -
2    Copyright 1987, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3    1999, 2000, 2001, 2002, 2003, 2004, 2005
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 2, 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 /* Segments & sub-segments.  */
24
25 #include "as.h"
26
27 #include "subsegs.h"
28 #include "obstack.h"
29
30 frchainS *frchain_root, *frchain_now;
31
32 static struct obstack frchains;
33
34 /* Gas segment information for bfd_abs_section_ptr and
35    bfd_und_section_ptr.  */
36 static segment_info_type *abs_seg_info;
37 static segment_info_type *und_seg_info;
38
39 static void subseg_set_rest (segT, subsegT);
40
41 static fragS dummy_frag;
42
43 static frchainS absolute_frchain;
44 \f
45 void
46 subsegs_begin (void)
47 {
48   obstack_begin (&frchains, chunksize);
49 #if __GNUC__ >= 2
50   obstack_alignment_mask (&frchains) = __alignof__ (frchainS) - 1;
51 #endif
52
53   frchain_root = NULL;
54   frchain_now = NULL;           /* Warn new_subseg() that we are booting.  */
55
56   frag_now = &dummy_frag;
57
58   absolute_frchain.frch_seg = absolute_section;
59   absolute_frchain.frch_subseg = 0;
60   absolute_frchain.fix_root = absolute_frchain.fix_tail = 0;
61   absolute_frchain.frch_frag_now = &zero_address_frag;
62   absolute_frchain.frch_root = absolute_frchain.frch_last = &zero_address_frag;
63 }
64 \f
65 /*
66  *                      subseg_change()
67  *
68  * Change the subsegment we are in, BUT DO NOT MAKE A NEW FRAG for the
69  * subsegment. If we are already in the correct subsegment, change nothing.
70  * This is used eg as a worker for subseg_set [which does make a new frag_now]
71  * and for changing segments after we have read the source. We construct eg
72  * fixSs even after the source file is read, so we do have to keep the
73  * segment context correct.
74  */
75 void
76 subseg_change (register segT seg, register int subseg)
77 {
78   segment_info_type *seginfo;
79   now_seg = seg;
80   now_subseg = subseg;
81
82   if (now_seg == absolute_section)
83     return;
84
85   seginfo = (segment_info_type *) bfd_get_section_userdata (stdoutput, seg);
86   if (! seginfo)
87     {
88       seginfo = (segment_info_type *) xmalloc (sizeof (*seginfo));
89       memset ((PTR) seginfo, 0, sizeof (*seginfo));
90       seginfo->fix_root = NULL;
91       seginfo->fix_tail = NULL;
92       seginfo->bfd_section = seg;
93       seginfo->sym = 0;
94       if (seg == bfd_abs_section_ptr)
95         abs_seg_info = seginfo;
96       else if (seg == bfd_und_section_ptr)
97         und_seg_info = seginfo;
98       else
99         bfd_set_section_userdata (stdoutput, seg, (PTR) seginfo);
100     }
101 }
102 \f
103 static void
104 subseg_set_rest (segT seg, subsegT subseg)
105 {
106   register frchainS *frcP;      /* crawl frchain chain */
107   register frchainS **lastPP;   /* address of last pointer */
108   frchainS *newP;               /* address of new frchain */
109
110   mri_common_symbol = NULL;
111
112   if (frag_now && frchain_now)
113     frchain_now->frch_frag_now = frag_now;
114
115   assert (frchain_now == 0
116           || now_seg == undefined_section
117           || now_seg == absolute_section
118           || frchain_now->frch_last == frag_now);
119
120   subseg_change (seg, (int) subseg);
121
122   if (seg == absolute_section)
123     {
124       frchain_now = &absolute_frchain;
125       frag_now = &zero_address_frag;
126       return;
127     }
128
129   assert (frchain_now == 0
130           || now_seg == undefined_section
131           || frchain_now->frch_last == frag_now);
132
133   /*
134    * Attempt to find or make a frchain for that sub seg.
135    * Crawl along chain of frchainSs, begins @ frchain_root.
136    * If we need to make a frchainS, link it into correct
137    * position of chain rooted in frchain_root.
138    */
139   for (frcP = *(lastPP = &frchain_root);
140        frcP && frcP->frch_seg <= seg;
141        frcP = *(lastPP = &frcP->frch_next))
142     {
143       if (frcP->frch_seg == seg
144           && frcP->frch_subseg >= subseg)
145         {
146           break;
147         }
148     }
149   /*
150    * frcP:              Address of the 1st frchainS in correct segment with
151    *            frch_subseg >= subseg.
152    *            We want to either use this frchainS, or we want
153    *            to insert a new frchainS just before it.
154    *
155    *            If frcP==NULL, then we are at the end of the chain
156    *            of frchainS-s. A NULL frcP means we fell off the end
157    *            of the chain looking for a
158    *            frch_subseg >= subseg, so we
159    *            must make a new frchainS.
160    *
161    *            If we ever maintain a pointer to
162    *            the last frchainS in the chain, we change that pointer
163    *            ONLY when frcP==NULL.
164    *
165    * lastPP:    Address of the pointer with value frcP;
166    *            Never NULL.
167    *            May point to frchain_root.
168    *
169    */
170   if (!frcP
171       || (frcP->frch_seg > seg
172           || frcP->frch_subseg > subseg))       /* Kinky logic only works with 2 segments.  */
173     {
174       /*
175        * This should be the only code that creates a frchainS.
176        */
177       segment_info_type *seginfo;
178
179       newP = (frchainS *) obstack_alloc (&frchains, sizeof (frchainS));
180       newP->frch_subseg = subseg;
181       newP->frch_seg = seg;
182       newP->fix_root = NULL;
183       newP->fix_tail = NULL;
184       obstack_begin (&newP->frch_obstack, chunksize);
185 #if __GNUC__ >= 2
186       obstack_alignment_mask (&newP->frch_obstack) = __alignof__ (fragS) - 1;
187 #endif
188       newP->frch_frag_now = frag_alloc (&newP->frch_obstack);
189       newP->frch_frag_now->fr_type = rs_fill;
190
191       newP->frch_root = newP->frch_last = newP->frch_frag_now;
192
193       *lastPP = newP;
194       newP->frch_next = frcP;   /* perhaps NULL */
195
196       seginfo = seg_info (seg);
197       if (seginfo && (!seginfo->frchainP || seginfo->frchainP == frcP))
198         seginfo->frchainP = newP;
199
200       frcP = newP;
201     }
202   /*
203    * Here with frcP pointing to the frchainS for subseg.
204    */
205   frchain_now = frcP;
206   frag_now = frcP->frch_frag_now;
207
208   assert (frchain_now->frch_last == frag_now);
209 }
210
211 /*
212  *                      subseg_set(segT, subsegT)
213  *
214  * If you attempt to change to the current subsegment, nothing happens.
215  *
216  * In:  segT, subsegT code for new subsegment.
217  *      frag_now -> incomplete frag for current subsegment.
218  *      If frag_now==NULL, then there is no old, incomplete frag, so
219  *      the old frag is not closed off.
220  *
221  * Out: now_subseg, now_seg updated.
222  *      Frchain_now points to the (possibly new) struct frchain for this
223  *      sub-segment.
224  *      Frchain_root updated if needed.
225  */
226
227 segT
228 subseg_get (const char *segname, int force_new)
229 {
230   segT secptr;
231   segment_info_type *seginfo;
232   const char *now_seg_name = (now_seg
233                               ? bfd_get_section_name (stdoutput, now_seg)
234                               : 0);
235
236   if (!force_new
237       && now_seg_name
238       && (now_seg_name == segname
239           || !strcmp (now_seg_name, segname)))
240     return now_seg;
241
242   if (!force_new)
243     secptr = bfd_make_section_old_way (stdoutput, segname);
244   else
245     secptr = bfd_make_section_anyway (stdoutput, segname);
246
247 #ifdef obj_sec_set_private_data
248   obj_sec_set_private_data (stdoutput, secptr);
249 #endif
250
251   seginfo = seg_info (secptr);
252   if (! seginfo)
253     {
254       /* Check whether output_section is set first because secptr may
255          be bfd_abs_section_ptr.  */
256       if (secptr->output_section != secptr)
257         secptr->output_section = secptr;
258       seginfo = (segment_info_type *) xmalloc (sizeof (*seginfo));
259       memset ((PTR) seginfo, 0, sizeof (*seginfo));
260       seginfo->fix_root = NULL;
261       seginfo->fix_tail = NULL;
262       seginfo->bfd_section = secptr;
263       if (secptr == bfd_abs_section_ptr)
264         abs_seg_info = seginfo;
265       else if (secptr == bfd_und_section_ptr)
266         und_seg_info = seginfo;
267       else
268         bfd_set_section_userdata (stdoutput, secptr, (PTR) seginfo);
269       seginfo->frchainP = NULL;
270       seginfo->lineno_list_head = seginfo->lineno_list_tail = NULL;
271       seginfo->sym = NULL;
272       seginfo->dot = NULL;
273     }
274   return secptr;
275 }
276
277 segT
278 subseg_new (const char *segname, subsegT subseg)
279 {
280   segT secptr;
281   segment_info_type *seginfo;
282
283   secptr = subseg_get (segname, 0);
284   subseg_set_rest (secptr, subseg);
285   seginfo = seg_info (secptr);
286   if (! seginfo->frchainP)
287     seginfo->frchainP = frchain_now;
288   return secptr;
289 }
290
291 /* Like subseg_new, except a new section is always created, even if
292    a section with that name already exists.  */
293 segT
294 subseg_force_new (const char *segname, subsegT subseg)
295 {
296   segT secptr;
297   segment_info_type *seginfo;
298
299   secptr = subseg_get (segname, 1);
300   subseg_set_rest (secptr, subseg);
301   seginfo = seg_info (secptr);
302   if (! seginfo->frchainP)
303     seginfo->frchainP = frchain_now;
304   return secptr;
305 }
306
307 void
308 subseg_set (segT secptr, subsegT subseg)
309 {
310   if (! (secptr == now_seg && subseg == now_subseg))
311     subseg_set_rest (secptr, subseg);
312   mri_common_symbol = NULL;
313 }
314
315 #ifndef obj_sec_sym_ok_for_reloc
316 #define obj_sec_sym_ok_for_reloc(SEC)   0
317 #endif
318
319 /* Get the gas information we are storing for a section.  */
320
321 segment_info_type *
322 seg_info (segT sec)
323 {
324   if (sec == bfd_abs_section_ptr)
325     return abs_seg_info;
326   else if (sec == bfd_und_section_ptr)
327     return und_seg_info;
328   else
329     return (segment_info_type *) bfd_get_section_userdata (stdoutput, sec);
330 }
331
332 symbolS *
333 section_symbol (segT sec)
334 {
335   segment_info_type *seginfo = seg_info (sec);
336   symbolS *s;
337
338   if (seginfo == 0)
339     abort ();
340   if (seginfo->sym)
341     return seginfo->sym;
342
343 #ifndef EMIT_SECTION_SYMBOLS
344 #define EMIT_SECTION_SYMBOLS 1
345 #endif
346
347   if (! EMIT_SECTION_SYMBOLS || symbol_table_frozen)
348     {
349       /* Here we know it won't be going into the symbol table.  */
350       s = symbol_create (sec->symbol->name, sec, 0, &zero_address_frag);
351     }
352   else
353     {
354       segT seg;
355       s = symbol_find (sec->symbol->name);
356       /* We have to make sure it is the right symbol when we
357          have multiple sections with the same section name.  */
358       if (s == NULL
359           || ((seg = S_GET_SEGMENT (s)) != sec
360               && seg != undefined_section))
361         s = symbol_new (sec->symbol->name, sec, 0, &zero_address_frag);
362       else if (seg == undefined_section)
363         {
364           S_SET_SEGMENT (s, sec);
365           symbol_set_frag (s, &zero_address_frag);
366         }
367     }
368
369   S_CLEAR_EXTERNAL (s);
370
371   /* Use the BFD section symbol, if possible.  */
372   if (obj_sec_sym_ok_for_reloc (sec))
373     symbol_set_bfdsym (s, sec->symbol);
374   else
375     symbol_get_bfdsym (s)->flags |= BSF_SECTION_SYM;
376
377   seginfo->sym = s;
378   return s;
379 }
380
381 /* Return whether the specified segment is thought to hold text.  */
382
383 int
384 subseg_text_p (segT sec)
385 {
386   return (bfd_get_section_flags (stdoutput, sec) & SEC_CODE) != 0;
387 }
388
389 /* Return non zero if SEC has at least one byte of data.  It is
390    possible that we'll return zero even on a non-empty section because
391    we don't know all the fragment types, and it is possible that an
392    fr_fix == 0 one still contributes data.  Think of this as
393    seg_definitely_not_empty_p.  */
394
395 int
396 seg_not_empty_p (segT sec ATTRIBUTE_UNUSED)
397 {
398   segment_info_type *seginfo = seg_info (sec);
399   frchainS *chain;
400   fragS *frag;
401
402   if (!seginfo)
403     return 0;
404   
405   for (chain = seginfo->frchainP; chain; chain = chain->frch_next)
406     {
407       for (frag = chain->frch_root; frag; frag = frag->fr_next)
408         if (frag->fr_fix)
409           return 1;
410       if (obstack_next_free (&chain->frch_obstack)
411           != chain->frch_last->fr_literal)
412         return 1;
413     }
414   return 0;
415 }
416
417 void
418 subsegs_print_statistics (FILE *file)
419 {
420   frchainS *frchp;
421   fprintf (file, "frag chains:\n");
422   for (frchp = frchain_root; frchp; frchp = frchp->frch_next)
423     {
424       int count = 0;
425       fragS *fragp;
426
427       /* If frch_subseg is non-zero, it's probably been chained onto
428          the end of a previous subsection.  Don't count it again.  */
429       if (frchp->frch_subseg != 0)
430         continue;
431
432       /* Skip gas-internal sections.  */
433       if (segment_name (frchp->frch_seg)[0] == '*')
434         continue;
435
436       for (fragp = frchp->frch_root; fragp; fragp = fragp->fr_next)
437         {
438           count++;
439         }
440       fprintf (file, "\n");
441       fprintf (file, "\t%p %-10s\t%10d frags\n", (void *) frchp,
442                segment_name (frchp->frch_seg), count);
443     }
444 }
445
446 /* end of subsegs.c */