|
111
|
1 /* simple-object-coff.c -- routines to manipulate XCOFF object files.
|
|
145
|
2 Copyright (C) 2013-2020 Free Software Foundation, Inc.
|
|
111
|
3 Written by Ian Lance Taylor, Google and David Edelsohn, IBM.
|
|
|
4
|
|
|
5 This program is free software; you can redistribute it and/or modify it
|
|
|
6 under the terms of the GNU General Public License as published by the
|
|
|
7 Free Software Foundation; either version 2, or (at your option) any
|
|
|
8 later version.
|
|
|
9
|
|
|
10 This program is distributed in the hope that it will be useful,
|
|
|
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
13 GNU General Public License for more details.
|
|
|
14
|
|
|
15 You should have received a copy of the GNU General Public License
|
|
|
16 along with this program; if not, write to the Free Software
|
|
|
17 Foundation, 51 Franklin Street - Fifth Floor,
|
|
|
18 Boston, MA 02110-1301, USA. */
|
|
|
19
|
|
|
20 #include "config.h"
|
|
|
21 #include "libiberty.h"
|
|
|
22 #include "simple-object.h"
|
|
|
23
|
|
|
24 #include <errno.h>
|
|
|
25 #include <stddef.h>
|
|
|
26
|
|
|
27 #ifdef HAVE_STDLIB_H
|
|
|
28 #include <stdlib.h>
|
|
|
29 #endif
|
|
|
30
|
|
|
31 #ifdef HAVE_STDINT_H
|
|
|
32 #include <stdint.h>
|
|
|
33 #endif
|
|
|
34
|
|
|
35 #ifdef HAVE_STRING_H
|
|
|
36 #include <string.h>
|
|
|
37 #endif
|
|
|
38
|
|
|
39 #ifdef HAVE_INTTYPES_H
|
|
|
40 #include <inttypes.h>
|
|
|
41 #endif
|
|
|
42
|
|
|
43 #include "simple-object-common.h"
|
|
|
44
|
|
|
45 /* XCOFF structures and constants. */
|
|
|
46
|
|
|
47 /* XCOFF file header. */
|
|
|
48
|
|
|
49 struct external_filehdr
|
|
|
50 {
|
|
|
51 unsigned char f_magic[2]; /* magic number */
|
|
|
52 unsigned char f_nscns[2]; /* number of sections */
|
|
|
53 unsigned char f_timdat[4]; /* time & date stamp */
|
|
|
54 union
|
|
|
55 {
|
|
|
56 struct
|
|
|
57 {
|
|
|
58 unsigned char f_symptr[4]; /* file pointer to symtab */
|
|
|
59 unsigned char f_nsyms[4]; /* number of symtab entries */
|
|
|
60 unsigned char f_opthdr[2]; /* sizeof(optional hdr) */
|
|
|
61 unsigned char f_flags[2]; /* flags */
|
|
|
62 } xcoff32;
|
|
|
63 struct
|
|
|
64 {
|
|
|
65 unsigned char f_symptr[8]; /* file pointer to symtab */
|
|
|
66 unsigned char f_opthdr[2]; /* sizeof(optional hdr) */
|
|
|
67 unsigned char f_flags[2]; /* flags */
|
|
|
68 unsigned char f_nsyms[4]; /* number of symtab entries */
|
|
|
69 } xcoff64;
|
|
|
70 } u;
|
|
|
71 };
|
|
|
72
|
|
|
73 /* Bits for filehdr f_flags field. */
|
|
|
74
|
|
|
75 #define F_EXEC (0x0002)
|
|
|
76
|
|
|
77 /* The known values of f_magic in an XCOFF file header. */
|
|
|
78
|
|
|
79 #define U802WRMAGIC 0730 /* Writeable text segments. */
|
|
|
80 #define U802ROMAGIC 0735 /* Readonly sharable text segments. */
|
|
|
81 #define U802TOCMAGIC 0737 /* Readonly text segments and TOC. */
|
|
|
82 #define U803XTOCMAGIC 0757 /* Aix 4.3 64-bit XCOFF. */
|
|
|
83 #define U64_TOCMAGIC 0767 /* AIX 5+ 64-bit XCOFF. */
|
|
|
84
|
|
|
85 /* XCOFF section header. */
|
|
|
86
|
|
|
87 struct external_scnhdr
|
|
|
88 {
|
|
|
89 unsigned char s_name[8]; /* section name */
|
|
|
90 union
|
|
|
91 {
|
|
|
92 struct
|
|
|
93 {
|
|
|
94 unsigned char s_paddr[4]; /* physical address, aliased s_nlib */
|
|
|
95 unsigned char s_vaddr[4]; /* virtual address */
|
|
|
96 unsigned char s_size[4]; /* section size */
|
|
|
97 unsigned char s_scnptr[4]; /* file ptr to raw data for section */
|
|
|
98 unsigned char s_relptr[4]; /* file ptr to relocation */
|
|
|
99 unsigned char s_lnnoptr[4]; /* file ptr to line numbers */
|
|
|
100 unsigned char s_nreloc[2]; /* number of relocation entries */
|
|
|
101 unsigned char s_nlnno[2]; /* number of line number entries */
|
|
|
102 unsigned char s_flags[4]; /* flags */
|
|
|
103 } xcoff32;
|
|
|
104 struct
|
|
|
105 {
|
|
|
106 unsigned char s_paddr[8]; /* physical address, aliased s_nlib */
|
|
|
107 unsigned char s_vaddr[8]; /* virtual address */
|
|
|
108 unsigned char s_size[8]; /* section size */
|
|
|
109 unsigned char s_scnptr[8]; /* file ptr to raw data for section */
|
|
|
110 unsigned char s_relptr[8]; /* file ptr to relocation */
|
|
|
111 unsigned char s_lnnoptr[8]; /* file ptr to line numbers */
|
|
|
112 unsigned char s_nreloc[4]; /* number of relocation entries */
|
|
|
113 unsigned char s_nlnno[4]; /* number of line number entries */
|
|
|
114 unsigned char s_flags[4]; /* flags */
|
|
|
115 } xcoff64;
|
|
|
116 } u;
|
|
|
117 };
|
|
|
118
|
|
|
119 #define SCNHSZ32 (40)
|
|
|
120 #define SCNHSZ64 (68)
|
|
|
121
|
|
|
122 /* The length of the s_name field in struct external_scnhdr. */
|
|
|
123
|
|
|
124 #define SCNNMLEN (8)
|
|
|
125
|
|
|
126 /* Bits for scnhdr s_flags field. */
|
|
|
127
|
|
|
128 #define STYP_DATA 0x40
|
|
|
129
|
|
|
130 /* XCOFF symbol table entry. */
|
|
|
131
|
|
|
132
|
|
|
133 #define N_SYMNMLEN (8) /* # characters in a symbol name */
|
|
|
134
|
|
|
135 /* The format of an XCOFF symbol-table entry. */
|
|
|
136 struct external_syment
|
|
|
137 {
|
|
|
138 union {
|
|
|
139 struct {
|
|
|
140 union {
|
|
|
141 /* The name of the symbol. There is an implicit null character
|
|
|
142 after the end of the array. */
|
|
|
143 char n_name[N_SYMNMLEN];
|
|
|
144 struct {
|
|
|
145 /* If n_zeroes is zero, n_offset is the offset the name from
|
|
|
146 the start of the string table. */
|
|
|
147 unsigned char n_zeroes[4];
|
|
|
148 unsigned char n_offset[4];
|
|
|
149 } n;
|
|
|
150 } n;
|
|
|
151
|
|
|
152 /* The symbol's value. */
|
|
|
153 unsigned char n_value[4];
|
|
|
154 } xcoff32;
|
|
|
155 struct {
|
|
|
156 /* The symbol's value. */
|
|
|
157 unsigned char n_value[8];
|
|
|
158
|
|
|
159 /* The offset of the symbol from the start of the string table. */
|
|
|
160 unsigned char n_offset[4];
|
|
|
161 } xcoff64;
|
|
|
162 } u;
|
|
|
163
|
|
|
164 /* The number of the section to which this symbol belongs. */
|
|
|
165 unsigned char n_scnum[2];
|
|
|
166
|
|
|
167 /* The type of symbol. (It can be interpreted as an n_lang
|
|
|
168 and an n_cpu byte, but we don't care about that here.) */
|
|
|
169 unsigned char n_type[2];
|
|
|
170
|
|
|
171 /* The class of symbol (a C_* value). */
|
|
|
172 unsigned char n_sclass[1];
|
|
|
173
|
|
|
174 /* The number of auxiliary symbols attached to this entry. */
|
|
|
175 unsigned char n_numaux[1];
|
|
|
176 };
|
|
|
177
|
|
|
178 #define SYMESZ (18)
|
|
|
179
|
|
|
180 /* Length allowed for filename in aux sym format 4. */
|
|
|
181
|
|
|
182 #define FILNMLEN (14)
|
|
|
183
|
|
|
184 /* Omits x_sym and other unused variants. */
|
|
|
185
|
|
|
186 union external_auxent
|
|
|
187 {
|
|
|
188 /* Aux sym format 4: file. */
|
|
|
189 union
|
|
|
190 {
|
|
|
191 char x_fname[FILNMLEN];
|
|
|
192 struct
|
|
|
193 {
|
|
|
194 unsigned char x_zeroes[4];
|
|
|
195 unsigned char x_offset[4];
|
|
|
196 unsigned char x_pad[FILNMLEN-8];
|
|
|
197 unsigned char x_ftype;
|
|
|
198 } _x;
|
|
|
199 } x_file;
|
|
|
200 /* Aux sym format 5: section. */
|
|
|
201 struct
|
|
|
202 {
|
|
|
203 unsigned char x_scnlen[4]; /* section length */
|
|
|
204 unsigned char x_nreloc[2]; /* # relocation entries */
|
|
|
205 unsigned char x_nlinno[2]; /* # line numbers */
|
|
|
206 } x_scn;
|
|
|
207 /* CSECT auxiliary entry. */
|
|
|
208 union
|
|
|
209 {
|
|
|
210 struct
|
|
|
211 {
|
|
|
212 struct
|
|
|
213 {
|
|
|
214 unsigned char x_scnlen[4]; /* csect length */
|
|
|
215 unsigned char x_parmhash[4]; /* parm type hash index */
|
|
|
216 unsigned char x_snhash[2]; /* sect num with parm hash */
|
|
|
217 unsigned char x_smtyp; /* symbol align and type */
|
|
|
218 unsigned char x_smclas; /* storage mapping class */
|
|
|
219 unsigned char x_stab; /* dbx stab info index */
|
|
|
220 unsigned char x_snstab[2]; /* sect num with dbx stab */
|
|
|
221 } x_csect;
|
|
|
222 } xcoff32;
|
|
|
223 struct
|
|
|
224 {
|
|
|
225 struct
|
|
|
226 {
|
|
|
227 unsigned char x_scnlen_lo[4]; /* csect length */
|
|
|
228 unsigned char x_parmhash[4]; /* parm type hash index */
|
|
|
229 unsigned char x_snhash[2]; /* sect num with parm hash */
|
|
|
230 unsigned char x_smtyp; /* symbol align and type */
|
|
|
231 unsigned char x_smclas; /* storage mapping class */
|
|
|
232 unsigned char x_scnlen_hi[4];
|
|
|
233 unsigned char pad;
|
|
|
234 unsigned char x_auxtype;
|
|
|
235 } x_csect;
|
|
|
236 } xcoff64;
|
|
|
237 } u;
|
|
|
238 /* SECTION/DWARF auxiliary entry. */
|
|
|
239 struct
|
|
|
240 {
|
|
|
241 unsigned char x_scnlen[4]; /* section length */
|
|
|
242 unsigned char pad1[4];
|
|
|
243 unsigned char x_nreloc[4]; /* number RLDs */
|
|
|
244 } x_sect;
|
|
|
245 };
|
|
|
246
|
|
|
247 /* Symbol-related constants. */
|
|
|
248
|
|
|
249 #define N_DEBUG (-2)
|
|
|
250 #define IMAGE_SYM_TYPE_NULL (0)
|
|
|
251 #define IMAGE_SYM_DTYPE_NULL (0)
|
|
|
252 #define IMAGE_SYM_CLASS_STATIC (3)
|
|
|
253 #define IMAGE_SYM_CLASS_FILE (103)
|
|
|
254
|
|
|
255 #define IMAGE_SYM_TYPE \
|
|
|
256 ((IMAGE_SYM_DTYPE_NULL << 4) | IMAGE_SYM_TYPE_NULL)
|
|
|
257
|
|
|
258 #define C_EXT (2)
|
|
|
259 #define C_STAT (3)
|
|
|
260 #define C_FILE (103)
|
|
|
261 #define C_HIDEXT (107)
|
|
|
262
|
|
|
263 #define XTY_SD (1) /* section definition */
|
|
|
264
|
|
|
265 #define XMC_XO (7) /* extended operation */
|
|
|
266
|
|
|
267 /* Private data for an simple_object_read. */
|
|
|
268
|
|
|
269 struct simple_object_xcoff_read
|
|
|
270 {
|
|
|
271 /* Magic number. */
|
|
|
272 unsigned short magic;
|
|
|
273 /* Number of sections. */
|
|
|
274 unsigned short nscns;
|
|
|
275 /* File offset of symbol table. */
|
|
|
276 off_t symptr;
|
|
|
277 /* Number of symbol table entries. */
|
|
|
278 unsigned int nsyms;
|
|
|
279 /* Flags. */
|
|
|
280 unsigned short flags;
|
|
|
281 /* Offset of section headers in file. */
|
|
|
282 off_t scnhdr_offset;
|
|
|
283 };
|
|
|
284
|
|
|
285 /* Private data for an simple_object_attributes. */
|
|
|
286
|
|
|
287 struct simple_object_xcoff_attributes
|
|
|
288 {
|
|
|
289 /* Magic number. */
|
|
|
290 unsigned short magic;
|
|
|
291 /* Flags. */
|
|
|
292 unsigned short flags;
|
|
|
293 };
|
|
|
294
|
|
|
295 /* See if we have a XCOFF file. */
|
|
|
296
|
|
|
297 static void *
|
|
|
298 simple_object_xcoff_match (unsigned char header[SIMPLE_OBJECT_MATCH_HEADER_LEN],
|
|
|
299 int descriptor, off_t offset,
|
|
|
300 const char *segment_name ATTRIBUTE_UNUSED,
|
|
|
301 const char **errmsg, int *err)
|
|
|
302 {
|
|
|
303 unsigned short magic;
|
|
|
304 unsigned short (*fetch_16) (const unsigned char *);
|
|
|
305 unsigned int (*fetch_32) (const unsigned char *);
|
|
|
306 ulong_type (*fetch_64) (const unsigned char *);
|
|
|
307 unsigned char hdrbuf[sizeof (struct external_filehdr)];
|
|
|
308 struct simple_object_xcoff_read *ocr;
|
|
|
309 int u64;
|
|
|
310
|
|
|
311 magic = simple_object_fetch_big_16 (header);
|
|
|
312
|
|
|
313 if (magic != U802TOCMAGIC && magic != U64_TOCMAGIC)
|
|
|
314 {
|
|
|
315 *errmsg = NULL;
|
|
|
316 *err = 0;
|
|
|
317 return NULL;
|
|
|
318 }
|
|
|
319
|
|
|
320 fetch_16 = simple_object_fetch_big_16;
|
|
|
321 fetch_32 = simple_object_fetch_big_32;
|
|
|
322 fetch_64 = simple_object_fetch_big_64;
|
|
|
323
|
|
|
324 if (!simple_object_internal_read (descriptor, offset, hdrbuf, sizeof hdrbuf,
|
|
|
325 errmsg, err))
|
|
|
326 return NULL;
|
|
|
327
|
|
|
328 u64 = magic == U64_TOCMAGIC;
|
|
|
329
|
|
|
330 ocr = XNEW (struct simple_object_xcoff_read);
|
|
|
331 ocr->magic = magic;
|
|
|
332 ocr->nscns = fetch_16 (hdrbuf + offsetof (struct external_filehdr, f_nscns));
|
|
|
333 if (u64)
|
|
|
334 {
|
|
|
335 ocr->symptr = fetch_64 (hdrbuf
|
|
|
336 + offsetof (struct external_filehdr,
|
|
|
337 u.xcoff64.f_symptr));
|
|
|
338 ocr->nsyms = fetch_32 (hdrbuf + offsetof (struct external_filehdr,
|
|
|
339 u.xcoff64.f_nsyms));
|
|
|
340 ocr->scnhdr_offset = (sizeof (struct external_filehdr)
|
|
|
341 + fetch_16 (hdrbuf + offsetof (struct external_filehdr,
|
|
|
342 u.xcoff64.f_opthdr)));
|
|
|
343
|
|
|
344 }
|
|
|
345 else
|
|
|
346 {
|
|
|
347 ocr->symptr = fetch_32 (hdrbuf
|
|
|
348 + offsetof (struct external_filehdr,
|
|
|
349 u.xcoff32.f_symptr));
|
|
|
350 ocr->nsyms = fetch_32 (hdrbuf + offsetof (struct external_filehdr,
|
|
|
351 u.xcoff32.f_nsyms));
|
|
|
352 ocr->scnhdr_offset = (sizeof (struct external_filehdr) - 4
|
|
|
353 + fetch_16 (hdrbuf + offsetof (struct external_filehdr,
|
|
|
354 u.xcoff32.f_opthdr)));
|
|
|
355
|
|
|
356 }
|
|
|
357
|
|
|
358 return (void *) ocr;
|
|
|
359 }
|
|
|
360
|
|
|
361 /* Read the string table in a XCOFF file. */
|
|
|
362
|
|
|
363 static char *
|
|
|
364 simple_object_xcoff_read_strtab (simple_object_read *sobj, size_t *strtab_size,
|
|
|
365 const char **errmsg, int *err)
|
|
|
366 {
|
|
|
367 struct simple_object_xcoff_read *ocr =
|
|
|
368 (struct simple_object_xcoff_read *) sobj->data;
|
|
|
369 off_t strtab_offset;
|
|
|
370 unsigned char strsizebuf[4];
|
|
|
371 size_t strsize;
|
|
|
372 char *strtab;
|
|
|
373
|
|
|
374 strtab_offset = sobj->offset + ocr->symptr
|
|
|
375 + ocr->nsyms * SYMESZ;
|
|
|
376 if (!simple_object_internal_read (sobj->descriptor, strtab_offset,
|
|
|
377 strsizebuf, 4, errmsg, err))
|
|
|
378 return NULL;
|
|
|
379 strsize = simple_object_fetch_big_32 (strsizebuf);
|
|
|
380 strtab = XNEWVEC (char, strsize);
|
|
|
381 if (!simple_object_internal_read (sobj->descriptor, strtab_offset,
|
|
|
382 (unsigned char *) strtab, strsize, errmsg,
|
|
|
383 err))
|
|
|
384 {
|
|
|
385 XDELETEVEC (strtab);
|
|
|
386 return NULL;
|
|
|
387 }
|
|
|
388 *strtab_size = strsize;
|
|
|
389 return strtab;
|
|
|
390 }
|
|
|
391
|
|
|
392 /* Find all sections in a XCOFF file. */
|
|
|
393
|
|
|
394 static const char *
|
|
|
395 simple_object_xcoff_find_sections (simple_object_read *sobj,
|
|
|
396 int (*pfn) (void *, const char *,
|
|
|
397 off_t offset, off_t length),
|
|
|
398 void *data,
|
|
|
399 int *err)
|
|
|
400 {
|
|
|
401 struct simple_object_xcoff_read *ocr =
|
|
|
402 (struct simple_object_xcoff_read *) sobj->data;
|
|
|
403 int u64 = ocr->magic == U64_TOCMAGIC;
|
|
|
404 size_t scnhdr_size;
|
|
|
405 unsigned char *scnbuf;
|
|
|
406 const char *errmsg;
|
|
|
407 unsigned short (*fetch_16) (const unsigned char *);
|
|
|
408 unsigned int (*fetch_32) (const unsigned char *);
|
|
|
409 ulong_type (*fetch_64) (const unsigned char *);
|
|
|
410 unsigned int nscns;
|
|
|
411 char *strtab;
|
|
|
412 size_t strtab_size;
|
|
|
413 struct external_syment *symtab = NULL;
|
|
|
414 unsigned int i;
|
|
|
415
|
|
|
416 scnhdr_size = u64 ? SCNHSZ64 : SCNHSZ32;
|
|
|
417 scnbuf = XNEWVEC (unsigned char, scnhdr_size * ocr->nscns);
|
|
|
418 if (!simple_object_internal_read (sobj->descriptor,
|
|
|
419 sobj->offset + ocr->scnhdr_offset,
|
|
|
420 scnbuf, scnhdr_size * ocr->nscns, &errmsg,
|
|
|
421 err))
|
|
|
422 {
|
|
|
423 XDELETEVEC (scnbuf);
|
|
|
424 return errmsg;
|
|
|
425 }
|
|
|
426
|
|
|
427 fetch_16 = simple_object_fetch_big_16;
|
|
|
428 fetch_32 = simple_object_fetch_big_32;
|
|
|
429 fetch_64 = simple_object_fetch_big_64;
|
|
|
430
|
|
|
431 nscns = ocr->nscns;
|
|
|
432 strtab = NULL;
|
|
|
433 strtab_size = 0;
|
|
|
434 for (i = 0; i < nscns; ++i)
|
|
|
435 {
|
|
|
436 unsigned char *scnhdr;
|
|
|
437 unsigned char *scnname;
|
|
|
438 char namebuf[SCNNMLEN + 1];
|
|
|
439 char *name;
|
|
|
440 off_t scnptr;
|
|
|
441 off_t size;
|
|
|
442
|
|
|
443 scnhdr = scnbuf + i * scnhdr_size;
|
|
|
444 scnname = scnhdr + offsetof (struct external_scnhdr, s_name);
|
|
|
445 memcpy (namebuf, scnname, SCNNMLEN);
|
|
|
446 namebuf[SCNNMLEN] = '\0';
|
|
|
447 name = &namebuf[0];
|
|
|
448 if (namebuf[0] == '/')
|
|
|
449 {
|
|
|
450 size_t strindex;
|
|
|
451 char *end;
|
|
|
452
|
|
|
453 strindex = strtol (namebuf + 1, &end, 10);
|
|
|
454 if (*end == '\0')
|
|
|
455 {
|
|
|
456 /* The real section name is found in the string
|
|
|
457 table. */
|
|
|
458 if (strtab == NULL)
|
|
|
459 {
|
|
|
460 strtab = simple_object_xcoff_read_strtab (sobj,
|
|
|
461 &strtab_size,
|
|
|
462 &errmsg, err);
|
|
|
463 if (strtab == NULL)
|
|
|
464 {
|
|
|
465 XDELETEVEC (scnbuf);
|
|
|
466 return errmsg;
|
|
|
467 }
|
|
|
468 }
|
|
|
469
|
|
|
470 if (strindex < 4 || strindex >= strtab_size)
|
|
|
471 {
|
|
|
472 XDELETEVEC (strtab);
|
|
|
473 XDELETEVEC (scnbuf);
|
|
|
474 *err = 0;
|
|
|
475 return "section string index out of range";
|
|
|
476 }
|
|
|
477
|
|
|
478 name = strtab + strindex;
|
|
|
479 }
|
|
|
480 }
|
|
|
481
|
|
|
482 if (u64)
|
|
|
483 {
|
|
|
484 scnptr = fetch_64 (scnhdr + offsetof (struct external_scnhdr,
|
|
|
485 u.xcoff64.s_scnptr));
|
|
|
486 size = fetch_64 (scnhdr + offsetof (struct external_scnhdr,
|
|
|
487 u.xcoff64.s_size));
|
|
|
488 }
|
|
|
489 else
|
|
|
490 {
|
|
|
491 scnptr = fetch_32 (scnhdr + offsetof (struct external_scnhdr,
|
|
|
492 u.xcoff32.s_scnptr));
|
|
|
493 size = fetch_32 (scnhdr + offsetof (struct external_scnhdr,
|
|
|
494 u.xcoff32.s_size));
|
|
|
495 }
|
|
|
496
|
|
|
497 if (!(*pfn) (data, name, scnptr, size))
|
|
|
498 break;
|
|
|
499 }
|
|
|
500
|
|
|
501 /* Special handling for .go_export csect. */
|
|
|
502 if (ocr->nsyms > 0)
|
|
|
503 {
|
|
|
504 unsigned char *sym;
|
|
|
505 const char *n_name;
|
|
|
506 off_t size, n_value;
|
|
|
507 unsigned int n_numaux, n_offset, n_zeroes;
|
|
|
508 short n_scnum;
|
|
|
509
|
|
|
510 /* Read symbol table. */
|
|
|
511 symtab = XNEWVEC (struct external_syment, ocr->nsyms * SYMESZ);
|
|
|
512 if (!simple_object_internal_read (sobj->descriptor,
|
|
|
513 sobj->offset + ocr->symptr,
|
|
|
514 (unsigned char *) symtab,
|
|
|
515 ocr->nsyms * SYMESZ,
|
|
|
516 &errmsg, err))
|
|
|
517 {
|
|
|
518 XDELETEVEC (symtab);
|
|
|
519 XDELETEVEC (scnbuf);
|
|
|
520 return NULL;
|
|
|
521 }
|
|
|
522
|
|
|
523 /* Search in symbol table if we have a ".go_export" symbol. */
|
|
|
524 for (i = 0; i < ocr->nsyms; i += n_numaux + 1)
|
|
|
525 {
|
|
|
526 sym = (unsigned char *) &symtab[i];
|
|
|
527 n_numaux = symtab[i].n_numaux[0];
|
|
|
528
|
|
|
529 if (symtab[i].n_sclass[0] != C_EXT
|
|
|
530 && symtab[i].n_sclass[0] != C_HIDEXT)
|
|
|
531 continue;
|
|
|
532
|
|
|
533 /* Must have at least one csect auxiliary entry. */
|
|
|
534 if (n_numaux < 1 || i + n_numaux >= ocr->nsyms)
|
|
|
535 continue;
|
|
|
536
|
|
|
537 n_scnum = fetch_16 (sym + offsetof (struct external_syment,
|
|
|
538 n_scnum));
|
|
|
539 if (n_scnum < 1 || (unsigned int) n_scnum > nscns)
|
|
|
540 continue;
|
|
|
541
|
|
|
542 if (u64)
|
|
|
543 {
|
|
|
544 n_value = fetch_64 (sym + offsetof (struct external_syment,
|
|
|
545 u.xcoff64.n_value));
|
|
|
546 n_offset = fetch_32 (sym + offsetof (struct external_syment,
|
|
|
547 u.xcoff64.n_offset));
|
|
|
548 }
|
|
|
549 else
|
|
|
550 {
|
|
|
551 /* ".go_export" is longer than N_SYMNMLEN. */
|
|
|
552 n_zeroes = fetch_32 (sym + offsetof (struct external_syment,
|
|
|
553 u.xcoff32.n.n.n_zeroes));
|
|
|
554 if (n_zeroes != 0)
|
|
|
555 continue;
|
|
|
556
|
|
|
557 n_value = fetch_32 (sym + offsetof (struct external_syment,
|
|
|
558 u.xcoff32.n_value));
|
|
|
559 n_offset = fetch_32 (sym + offsetof (struct external_syment,
|
|
|
560 u.xcoff32.n.n.n_offset));
|
|
|
561 }
|
|
|
562
|
|
|
563 /* The real symbol name is found in the string table. */
|
|
|
564 if (strtab == NULL)
|
|
|
565 {
|
|
|
566 strtab = simple_object_xcoff_read_strtab (sobj,
|
|
|
567 &strtab_size,
|
|
|
568 &errmsg, err);
|
|
|
569 if (strtab == NULL)
|
|
|
570 {
|
|
|
571 XDELETEVEC (symtab);
|
|
|
572 XDELETEVEC (scnbuf);
|
|
|
573 return errmsg;
|
|
|
574 }
|
|
|
575 }
|
|
|
576
|
|
|
577 if (n_offset >= strtab_size)
|
|
|
578 {
|
|
|
579 XDELETEVEC (strtab);
|
|
|
580 XDELETEVEC (symtab);
|
|
|
581 XDELETEVEC (scnbuf);
|
|
|
582 *err = 0;
|
|
|
583 return "symbol string index out of range";
|
|
|
584 }
|
|
|
585 n_name = strtab + n_offset;
|
|
|
586
|
|
|
587 if (!strcmp (n_name, ".go_export"))
|
|
|
588 {
|
|
|
589 union external_auxent *auxent;
|
|
|
590 unsigned char *aux, *scnhdr;
|
|
|
591 off_t scnptr, x_scnlen;
|
|
|
592
|
|
|
593 /* Found .go_export symbol, read its csect auxiliary entry.
|
|
|
594 By convention, it is the last auxiliary entry. */
|
|
|
595 auxent = (union external_auxent *) &symtab[i + n_numaux];
|
|
|
596 aux = (unsigned char *) auxent;
|
|
|
597 if (u64)
|
|
|
598 {
|
|
131
|
599 /* Use an intermediate 64-bit type to avoid
|
|
|
600 compilation warning about 32-bit shift below on
|
|
|
601 hosts with 32-bit off_t which aren't supported by
|
|
|
602 AC_SYS_LARGEFILE. */
|
|
|
603 ulong_type x_scnlen64;
|
|
|
604
|
|
111
|
605 if ((auxent->u.xcoff64.x_csect.x_smtyp & 0x7) != XTY_SD
|
|
|
606 || auxent->u.xcoff64.x_csect.x_smclas != XMC_XO)
|
|
|
607 continue;
|
|
|
608
|
|
131
|
609 x_scnlen64 =
|
|
|
610 fetch_32 (aux + offsetof (union external_auxent,
|
|
|
611 u.xcoff64.x_csect.x_scnlen_hi));
|
|
|
612 x_scnlen =
|
|
|
613 ((x_scnlen64 << 32)
|
|
|
614 | fetch_32 (aux
|
|
|
615 + offsetof (union external_auxent,
|
|
|
616 u.xcoff64.x_csect.x_scnlen_lo)));
|
|
111
|
617 }
|
|
|
618 else
|
|
|
619 {
|
|
|
620 if ((auxent->u.xcoff32.x_csect.x_smtyp & 0x7) != XTY_SD
|
|
|
621 || auxent->u.xcoff32.x_csect.x_smclas != XMC_XO)
|
|
|
622 continue;
|
|
|
623
|
|
|
624 x_scnlen = fetch_32 (aux + offsetof (union external_auxent,
|
|
|
625 u.xcoff32.x_csect.x_scnlen));
|
|
|
626 }
|
|
|
627
|
|
|
628 /* Get header of containing section. */
|
|
|
629 scnhdr = scnbuf + (n_scnum - 1) * scnhdr_size;
|
|
|
630 if (u64)
|
|
|
631 {
|
|
|
632 scnptr = fetch_64 (scnhdr + offsetof (struct external_scnhdr,
|
|
|
633 u.xcoff64.s_scnptr));
|
|
|
634 size = fetch_64 (scnhdr + offsetof (struct external_scnhdr,
|
|
|
635 u.xcoff64.s_size));
|
|
|
636 }
|
|
|
637 else
|
|
|
638 {
|
|
|
639 scnptr = fetch_32 (scnhdr + offsetof (struct external_scnhdr,
|
|
|
640 u.xcoff32.s_scnptr));
|
|
|
641 size = fetch_32 (scnhdr + offsetof (struct external_scnhdr,
|
|
|
642 u.xcoff32.s_size));
|
|
|
643 }
|
|
|
644 if (n_value + x_scnlen > size)
|
|
|
645 break;
|
|
|
646
|
|
|
647 (*pfn) (data, ".go_export", scnptr + n_value, x_scnlen);
|
|
|
648 break;
|
|
|
649 }
|
|
|
650 }
|
|
|
651 }
|
|
|
652
|
|
|
653 if (symtab != NULL)
|
|
|
654 XDELETEVEC (symtab);
|
|
|
655 if (strtab != NULL)
|
|
|
656 XDELETEVEC (strtab);
|
|
|
657 XDELETEVEC (scnbuf);
|
|
|
658
|
|
|
659 return NULL;
|
|
|
660 }
|
|
|
661
|
|
|
662 /* Fetch the attributes for an simple_object_read. */
|
|
|
663
|
|
|
664 static void *
|
|
|
665 simple_object_xcoff_fetch_attributes (simple_object_read *sobj,
|
|
|
666 const char **errmsg ATTRIBUTE_UNUSED,
|
|
|
667 int *err ATTRIBUTE_UNUSED)
|
|
|
668 {
|
|
|
669 struct simple_object_xcoff_read *ocr =
|
|
|
670 (struct simple_object_xcoff_read *) sobj->data;
|
|
|
671 struct simple_object_xcoff_attributes *ret;
|
|
|
672
|
|
|
673 ret = XNEW (struct simple_object_xcoff_attributes);
|
|
|
674 ret->magic = ocr->magic;
|
|
|
675 ret->flags = ocr->flags;
|
|
|
676 return ret;
|
|
|
677 }
|
|
|
678
|
|
|
679 /* Release the private data for an simple_object_read. */
|
|
|
680
|
|
|
681 static void
|
|
|
682 simple_object_xcoff_release_read (void *data)
|
|
|
683 {
|
|
|
684 XDELETE (data);
|
|
|
685 }
|
|
|
686
|
|
|
687 /* Compare two attributes structures. */
|
|
|
688
|
|
|
689 static const char *
|
|
|
690 simple_object_xcoff_attributes_merge (void *todata, void *fromdata, int *err)
|
|
|
691 {
|
|
|
692 struct simple_object_xcoff_attributes *to =
|
|
|
693 (struct simple_object_xcoff_attributes *) todata;
|
|
|
694 struct simple_object_xcoff_attributes *from =
|
|
|
695 (struct simple_object_xcoff_attributes *) fromdata;
|
|
|
696
|
|
|
697 if (to->magic != from->magic)
|
|
|
698 {
|
|
|
699 *err = 0;
|
|
|
700 return "XCOFF object format mismatch";
|
|
|
701 }
|
|
|
702 return NULL;
|
|
|
703 }
|
|
|
704
|
|
|
705 /* Release the private data for an attributes structure. */
|
|
|
706
|
|
|
707 static void
|
|
|
708 simple_object_xcoff_release_attributes (void *data)
|
|
|
709 {
|
|
|
710 XDELETE (data);
|
|
|
711 }
|
|
|
712
|
|
|
713 /* Prepare to write out a file. */
|
|
|
714
|
|
|
715 static void *
|
|
|
716 simple_object_xcoff_start_write (void *attributes_data,
|
|
|
717 const char **errmsg ATTRIBUTE_UNUSED,
|
|
|
718 int *err ATTRIBUTE_UNUSED)
|
|
|
719 {
|
|
|
720 struct simple_object_xcoff_attributes *attrs =
|
|
|
721 (struct simple_object_xcoff_attributes *) attributes_data;
|
|
|
722 struct simple_object_xcoff_attributes *ret;
|
|
|
723
|
|
|
724 /* We're just going to record the attributes, but we need to make a
|
|
|
725 copy because the user may delete them. */
|
|
|
726 ret = XNEW (struct simple_object_xcoff_attributes);
|
|
|
727 *ret = *attrs;
|
|
|
728 return ret;
|
|
|
729 }
|
|
|
730
|
|
|
731 /* Write out a XCOFF filehdr. */
|
|
|
732
|
|
|
733 static int
|
|
|
734 simple_object_xcoff_write_filehdr (simple_object_write *sobj, int descriptor,
|
|
|
735 unsigned int nscns, size_t symtab_offset,
|
|
|
736 unsigned int nsyms, const char **errmsg,
|
|
|
737 int *err)
|
|
|
738 {
|
|
|
739 struct simple_object_xcoff_attributes *attrs =
|
|
|
740 (struct simple_object_xcoff_attributes *) sobj->data;
|
|
|
741 int u64 = attrs->magic == U64_TOCMAGIC;
|
|
|
742 unsigned char hdrbuf[sizeof (struct external_filehdr)];
|
|
|
743 unsigned char *hdr;
|
|
|
744 void (*set_16) (unsigned char *, unsigned short);
|
|
|
745 void (*set_32) (unsigned char *, unsigned int);
|
|
|
746 void (*set_64) (unsigned char *, ulong_type);
|
|
|
747
|
|
|
748 hdr = &hdrbuf[0];
|
|
|
749
|
|
|
750 set_16 = simple_object_set_big_16;
|
|
|
751 set_32 = simple_object_set_big_32;
|
|
|
752 set_64 = simple_object_set_big_64;
|
|
|
753
|
|
|
754 memset (hdr, 0, sizeof (struct external_filehdr));
|
|
|
755
|
|
|
756 set_16 (hdr + offsetof (struct external_filehdr, f_magic), attrs->magic);
|
|
|
757 set_16 (hdr + offsetof (struct external_filehdr, f_nscns), nscns);
|
|
|
758 /* f_timdat left as zero. */
|
|
|
759 if (u64)
|
|
|
760 {
|
|
|
761 set_64 (hdr + offsetof (struct external_filehdr, u.xcoff64.f_symptr),
|
|
|
762 symtab_offset);
|
|
|
763 set_32 (hdr + offsetof (struct external_filehdr, u.xcoff64.f_nsyms),
|
|
|
764 nsyms);
|
|
|
765 /* f_opthdr left as zero. */
|
|
|
766 set_16 (hdr + offsetof (struct external_filehdr, u.xcoff64.f_flags),
|
|
|
767 attrs->flags);
|
|
|
768 }
|
|
|
769 else
|
|
|
770 {
|
|
|
771 set_32 (hdr + offsetof (struct external_filehdr, u.xcoff64.f_symptr),
|
|
|
772 symtab_offset);
|
|
|
773 set_32 (hdr + offsetof (struct external_filehdr, u.xcoff64.f_nsyms),
|
|
|
774 nsyms);
|
|
|
775 /* f_opthdr left as zero. */
|
|
|
776 set_16 (hdr + offsetof (struct external_filehdr, u.xcoff64.f_flags),
|
|
|
777 attrs->flags);
|
|
|
778 }
|
|
|
779
|
|
|
780 return simple_object_internal_write (descriptor, 0, hdrbuf,
|
|
|
781 sizeof (struct external_filehdr),
|
|
|
782 errmsg, err);
|
|
|
783 }
|
|
|
784
|
|
|
785 /* Write out a XCOFF section header. */
|
|
|
786
|
|
|
787 static int
|
|
|
788 simple_object_xcoff_write_scnhdr (simple_object_write *sobj,
|
|
|
789 int descriptor,
|
|
|
790 const char *name, size_t *name_offset,
|
|
|
791 off_t scnhdr_offset, size_t scnsize,
|
|
|
792 off_t offset, unsigned int align,
|
|
|
793 const char **errmsg, int *err)
|
|
|
794 {
|
|
|
795 struct simple_object_xcoff_read *ocr =
|
|
|
796 (struct simple_object_xcoff_read *) sobj->data;
|
|
|
797 int u64 = ocr->magic == U64_TOCMAGIC;
|
|
|
798 void (*set_32) (unsigned char *, unsigned int);
|
|
|
799 void (*set_64) (unsigned char *, unsigned int);
|
|
|
800 unsigned char hdrbuf[sizeof (struct external_scnhdr)];
|
|
|
801 unsigned char *hdr;
|
|
|
802 size_t namelen;
|
|
|
803 unsigned int flags;
|
|
|
804
|
|
|
805 set_32 = simple_object_set_big_32;
|
|
|
806 set_64 = simple_object_set_big_32;
|
|
|
807
|
|
|
808 memset (hdrbuf, 0, sizeof hdrbuf);
|
|
|
809 hdr = &hdrbuf[0];
|
|
|
810
|
|
|
811 namelen = strlen (name);
|
|
|
812 if (namelen <= SCNNMLEN)
|
|
|
813 strncpy ((char *) hdr + offsetof (struct external_scnhdr, s_name),
|
|
|
814 name, SCNNMLEN);
|
|
|
815 else
|
|
|
816 {
|
|
|
817 snprintf ((char *) hdr + offsetof (struct external_scnhdr, s_name),
|
|
|
818 SCNNMLEN, "/%lu", (unsigned long) *name_offset);
|
|
|
819 *name_offset += namelen + 1;
|
|
|
820 }
|
|
|
821
|
|
|
822 /* s_paddr left as zero. */
|
|
|
823 /* s_vaddr left as zero. */
|
|
|
824 if (u64)
|
|
|
825 {
|
|
|
826 set_64 (hdr + offsetof (struct external_scnhdr, u.xcoff64.s_size),
|
|
|
827 scnsize);
|
|
|
828 set_64 (hdr + offsetof (struct external_scnhdr, u.xcoff64.s_scnptr),
|
|
|
829 offset);
|
|
|
830 }
|
|
|
831 else
|
|
|
832 {
|
|
|
833 set_32 (hdr + offsetof (struct external_scnhdr, u.xcoff32.s_size),
|
|
|
834 scnsize);
|
|
|
835 set_32 (hdr + offsetof (struct external_scnhdr, u.xcoff32.s_scnptr),
|
|
|
836 offset);
|
|
|
837 }
|
|
|
838 /* s_relptr left as zero. */
|
|
|
839 /* s_lnnoptr left as zero. */
|
|
|
840 /* s_nreloc left as zero. */
|
|
|
841 /* s_nlnno left as zero. */
|
|
|
842 flags = STYP_DATA;
|
|
|
843 if (align > 13)
|
|
|
844 align = 13;
|
|
|
845 if (u64)
|
|
|
846 set_32 (hdr + offsetof (struct external_scnhdr, u.xcoff64.s_flags), flags);
|
|
|
847 else
|
|
|
848 set_32 (hdr + offsetof (struct external_scnhdr, u.xcoff32.s_flags), flags);
|
|
|
849
|
|
|
850 return simple_object_internal_write (descriptor, scnhdr_offset, hdrbuf,
|
|
|
851 u64 ? SCNHSZ64 : SCNHSZ32,
|
|
|
852 errmsg, err);
|
|
|
853 }
|
|
|
854
|
|
|
855 /* Write out a complete XCOFF file. */
|
|
|
856
|
|
|
857 static const char *
|
|
|
858 simple_object_xcoff_write_to_file (simple_object_write *sobj, int descriptor,
|
|
|
859 int *err)
|
|
|
860 {
|
|
|
861 struct simple_object_xcoff_read *ocr =
|
|
|
862 (struct simple_object_xcoff_read *) sobj->data;
|
|
|
863 int u64 = ocr->magic == U64_TOCMAGIC;
|
|
|
864 unsigned int nscns, secnum;
|
|
|
865 simple_object_write_section *section;
|
|
|
866 off_t scnhdr_offset;
|
|
|
867 size_t symtab_offset;
|
|
|
868 off_t secsym_offset;
|
|
|
869 unsigned int nsyms;
|
|
|
870 size_t offset;
|
|
|
871 size_t name_offset;
|
|
|
872 const char *errmsg;
|
|
|
873 unsigned char strsizebuf[4];
|
|
|
874 /* The interface doesn't give us access to the name of the input file
|
|
|
875 yet. We want to use its basename for the FILE symbol. This is
|
|
|
876 what 'gas' uses when told to assemble from stdin. */
|
|
|
877 const char *source_filename = "fake";
|
|
|
878 size_t sflen;
|
|
|
879 union
|
|
|
880 {
|
|
|
881 struct external_syment sym;
|
|
|
882 union external_auxent aux;
|
|
|
883 } syms[2];
|
|
|
884 void (*set_16) (unsigned char *, unsigned short);
|
|
|
885 void (*set_32) (unsigned char *, unsigned int);
|
|
|
886
|
|
|
887 set_16 = simple_object_set_big_16;
|
|
|
888 set_32 = simple_object_set_big_32;
|
|
|
889
|
|
|
890 nscns = 0;
|
|
|
891 for (section = sobj->sections; section != NULL; section = section->next)
|
|
|
892 ++nscns;
|
|
|
893
|
|
|
894 scnhdr_offset = sizeof (struct external_filehdr) - (u64 ? 4 : 0);
|
|
|
895 offset = scnhdr_offset + nscns * (u64 ? SCNHSZ64 : SCNHSZ32);
|
|
|
896 name_offset = 4;
|
|
|
897 for (section = sobj->sections; section != NULL; section = section->next)
|
|
|
898 {
|
|
|
899 size_t mask;
|
|
|
900 size_t new_offset;
|
|
|
901 size_t scnsize;
|
|
|
902 struct simple_object_write_section_buffer *buffer;
|
|
|
903
|
|
|
904 mask = (1U << section->align) - 1;
|
|
|
905 new_offset = offset & mask;
|
|
|
906 new_offset &= ~ mask;
|
|
|
907 while (new_offset > offset)
|
|
|
908 {
|
|
|
909 unsigned char zeroes[16];
|
|
|
910 size_t write;
|
|
|
911
|
|
|
912 memset (zeroes, 0, sizeof zeroes);
|
|
|
913 write = new_offset - offset;
|
|
|
914 if (write > sizeof zeroes)
|
|
|
915 write = sizeof zeroes;
|
|
|
916 if (!simple_object_internal_write (descriptor, offset, zeroes, write,
|
|
|
917 &errmsg, err))
|
|
|
918 return errmsg;
|
|
|
919 }
|
|
|
920
|
|
|
921 scnsize = 0;
|
|
|
922 for (buffer = section->buffers; buffer != NULL; buffer = buffer->next)
|
|
|
923 {
|
|
|
924 if (!simple_object_internal_write (descriptor, offset + scnsize,
|
|
|
925 ((const unsigned char *)
|
|
|
926 buffer->buffer),
|
|
|
927 buffer->size, &errmsg, err))
|
|
|
928 return errmsg;
|
|
|
929 scnsize += buffer->size;
|
|
|
930 }
|
|
|
931
|
|
|
932 if (!simple_object_xcoff_write_scnhdr (sobj, descriptor, section->name,
|
|
|
933 &name_offset, scnhdr_offset,
|
|
|
934 scnsize, offset, section->align,
|
|
|
935 &errmsg, err))
|
|
|
936 return errmsg;
|
|
|
937
|
|
|
938 scnhdr_offset += u64 ? SCNHSZ64 : SCNHSZ32;
|
|
|
939 offset += scnsize;
|
|
|
940 }
|
|
|
941
|
|
|
942 /* Symbol table is always half-word aligned. */
|
|
|
943 offset += (offset & 1);
|
|
|
944 /* There is a file symbol and a section symbol per section,
|
|
|
945 and each of these has a single auxiliary symbol following. */
|
|
|
946 nsyms = 2 * (nscns + 1);
|
|
|
947 symtab_offset = offset;
|
|
|
948 /* Advance across space reserved for symbol table to locate
|
|
|
949 start of string table. */
|
|
|
950 offset += nsyms * SYMESZ;
|
|
|
951
|
|
|
952 /* Write out file symbol. */
|
|
|
953 memset (&syms[0], 0, sizeof (syms));
|
|
|
954 if (!u64)
|
|
|
955 strcpy ((char *)&syms[0].sym.u.xcoff32.n.n_name[0], ".file");
|
|
|
956 set_16 (&syms[0].sym.n_scnum[0], N_DEBUG);
|
|
|
957 set_16 (&syms[0].sym.n_type[0], IMAGE_SYM_TYPE);
|
|
|
958 syms[0].sym.n_sclass[0] = C_FILE;
|
|
|
959 syms[0].sym.n_numaux[0] = 1;
|
|
|
960 /* The name need not be nul-terminated if it fits into the x_fname field
|
|
|
961 directly, but must be if it has to be placed into the string table. */
|
|
|
962 sflen = strlen (source_filename);
|
|
|
963 if (sflen <= FILNMLEN)
|
|
|
964 memcpy (&syms[1].aux.x_file.x_fname[0], source_filename, sflen);
|
|
|
965 else
|
|
|
966 {
|
|
|
967 set_32 (&syms[1].aux.x_file._x.x_offset[0], name_offset);
|
|
|
968 if (!simple_object_internal_write (descriptor, offset + name_offset,
|
|
|
969 ((const unsigned char *)
|
|
|
970 source_filename),
|
|
|
971 sflen + 1, &errmsg, err))
|
|
|
972 return errmsg;
|
|
|
973 name_offset += strlen (source_filename) + 1;
|
|
|
974 }
|
|
|
975 if (!simple_object_internal_write (descriptor, symtab_offset,
|
|
|
976 (const unsigned char *) &syms[0],
|
|
|
977 sizeof (syms), &errmsg, err))
|
|
|
978 return errmsg;
|
|
|
979
|
|
|
980 /* Write the string table length, followed by the strings and section
|
|
|
981 symbols in step with each other. */
|
|
|
982 set_32 (strsizebuf, name_offset);
|
|
|
983 if (!simple_object_internal_write (descriptor, offset, strsizebuf, 4,
|
|
|
984 &errmsg, err))
|
|
|
985 return errmsg;
|
|
|
986
|
|
|
987 name_offset = 4;
|
|
|
988 secsym_offset = symtab_offset + sizeof (syms);
|
|
|
989 memset (&syms[0], 0, sizeof (syms));
|
|
|
990 set_16 (&syms[0].sym.n_type[0], IMAGE_SYM_TYPE);
|
|
|
991 syms[0].sym.n_sclass[0] = C_STAT;
|
|
|
992 syms[0].sym.n_numaux[0] = 1;
|
|
|
993 secnum = 1;
|
|
|
994
|
|
|
995 for (section = sobj->sections; section != NULL; section = section->next)
|
|
|
996 {
|
|
|
997 size_t namelen;
|
|
|
998 size_t scnsize;
|
|
|
999 struct simple_object_write_section_buffer *buffer;
|
|
|
1000
|
|
|
1001 namelen = strlen (section->name);
|
|
|
1002 set_16 (&syms[0].sym.n_scnum[0], secnum++);
|
|
|
1003 scnsize = 0;
|
|
|
1004 for (buffer = section->buffers; buffer != NULL; buffer = buffer->next)
|
|
|
1005 scnsize += buffer->size;
|
|
|
1006 set_32 (&syms[1].aux.x_scn.x_scnlen[0], scnsize);
|
|
|
1007 if (namelen > SCNNMLEN)
|
|
|
1008 {
|
|
|
1009 set_32 (&syms[0].sym.u.xcoff32.n.n.n_zeroes[0], 0);
|
|
|
1010 set_32 (&syms[0].sym.u.xcoff32.n.n.n_offset[0], name_offset);
|
|
|
1011 if (!simple_object_internal_write (descriptor, offset + name_offset,
|
|
|
1012 ((const unsigned char *)
|
|
|
1013 section->name),
|
|
|
1014 namelen + 1, &errmsg, err))
|
|
|
1015 return errmsg;
|
|
|
1016 name_offset += namelen + 1;
|
|
|
1017 }
|
|
|
1018 else
|
|
|
1019 {
|
|
|
1020 memcpy (&syms[0].sym.u.xcoff32.n.n_name[0], section->name,
|
|
|
1021 strlen (section->name));
|
|
|
1022 memset (&syms[0].sym.u.xcoff32.n.n_name[strlen (section->name)], 0,
|
|
|
1023 N_SYMNMLEN - strlen (section->name));
|
|
|
1024 }
|
|
|
1025
|
|
|
1026 if (!simple_object_internal_write (descriptor, secsym_offset,
|
|
|
1027 (const unsigned char *) &syms[0],
|
|
|
1028 sizeof (syms), &errmsg, err))
|
|
|
1029 return errmsg;
|
|
|
1030 secsym_offset += sizeof (syms);
|
|
|
1031 }
|
|
|
1032
|
|
|
1033 if (!simple_object_xcoff_write_filehdr (sobj, descriptor, nscns,
|
|
|
1034 symtab_offset, nsyms, &errmsg, err))
|
|
|
1035 return errmsg;
|
|
|
1036
|
|
|
1037 return NULL;
|
|
|
1038 }
|
|
|
1039
|
|
|
1040 /* Release the private data for an simple_object_write structure. */
|
|
|
1041
|
|
|
1042 static void
|
|
|
1043 simple_object_xcoff_release_write (void *data)
|
|
|
1044 {
|
|
|
1045 XDELETE (data);
|
|
|
1046 }
|
|
|
1047
|
|
|
1048 /* The XCOFF functions. */
|
|
|
1049
|
|
|
1050 const struct simple_object_functions simple_object_xcoff_functions =
|
|
|
1051 {
|
|
|
1052 simple_object_xcoff_match,
|
|
|
1053 simple_object_xcoff_find_sections,
|
|
|
1054 simple_object_xcoff_fetch_attributes,
|
|
|
1055 simple_object_xcoff_release_read,
|
|
|
1056 simple_object_xcoff_attributes_merge,
|
|
|
1057 simple_object_xcoff_release_attributes,
|
|
|
1058 simple_object_xcoff_start_write,
|
|
|
1059 simple_object_xcoff_write_to_file,
|
|
|
1060 simple_object_xcoff_release_write,
|
|
|
1061 NULL
|
|
|
1062 };
|
