![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to sections.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / GNUtools / cctools / as|
Return to sections.c CVS log | Up to [Apple XNU] / GNUtools / cctools / as |
1.1 root 1: /* sections.c (was subsegs.c in original GAS version)
2: Copyright (C) 1987 Free Software Foundation, Inc.
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 1, 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. */
19:
20: /*
21: * Mach-O sections are chains of fragments.
22: */
23: #include <stdlib.h>
24: #include <strings.h>
25: #include "sections.h"
26: #include "obstack.h"
27: #include "xmalloc.h"
28: #include "frags.h"
29: #include "messages.h"
30:
31: /*
32: * All sections' chains hang off here. NULL means no frchains yet.
33: */
34: frchainS *frchain_root = NULL;
35:
36: /*
37: * The frchain we are assembling into now. That is, the current section's
38: * frag chain, even if it contains no (complete) frags.
39: */
40: frchainS *frchain_now = NULL;
41:
42: /*
43: * sections_begin() sets up to allow sections to be created.
44: */
45: void
46: sections_begin(
47: void)
48: {
49: /* This may be needed if a section_new() for .text is not assumed */
50: /* obstack_begin(&frags, 5000); */
51: /* frag_now = (fragS *)obstack_alloc(&frags, SIZEOF_STRUCT_FRAG); */
52: }
53:
54: /*
55: * section_new() (for non-zerofill sections) switches to a new section, creating
56: * it if needed, and creates a fresh fragment. If it is the current section
57: * nothing happens except checks to make sure the type, attributes and
58: * sizeof_stub are the same. The segment and section names will be trimed to
59: * fit in the section structure and is the responsiblity of the caller to
60: * report errors if they don't. For zerofill sections only the struct frchain
61: * for the section is returned after possibly being created (these section are
62: * never made the current section and no frags are ever touched).
63: *
64: * Globals on input:
65: * frchain_now points to the (possibly none) struct frchain for the current
66: * section.
67: * frag_now points at an incomplete frag for current section.
68: * If frag_now == NULL, then there is no old, incomplete frag, so the old
69: * frag is not closed off.
70: *
71: * Globals on output:
72: * frchain_now points to the (possibly new) struct frchain for this section.
73: * frchain_root updated if needed (for the first section created).
74: * frag_now is set to the last (possibly new) frag in the section.
75: */
76: frchainS *
77: section_new(
78: char *segname,
79: char *sectname,
80: unsigned long type,
81: unsigned long attributes,
82: unsigned long sizeof_stub)
83: {
84: frchainS *frcP;
85: frchainS **lastPP;
86: unsigned long last_nsect;
87:
88: if(frags.chunk_size == 0)
89: /*
90: * This line is use instead of:
91: * obstack_begin(&frags, 5000);
92: * which the only difference is that frags are allocated on 4 byte
93: * boundaries instead of the default. The problem with the default
94: * is that on some RISC machines the obstack uses 8 (the alignment
95: * of a double after a char in a struct) and then the common use of:
96: * frag_now->fr_fix = obstack_next_free(&frags) -
97: * frag_now->fr_literal;
98: * can get an extra 4 bytes that are not in the frag because of the
99: * 8 byte alignment where only 4 byte alignment for frags are
100: * needed.
101: */
102: _obstack_begin(&frags, 5000, 4,
103: obstack_chunk_alloc, obstack_chunk_free);
104:
105: /*
106: * Determine if this section has been seen.
107: */
108: last_nsect = 0;
109: for(frcP = *(lastPP = &frchain_root);
110: frcP != NULL;
111: frcP = *(lastPP = &frcP->frch_next)){
112: if(strncmp(frcP->frch_section.segname, segname,
113: sizeof(frcP->frch_section.segname)) == 0 &&
114: strncmp(frcP->frch_section.sectname, sectname,
115: sizeof(frcP->frch_section.sectname)) == 0)
116: break;
117: last_nsect = frcP->frch_nsect;
118: }
119:
120: /*
121: * If this section has been seen make sure it's type and attributes
122: * for this call are the same as when the section was created.
123: */
124: if(frcP != NULL){
125: if((frcP->frch_section.flags & SECTION_TYPE) != type){
126: as_warn("section type does not match previous section type");
127: }
128: if(type == S_SYMBOL_STUBS &&
129: frcP->frch_section.reserved2 != sizeof_stub){
130: as_warn("section stub size does not match previous section "
131: "stub size");
132: }
133: if((frcP->frch_section.flags & SECTION_ATTRIBUTES) != attributes){
134: as_warn("section attributes does not match previous section "
135: "attributes");
136: }
137: }
138:
139: /*
140: * If the current section is the same as for this call there is nothing
141: * more to do.
142: */
143: if(frcP != NULL && (frchain_now == frcP || type == S_ZEROFILL)){
144: return(frcP);
145: }
146:
147: /*
148: * For non-zerofill sections it will be made the current section so deal
149: * with the current frag.
150: */
151: if(type != S_ZEROFILL){
152: /*
153: * If there is any current frag in the old section close it off.
154: */
155: if(frag_now != NULL){
156: frag_now->fr_fix = obstack_next_free(&frags) -
157: frag_now->fr_literal;
158: frag_wane(frag_now);
159: }
160:
161: /*
162: * We must do the obstack_finish(), so the next object we put on
163: * obstack frags will not appear to start at the fr_literal of the
164: * current frag. Also, it ensures that the next object will begin
165: * on a address that is aligned correctly for the engine that runs
166: * the assembler.
167: */
168: obstack_finish(&frags);
169: }
170:
171: /*
172: * If this section exists since it is not the current section switch to
173: * it by making it the current chain and create a new frag in it.
174: */
175: if(frcP != NULL){
176: /*
177: * For a zerofill section no frags are created here and since it
178: * exist just return a pointer to the section.
179: */
180: if((frcP->frch_section.flags & SECTION_TYPE) == S_ZEROFILL){
181: return(frcP);
182: }
183: else{
184: /*
185: * Make this section the current section.
186: */
187: frchain_now = frcP;
188:
189: /*
190: * Make a fresh frag for the section.
191: */
192: frag_now = (fragS *)obstack_alloc(&frags, SIZEOF_STRUCT_FRAG);
193: memset(frag_now, '\0', SIZEOF_STRUCT_FRAG);
194: frag_now->fr_next = NULL;
195:
196: /*
197: * Append the new frag to the existing frchain.
198: */
199: frchain_now->frch_last->fr_next = frag_now;
200: frchain_now->frch_last = frag_now;
201: }
202: }
203: else{
204: /*
205: * This section does not exist so create a new frchainS struct fill
206: * it in, link it to the chain
207: */
208: frcP = (frchainS *)xmalloc(sizeof(frchainS));
209: memset(frcP, '\0', sizeof(frchainS));
210: strncpy(frcP->frch_section.segname, segname,
211: sizeof(frcP->frch_section.segname));
212: strncpy(frcP->frch_section.sectname, sectname,
213: sizeof(frcP->frch_section.sectname));
214: frcP->frch_section.flags = attributes | type;
215: frcP->frch_section.reserved2 = sizeof_stub;
216:
217: frcP->frch_nsect = last_nsect + 1;
218:
219: *lastPP = frcP;
220:
221: /*
222: * For zerofill sections no frag is created here so just return.
223: * For non-zerofill section create the sections new frag and
224: * make the section the current chain.
225: */
226: if(type == S_ZEROFILL){
227: return(frcP);
228: }
229: else{
230: /*
231: * Make a fresh frag for the new section.
232: */
233: frag_now = (fragS *)obstack_alloc(&frags, SIZEOF_STRUCT_FRAG);
234: memset(frag_now, '\0', SIZEOF_STRUCT_FRAG);
235: frag_now->fr_next = NULL;
236:
237: /*
238: * Append the new frag to new frchain.
239: */
240: frcP->frch_root = frag_now;
241: frcP->frch_last = frag_now;
242:
243: /*
244: * Make this section the current section.
245: */
246: frchain_now = frcP;
247: }
248: }
249: return(frchain_now);
250: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.