projects / deliverable / binutils-gdb.git / blob
? search:


dc931ee81f118bc160ea0dc4cb68e792676dd534
[deliverable/binutils-gdb.git] / bfd / aout.c
1 /*** bfd backend for sunos binaries */
2
3 /* Copyright (C) 1990, 1991 Free Software Foundation, Inc.
4
5 This file is part of BFD, the Binary File Diddler.
6
7 BFD is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 1, or (at your option)
10 any later version.
11
12 BFD is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with BFD; see the file COPYING. If not, write to
19 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
20
21 /* $Id$
22 *
23 */
24
25 #define TARGET_BYTE_ORDER_BIG_P 1
26
27 #include <ansidecl.h>
28 #include "sysdep.h"
29 #include "bfd.h"
30 #include "libbfd.h"
31
32
33 void (*bfd_error_trap)();
34
35 /*SUPPRESS558*/
36 /*SUPPRESS529*/
37
38
39
40
41 typedef void generic_symbol_type;
42 /* These values are correct for the SPARC. I dunno about anything else */
43 #define PAGE_SIZE 0x02000
44 #define SEGMENT_SIZE PAGE_SIZE
45 #define TEXT_START_ADDR PAGE_SIZE
46 #include "a.out.gnu.h"
47 #include "stab.gnu.h"
48 #include "ar.h"
49 #include "liba.out.h" /* BFD a.out internal data structures */
50
51 #include "a.out.sun4.h"
52
53 #define CTOR_TABLE_RELOC_IDX 2
54 static reloc_howto_type howto_table_ext[] =
55 {
56 /* type rs size bsz pcrel bitpos abs ovrf sf name partial inplace mask*/
57 { (unsigned int) RELOC_8, 0, 0, 8, false, 0, true, true,0,"8", false, 0,0x000000ff},
58 { (unsigned int) RELOC_16, 0, 1, 16, false, 0, true, true,0,"16", false, 0,0x0000ffff},
59 { (unsigned int) RELOC_32, 0, 2, 32, false, 0, true, true,0,"32", false, 0,0xffffffff},
60 { (unsigned int) RELOC_DISP8, 0, 0, 8, true, 0, false, true,0,"DISP8", false, 0,0x000000ff},
61 { (unsigned int) RELOC_DISP16, 0, 1, 16, true, 0, false, true,0,"DISP16", false, 0,0x0000ffff},
62 { (unsigned int) RELOC_DISP32, 0, 2, 32, true, 0, false, true,0,"DISP32", false, 0,0xffffffff},
63 { (unsigned int) RELOC_WDISP30,2, 2, 30, true, 0, false, true,0,"WDISP30", false, 0,0x3fffffff},
64 { (unsigned int) RELOC_WDISP22,2, 2, 22, true, 0, false, true,0,"WDISP22", false, 0,0x003fffff},
65 { (unsigned int) RELOC_HI22, 10, 2, 22, false, 0, false, true,0,"HI22", false, 0,0x003fffff},
66 { (unsigned int) RELOC_22, 0, 2, 22, false, 0, false, true,0,"22", false, 0,0x003fffff},
67 { (unsigned int) RELOC_13, 0, 2, 13, false, 0, false, true,0,"13", false, 0,0x00001fff},
68 { (unsigned int) RELOC_LO10, 0, 2, 10, false, 0, false, true,0,"LO10", false, 0,0x000003ff},
69 { (unsigned int) RELOC_SFA_BASE,0, 2, 32, false, 0, false, true,0,"SFA_BASE", false, 0,0xffffffff},
70 { (unsigned int) RELOC_SFA_OFF13,0,2, 32, false, 0, false, true,0,"SFA_OFF13",false, 0,0xffffffff},
71 { (unsigned int) RELOC_BASE10, 0, 2, 16, false, 0, false, true,0,"BASE10", false, 0,0x0000ffff},
72 { (unsigned int) RELOC_BASE13, 0, 2, 13, false, 0, false, true,0,"BASE13", false, 0,0x00001fff},
73 { (unsigned int) RELOC_BASE22, 0, 2, 0, false, 0, false, true,0,"BASE22", false, 0,0x00000000},
74 { (unsigned int) RELOC_PC10, 0, 2, 10, false, 0, false, true,0,"PC10", false, 0,0x000003ff},
75 { (unsigned int) RELOC_PC22, 0, 2, 22, false, 0, false, true,0,"PC22", false, 0,0x003fffff},
76 { (unsigned int) RELOC_JMP_TBL,0, 2, 32, false, 0, false, true,0,"JMP_TBL", false, 0,0xffffffff},
77 { (unsigned int) RELOC_SEGOFF16,0, 2, 0, false, 0, false, true,0,"SEGOFF16", false, 0,0x00000000},
78 { (unsigned int) RELOC_GLOB_DAT,0, 2, 0, false, 0, false, true,0,"GLOB_DAT", false, 0,0x00000000},
79 { (unsigned int) RELOC_JMP_SLOT,0, 2, 0, false, 0, false, true,0,"JMP_SLOT", false, 0,0x00000000},
80 { (unsigned int) RELOC_RELATIVE,0, 2, 0, false, 0, false, true,0,"RELATIVE", false, 0,0x00000000},
81 { (unsigned int) RELOC_JUMPTARG,2, 13, 16, true, 0, false, true,0,"JUMPTARG", false, 0,0x0000ffff},
82 { (unsigned int) RELOC_CONST, 0, 13, 16, false, 0, false, true,0,"CONST", false, 0,0x0000ffff},
83 { (unsigned int) RELOC_CONSTH, 16, 13, 16, false, 0, false, true,0,"CONSTH", false, 0,0x0000ffff},
84 };
85
86 /* Convert standard reloc records to "arelent" format (incl byte swap). */
87
88 static reloc_howto_type howto_table_std[] = {
89 /* type rs size bsz pcrel bitpos abs ovrf sf name*/
90 { (unsigned int) 0, 0, 0, 8, false, 0, true, true,0,"8", true, 0x000000ff,0x000000ff},
91 { (unsigned int) 1, 0, 1, 16, false, 0, true, true,0,"16", true, 0x0000ffff,0x0000ffff},
92 { (unsigned int) 2, 0, 2, 32, false, 0, true, true,0,"32", true, 0xffffffff,0xffffffff},
93 { (unsigned int) 3, 0, 3, 64, false, 0, true, true,0,"64", true, 0xdeaddead,0xdeaddead},
94 { (unsigned int) 4, 0, 0, 8, true, 0, false, true,0,"DISP8", true, 0x000000ff,0x000000ff},
95 { (unsigned int) 5, 0, 1, 16, true, 0, false, true,0,"DISP16", true, 0x0000ffff,0x0000ffff},
96 { (unsigned int) 6, 0, 2, 32, true, 0, false, true,0,"DISP32", true, 0xffffffff,0xffffffff},
97 { (unsigned int) 7, 0, 3, 64, true, 0, false, true,0,"DISP64", true, 0xfeedface,0xfeedface},
98 };
99
100
101 bfd_error_vector_type bfd_error_vector;
102 /** a.out files */
103
104
105 PROTO (void , sunos4_write_syms, ());
106 PROTO (static boolean,sunos4_squirt_out_relocs,(bfd *abfd, asection *section));
107
108
109 static size_t
110 reloc_size_func(abfd)
111 bfd *abfd;
112 {
113 switch (bfd_get_architecture (abfd)) {
114 case bfd_arch_sparc:
115 case bfd_arch_a29k:
116 return RELOC_EXT_SIZE;
117 default:
118 return RELOC_STD_SIZE;
119 }
120 }
121
122 static void
123 DEFUN(bfd_aout_swap_exec_header_in,(abfd, raw_bytes, execp),
124 bfd *abfd AND
125 unsigned char *raw_bytes AND
126 struct exec *execp)
127 {
128 struct exec_bytes *bytes = (struct exec_bytes *)raw_bytes;
129
130 /* Now fill in fields in the execp, from the bytes in the raw data. */
131 execp->a_info = bfd_h_getlong (abfd, bytes->a_info);
132 execp->a_text = bfd_h_getlong (abfd, bytes->a_text);
133 execp->a_data = bfd_h_getlong (abfd, bytes->a_data);
134 execp->a_bss = bfd_h_getlong (abfd, bytes->a_bss);
135 execp->a_syms = bfd_h_getlong (abfd, bytes->a_syms);
136 execp->a_entry = bfd_h_getlong (abfd, bytes->a_entry);
137 execp->a_trsize = bfd_h_getlong (abfd, bytes->a_trsize);
138 execp->a_drsize = bfd_h_getlong (abfd, bytes->a_drsize);
139 }
140
141 static void
142 DEFUN(bfd_aout_swap_exec_header_out,(abfd, execp, raw_bytes),
143 bfd *abfd AND
144 struct exec *execp AND
145 unsigned char *raw_bytes)
146 {
147 struct exec_bytes *bytes = (struct exec_bytes *)raw_bytes;
148
149 /* Now fill in fields in the raw data, from the fields in the exec struct. */
150 bfd_h_putlong (abfd, execp->a_info , bytes->a_info);
151 bfd_h_putlong (abfd, execp->a_text , bytes->a_text);
152 bfd_h_putlong (abfd, execp->a_data , bytes->a_data);
153 bfd_h_putlong (abfd, execp->a_bss , bytes->a_bss);
154 bfd_h_putlong (abfd, execp->a_syms , bytes->a_syms);
155 bfd_h_putlong (abfd, execp->a_entry , bytes->a_entry);
156 bfd_h_putlong (abfd, execp->a_trsize, bytes->a_trsize);
157 bfd_h_putlong (abfd, execp->a_drsize, bytes->a_drsize);
158 }
159
160 /* Steve wants some way to frob this stuff from Saber while he's debugging
161 ld, so we have these funny shadow functions */
162 /* ZMAGIC's start at 0 (making the exec part of the text section),
163 other formats start after the exec
164 */
165 static unsigned int n_txtoff(ptr)
166 struct exec *ptr;
167 {return N_MAGIC(*ptr)== ZMAGIC ? 0: sizeof(struct exec);}
168
169 static unsigned int n_datoff(ptr)
170 struct exec *ptr;
171 {return n_txtoff(ptr) + ptr->a_text;}
172
173 static unsigned int n_treloff(ptr)
174 struct exec *ptr;
175 {return n_datoff(ptr) + ptr->a_data;}
176
177 static unsigned int n_dreloff(ptr)
178 struct exec *ptr;
179 {return n_treloff(ptr) + ptr->a_trsize;}
180
181 static unsigned int n_symoff(ptr)
182 struct exec *ptr;
183 {return n_dreloff(ptr) + ptr->a_drsize;}
184
185 static unsigned int n_stroff(ptr)
186 struct exec *ptr;
187 {return n_symoff(ptr) + ptr->a_syms;}
188
189 static
190 unsigned int n_badmag(ptr)
191 struct exec *ptr;
192 {
193 switch (N_MAGIC(*ptr)) {
194 case OMAGIC: case NMAGIC: case ZMAGIC: return 0;
195 default: return 1;
196 }
197 }
198
199 bfd_target *
200 sunos4_object_p (abfd)
201 bfd *abfd;
202 {
203 unsigned char magicbuf[4]; /* Raw bytes of magic number from file */
204 unsigned long magic; /* Swapped magic number */
205 unsigned char exec_bytes[EXEC_BYTES_SIZE]; /* Raw bytes of exec hdr */
206 struct exec *execp;
207 void *rawptr;
208
209 bfd_error = system_call_error;
210
211 if (bfd_read ((void *)magicbuf, 1, sizeof (magicbuf), abfd) !=
212 sizeof (magicbuf))
213 return 0;
214 magic = bfd_h_getlong (abfd, magicbuf);
215
216 /* Baroque syntax to mask deficiencies of the Sun compiler */
217 /* if (N_BADMAG (*((struct exec *) &magic))) return 0; */
218 if (n_badmag ((struct exec *) &magic)) return 0;
219
220 if (bfd_seek (abfd, 0L, false) < 0) return 0;
221
222 if (bfd_read ((void *) exec_bytes, 1, EXEC_BYTES_SIZE, abfd)
223 != EXEC_BYTES_SIZE) {
224 bfd_error = wrong_format;
225 return 0;
226 }
227
228 /* Use an intermediate variable for clarity */
229 rawptr = (void *) zalloc (sizeof (struct sunexdata) + sizeof (struct exec));
230
231 if (rawptr == NULL) {
232 bfd_error = no_memory;
233 return 0;
234 }
235
236 set_tdata (abfd, ((struct sunexdata *) rawptr));
237 exec_hdr (abfd) = execp =
238 (struct exec *) ((char *)rawptr + sizeof (struct sunexdata));
239
240 bfd_aout_swap_exec_header_in (abfd, exec_bytes, execp);
241
242 /* Set the file flags */
243 abfd->flags = NO_FLAGS;
244 if (execp->a_drsize || execp->a_trsize)
245 abfd->flags |= HAS_RELOC;
246 if (execp->a_entry)
247 abfd->flags |= EXEC_P;
248 if (execp->a_syms)
249 abfd->flags |= HAS_LINENO | HAS_DEBUG | HAS_SYMS | HAS_LOCALS;
250
251
252 if (N_MAGIC (*execp) == ZMAGIC) abfd->flags |= D_PAGED;
253 if (N_MAGIC (*execp) == NMAGIC) abfd->flags |= WP_TEXT;
254
255 /* Determine the architecture and machine type of the object file. */
256 abfd->obj_arch = bfd_arch_unknown; /* Default values */
257 abfd->obj_machine = 0;
258 switch (N_MACHTYPE (*execp)) {
259
260 case M_UNKNOWN:
261 break;
262
263 case M_68010:
264 abfd->obj_arch = bfd_arch_m68k;
265 abfd->obj_machine = 68010;
266 break;
267
268 case M_68020:
269 abfd->obj_arch = bfd_arch_m68k;
270 abfd->obj_machine = 68020;
271 break;
272
273 case M_SPARC:
274 abfd->obj_arch = bfd_arch_sparc;
275 break;
276
277 case M_386:
278 abfd->obj_arch = bfd_arch_i386;
279 break;
280
281 case M_29K:
282 abfd->obj_arch = bfd_arch_a29k;
283 break;
284
285 default:
286 abfd->obj_arch = bfd_arch_obscure;
287 break;
288 }
289
290 bfd_get_start_address (abfd) = execp->a_entry;
291
292 /* Remember the positions of the string table and symbol table. */
293 obj_str_filepos (abfd) = n_stroff (execp);
294 obj_sym_filepos (abfd) = n_symoff (execp);
295
296 /* create the sections. This is raunchy, but bfd_close wants to reclaim
297 them */
298 obj_textsec (abfd) = (asection *)NULL;
299 obj_datasec (abfd) = (asection *)NULL;
300 obj_bsssec (abfd) = (asection *)NULL;
301 obj_aout_symbols(abfd) = (aout_symbol_type *)NULL;
302 (void)bfd_make_section(abfd, ".text");
303 (void)bfd_make_section(abfd, ".data");
304 (void)bfd_make_section(abfd, ".bss");
305
306 obj_datasec (abfd)->size = execp->a_data;
307 obj_bsssec (abfd)->size = execp->a_bss;
308 obj_textsec (abfd)->size = execp->a_text;
309 obj_datasec (abfd)->vma = N_DATADDR(*execp);
310 obj_bsssec (abfd)->vma = N_BSSADDR(*execp);
311 obj_textsec (abfd)->vma = N_TXTADDR(*execp);
312
313 obj_textsec (abfd)->filepos = N_TXTOFF(*execp);
314 obj_datasec (abfd)->filepos = N_DATOFF(*execp);
315
316 obj_textsec (abfd)->rel_filepos = N_TROFF(*execp);
317 obj_datasec (abfd)->rel_filepos = N_DROFF(*execp);
318
319 obj_textsec (abfd)->flags = (execp->a_trsize != 0 ?
320 (SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_HAS_CONTENTS) :
321 (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS));
322 obj_datasec (abfd)->flags = (execp->a_drsize != 0 ?
323 (SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_HAS_CONTENTS) :
324 (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS));
325 obj_bsssec (abfd)->flags = SEC_ALLOC;
326
327 abfd->sections = obj_textsec (abfd);
328 obj_textsec (abfd)->next = obj_datasec (abfd);
329 obj_datasec (abfd)->next = obj_bsssec (abfd);
330 return abfd->xvec;
331 }
332
333
334 boolean
335 sunos4_mkobject (abfd)
336 bfd *abfd;
337 {
338 char *rawptr;
339
340 bfd_error = system_call_error;
341
342 /* Use an intermediate variable for clarity */
343 rawptr = zalloc (sizeof (struct sunexdata) + sizeof (struct exec));
344
345 if (rawptr == NULL) {
346 bfd_error = no_memory;
347 return false;
348 }
349
350 abfd->tdata = (void *)((struct sunexdata *) rawptr);
351 exec_hdr (abfd) = (struct exec *) (rawptr + sizeof (struct sunexdata));
352
353 /* For simplicity's sake we just make all the sections right here. */
354
355 obj_textsec (abfd) = (asection *)NULL;
356 obj_datasec (abfd) = (asection *)NULL;
357 obj_bsssec (abfd) = (asection *)NULL;
358 bfd_make_section (abfd, ".text");
359 bfd_make_section (abfd, ".data");
360 bfd_make_section (abfd, ".bss");
361
362 return true;
363 }
364
365 /* Keep track of machine architecture and machine type for a.out's.
366 Return the machine_type for a particular arch&machine, or M_UNKNOWN
367 if that exact arch&machine can't be represented in a.out format.
368
369 If the architecture is understood, machine type 0 (default) should
370 always be understood. */
371
372 static enum machine_type
373 aout_machine_type (arch, machine)
374 enum bfd_architecture arch;
375 unsigned long machine;
376 {
377 enum machine_type arch_flags;
378
379 arch_flags = M_UNKNOWN;
380
381 switch (arch) {
382 case bfd_arch_sparc:
383 if (machine == 0) arch_flags = M_SPARC;
384 break;
385
386 case bfd_arch_m68k:
387 switch (machine) {
388 case 0: arch_flags = M_UNKNOWN; break;
389 case 68000: arch_flags = M_UNKNOWN; break;
390 case 68010: arch_flags = M_68010; break;
391 case 68020: arch_flags = M_68020; break;
392 default: arch_flags = M_UNKNOWN; break;
393 }
394 break;
395
396 case bfd_arch_i386:
397 if (machine == 0) arch_flags = M_386;
398 break;
399
400 case bfd_arch_a29k:
401 if (machine == 0) arch_flags = M_29K;
402 break;
403
404 default:
405 arch_flags = M_UNKNOWN;
406 break;
407 }
408 return arch_flags;
409 }
410
411 boolean
412 sunos4_set_arch_mach (abfd, arch, machine)
413 bfd *abfd;
414 enum bfd_architecture arch;
415 unsigned long machine;
416 {
417 abfd->obj_arch = arch;
418 abfd->obj_machine = machine;
419 if (arch != bfd_arch_unknown &&
420 aout_machine_type (arch, machine) == M_UNKNOWN)
421 return false; /* We can't represent this type */
422 return true; /* We're easy ... */
423 }
424
425 boolean
426 sunos4_write_object_contents (abfd)
427 bfd *abfd;
428 {
429 size_t data_pad = 0;
430 unsigned char exec_bytes[EXEC_BYTES_SIZE];
431 struct exec *execp = exec_hdr (abfd);
432
433 execp->a_text = obj_textsec (abfd)->size;
434
435 /* Magic number, maestro, please! */
436 switch (bfd_get_architecture(abfd)) {
437 case bfd_arch_m68k:
438 switch (bfd_get_machine(abfd)) {
439 case 68010:
440 N_SET_MACHTYPE(*execp, M_68010);
441 break;
442 default:
443 case 68020:
444 N_SET_MACHTYPE(*execp, M_68020);
445 break;
446 }
447 break;
448 case bfd_arch_sparc:
449 N_SET_MACHTYPE(*execp, M_SPARC);
450 break;
451 case bfd_arch_i386:
452 N_SET_MACHTYPE(*execp, M_386);
453 break;
454 case bfd_arch_a29k:
455 N_SET_MACHTYPE(*execp, M_29K);
456 break;
457 default:
458 N_SET_MACHTYPE(*execp, M_UNKNOWN);
459 }
460
461 N_SET_MAGIC (*execp, OMAGIC);
462 if (abfd->flags & D_PAGED) {
463 execp->a_text = obj_textsec (abfd)->size + sizeof(struct exec);
464 N_SET_MAGIC (*execp, ZMAGIC);
465 } else if (abfd->flags & WP_TEXT) {
466 N_SET_MAGIC (*execp, NMAGIC);
467 }
468 N_SET_FLAGS (*execp, 0x1); /* copied from ld.c; who the hell knows? */
469
470 if (abfd->flags & D_PAGED)
471 {
472 data_pad = ((obj_datasec(abfd)->size + PAGE_SIZE -1)
473 & (- PAGE_SIZE)) - obj_datasec(abfd)->size;
474
475 if (data_pad > obj_bsssec(abfd)->size)
476 execp->a_bss = 0;
477 else
478 execp->a_bss = obj_bsssec(abfd)->size - data_pad;
479 execp->a_data = obj_datasec(abfd)->size + data_pad;
480
481 }
482 else {
483 execp->a_data = obj_datasec (abfd)->size;
484 execp->a_bss = obj_bsssec (abfd)->size;
485 }
486
487 execp->a_syms = bfd_get_symcount (abfd) * sizeof (struct nlist);
488 execp->a_entry = bfd_get_start_address (abfd);
489
490 execp->a_trsize = ((obj_textsec (abfd)->reloc_count) *
491 reloc_size_func(abfd));
492
493 execp->a_drsize = ((obj_datasec (abfd)->reloc_count) *
494 reloc_size_func(abfd));
495
496 bfd_aout_swap_exec_header_out (abfd, execp, exec_bytes);
497
498 bfd_seek (abfd, 0L, false);
499 bfd_write ((void *) exec_bytes, 1, EXEC_BYTES_SIZE, abfd);
500
501 /* Now write out reloc info, followed by syms and strings */
502
503 if (bfd_get_symcount (abfd) != 0)
504 {
505 bfd_seek (abfd,
506 (long)(N_SYMOFF(*execp)), false);
507
508 sunos4_write_syms (abfd);
509
510 bfd_seek (abfd, (long)(N_TROFF(*execp)), false);
511
512 if (!sunos4_squirt_out_relocs (abfd, obj_textsec (abfd))) return false;
513 bfd_seek (abfd, (long)(N_DROFF(*execp)), false);
514
515 if (!sunos4_squirt_out_relocs (abfd, obj_datasec (abfd))) return false;
516 }
517 return true;
518 }
519
520 /** core files */
521 /** core files */
522
523 #define CORE_MAGIC 0x080456
524 #define CORE_NAMELEN 16
525
526 /* The core structure is taken from the Sun documentation.
527 Unfortunately, they don't document the FPA structure, or at least I
528 can't find it easily. Fortunately the core header contains its own
529 length. So this shouldn't cause problems, except for c_ucode, which
530 so far we don't use but is easy to find with a little arithmetic. */
531
532 /* But the reg structure can be gotten from the SPARC processor handbook.
533 This really should be in a GNU include file though so that gdb can use
534 the same info. */
535 struct regs {
536 int r_psr;
537 int r_pc;
538 int r_npc;
539 int r_y;
540 int r_g1;
541 int r_g2;
542 int r_g3;
543 int r_g4;
544 int r_g5;
545 int r_g6;
546 int r_g7;
547 int r_o0;
548 int r_o1;
549 int r_o2;
550 int r_o3;
551 int r_o4;
552 int r_o5;
553 int r_o6;
554 int r_o7;
555 };
556
557 /* Taken from Sun documentation: */
558
559 /* FIXME: It's worse than we expect. This struct contains TWO substructs
560 neither of whose size we know, WITH STUFF IN BETWEEN THEM! We can't
561 even portably access the stuff in between! */
562
563 struct core {
564 int c_magic; /* Corefile magic number */
565 int c_len; /* Sizeof (struct core) */
566 struct regs c_regs; /* General purpose registers */
567 struct exec c_aouthdr; /* A.out header */
568 int c_signo; /* Killing signal, if any */
569 int c_tsize; /* Text size (bytes) */
570 int c_dsize; /* Data size (bytes) */
571 int c_ssize; /* Stack size (bytes) */
572 char c_cmdname[CORE_NAMELEN + 1]; /* Command name */
573 double fp_stuff[1]; /* external FPU state (size unknown by us) */
574 /* The type "double" is critical here, for alignment.
575 SunOS declares a struct here, but the struct's alignment
576 is double since it contains doubles. */
577 int c_ucode; /* Exception no. from u_code */
578 /* (this member is not accessible by name since we don't
579 portably know the size of fp_stuff.) */
580 };
581
582 /* Supposedly the user stack grows downward from the bottom of kernel memory.
583 Presuming that this remains true, this definition will work. */
584 #define USRSTACK (-(128*1024*1024))
585
586 PROTO (static void, swapcore, (bfd *abfd, struct core *core));
587
588 /* need this cast b/c ptr is really void * */
589 #define core_hdr(bfd) (((struct suncordata *) (bfd->tdata))->hdr)
590 #define core_datasec(bfd) (((struct suncordata *) ((bfd)->tdata))->data_section)
591 #define core_stacksec(bfd) (((struct suncordata*)((bfd)->tdata))->stack_section)
592 #define core_regsec(bfd) (((struct suncordata *) ((bfd)->tdata))->reg_section)
593 #define core_reg2sec(bfd) (((struct suncordata *) ((bfd)->tdata))->reg2_section)
594
595 /* These are stored in the bfd's tdata */
596 struct suncordata {
597 struct core *hdr; /* core file header */
598 asection *data_section;
599 asection *stack_section;
600 asection *reg_section;
601 asection *reg2_section;
602 };
603
604 bfd_target *
605 sunos4_core_file_p (abfd)
606 bfd *abfd;
607 {
608 unsigned char longbuf[4]; /* Raw bytes of various header fields */
609 int core_size;
610 int core_mag;
611 struct core *core;
612 char *rawptr;
613
614 bfd_error = system_call_error;
615
616 if (bfd_read ((void *)longbuf, 1, sizeof (longbuf), abfd) !=
617 sizeof (longbuf))
618 return 0;
619 core_mag = bfd_h_getlong (abfd, longbuf);
620
621 if (core_mag != CORE_MAGIC) return 0;
622
623 /* SunOS core headers can vary in length; second word is size; */
624 if (bfd_read ((void *)longbuf, 1, sizeof (longbuf), abfd) !=
625 sizeof (longbuf))
626 return 0;
627 core_size = bfd_h_getlong (abfd, longbuf);
628 /* Sanity check */
629 if (core_size > 20000)
630 return 0;
631
632 if (bfd_seek (abfd, 0L, false) < 0) return 0;
633
634 rawptr = zalloc (core_size + sizeof (struct suncordata));
635 if (rawptr == NULL) {
636 bfd_error = no_memory;
637 return 0;
638 }
639
640 core = (struct core *) (rawptr + sizeof (struct suncordata));
641
642 if ((bfd_read ((void *) core, 1, core_size, abfd)) != core_size) {
643 bfd_error = system_call_error;
644 free ((void *)rawptr);
645 return 0;
646 }
647
648 swapcore (abfd, core);
649 set_tdata (abfd, ((struct suncordata *) rawptr));
650 core_hdr (abfd) = core;
651
652 /* create the sections. This is raunchy, but bfd_close wants to reclaim
653 them */
654 core_stacksec (abfd) = (asection *) zalloc (sizeof (asection));
655 if (core_stacksec (abfd) == NULL) {
656 loser:
657 bfd_error = no_memory;
658 free ((void *)rawptr);
659 return 0;
660 }
661 core_datasec (abfd) = (asection *) zalloc (sizeof (asection));
662 if (core_datasec (abfd) == NULL) {
663 loser1:
664 free ((void *)core_stacksec (abfd));
665 goto loser;
666 }
667 core_regsec (abfd) = (asection *) zalloc (sizeof (asection));
668 if (core_regsec (abfd) == NULL) {
669 loser2:
670 free ((void *)core_datasec (abfd));
671 goto loser1;
672 }
673 core_reg2sec (abfd) = (asection *) zalloc (sizeof (asection));
674 if (core_reg2sec (abfd) == NULL) {
675 free ((void *)core_regsec (abfd));
676 goto loser2;
677 }
678
679 core_stacksec (abfd)->name = ".stack";
680 core_datasec (abfd)->name = ".data";
681 core_regsec (abfd)->name = ".reg";
682 core_reg2sec (abfd)->name = ".reg2";
683
684 core_stacksec (abfd)->flags = SEC_ALLOC + SEC_LOAD;
685 core_datasec (abfd)->flags = SEC_ALLOC + SEC_LOAD;
686 core_regsec (abfd)->flags = SEC_ALLOC;
687 core_reg2sec (abfd)->flags = SEC_ALLOC;
688
689 core_stacksec (abfd)->size = core->c_ssize;
690 core_datasec (abfd)->size = core->c_dsize;
691 core_regsec (abfd)->size = (sizeof core->c_regs);
692 /* Float regs take up end of struct, except c_ucode. */
693 core_reg2sec (abfd)->size = core_size - (sizeof core->c_ucode) -
694 (file_ptr)(((struct core *)0)->fp_stuff);
695
696 core_stacksec (abfd)->vma = (USRSTACK - core->c_ssize);
697 core_datasec (abfd)->vma = N_DATADDR(core->c_aouthdr);
698 core_regsec (abfd)->vma = -1;
699 core_reg2sec (abfd)->vma = -1;
700
701 core_stacksec (abfd)->filepos = core->c_len + core->c_dsize;
702 core_datasec (abfd)->filepos = core->c_len;
703 /* In file header: */
704 core_regsec (abfd)->filepos = (file_ptr)(&((struct core *)0)->c_regs);
705 core_reg2sec (abfd)->filepos = (file_ptr)(((struct core *)0)->fp_stuff);
706
707 /* Align to word at least */
708 core_stacksec (abfd)->alignment_power = 2;
709 core_datasec (abfd)->alignment_power = 2;
710 core_regsec (abfd)->alignment_power = 2;
711 core_reg2sec (abfd)->alignment_power = 2;
712
713 abfd->sections = core_stacksec (abfd);
714 core_stacksec (abfd)->next = core_datasec (abfd);
715 core_datasec (abfd)->next = core_regsec (abfd);
716 core_regsec (abfd)->next = core_reg2sec (abfd);
717
718 abfd->section_count = 4;
719
720 return abfd->xvec;
721 }
722
723 char *
724 sunos4_core_file_failing_command (abfd)
725 bfd *abfd;
726 {
727 return core_hdr (abfd)->c_cmdname;
728 }
729
730 int
731 sunos4_core_file_failing_signal (abfd)
732 bfd *abfd;
733 {
734 return core_hdr (abfd)->c_signo;
735 }
736
737 boolean
738 sunos4_core_file_matches_executable_p (core_bfd, exec_bfd)
739 bfd *core_bfd, *exec_bfd;
740 {
741 if (core_bfd->xvec != exec_bfd->xvec) {
742 bfd_error = system_call_error;
743 return false;
744 }
745
746 return (bcmp ((char *)&core_hdr (core_bfd), (char*) &exec_hdr (exec_bfd),
747 sizeof (struct exec)) == 0) ? true : false;
748 }
749
750 /* byte-swap core structure */
751 /* FIXME, this needs more work to swap IN a core struct from raw bytes */
752 static void
753 swapcore (abfd, core)
754 bfd *abfd;
755 struct core *core;
756 {
757 unsigned char exec_bytes[EXEC_BYTES_SIZE];
758
759 core->c_magic = bfd_h_getlong (abfd, (unsigned char *)&core->c_magic);
760 core->c_len = bfd_h_getlong (abfd, (unsigned char *)&core->c_len );
761 /* Leave integer registers in target byte order. */
762 bcopy ((char *)&(core->c_aouthdr), (char *)exec_bytes, EXEC_BYTES_SIZE);
763 bfd_aout_swap_exec_header_in (abfd, exec_bytes, &core->c_aouthdr);
764 core->c_signo = bfd_h_getlong (abfd, (unsigned char *)&core->c_signo);
765 core->c_tsize = bfd_h_getlong (abfd, (unsigned char *)&core->c_tsize);
766 core->c_dsize = bfd_h_getlong (abfd, (unsigned char *)&core->c_dsize);
767 core->c_ssize = bfd_h_getlong (abfd, (unsigned char *)&core->c_ssize);
768 /* Leave FP registers in target byte order. */
769 /* Leave "c_ucode" unswapped for now, since we can't find it easily. */
770 }
771 \f
772 /** exec and core file sections */
773
774 boolean
775 sunos4_new_section_hook (abfd, newsect)
776 bfd *abfd;
777 asection *newsect;
778 {
779 /* align to double at least */
780 newsect->alignment_power = 3;
781
782 if (bfd_get_format (abfd) == bfd_object) {
783 if (obj_textsec(abfd) == NULL && !strcmp(newsect->name, ".text")) {
784 obj_textsec(abfd)= newsect;
785 return true;
786 }
787
788 if (obj_datasec(abfd) == NULL && !strcmp(newsect->name, ".data")) {
789 obj_datasec(abfd) = newsect;
790 return true;
791 }
792
793 if (obj_bsssec(abfd) == NULL && !strcmp(newsect->name, ".bss")) {
794 obj_bsssec(abfd) = newsect;
795 return true;
796 }
797 }
798
799 /* We allow more than three sections internally */
800 return true;
801 }
802
803 boolean
804 sunos4_set_section_contents (abfd, section, location, offset, count)
805 bfd *abfd;
806 sec_ptr section;
807 unsigned char *location;
808 file_ptr offset;
809 int count;
810 {
811 if (abfd->output_has_begun == false)
812 { /* set by bfd.c handler */
813 if ((obj_textsec (abfd) == NULL) || (obj_datasec (abfd) == NULL)
814
815 /*||
816 (obj_textsec (abfd)->size == 0) || (obj_datasec (abfd)->size=
817 0)*/
818 )
819 {
820 bfd_error = invalid_operation;
821 return false;
822 }
823
824
825 #if 0
826 if (abfd->flags & D_PAGED)
827 {
828 obj_textsec (abfd)->filepos = sizeof(struct exec);
829 obj_datasec(abfd)->filepos = obj_textsec (abfd)->size;
830 }
831 else
832 #endif
833 {
834 obj_textsec (abfd)->filepos = sizeof(struct exec);
835 obj_datasec(abfd)->filepos = obj_textsec(abfd)->filepos + obj_textsec (abfd)->size;
836
837 }
838 }
839 /* regardless, once we know what we're doing, we might as well get going */
840
841 bfd_seek (abfd, section->filepos + offset, SEEK_SET);
842
843 if (count) {
844 return (bfd_write ((void *)location, 1, count, abfd) == count) ?
845 true : false;
846 }
847 return false;
848 }
849 boolean
850 sunos4_get_section_contents (abfd, section, location, offset, count)
851 bfd *abfd;
852 sec_ptr section;
853 void *location;
854 file_ptr offset;
855 int count;
856 {
857 if (count) {
858 if (offset >= section->size) return false;
859
860 bfd_seek (abfd, section->filepos + offset, SEEK_SET);
861
862 return (bfd_read (location, 1, count, abfd) == count) ? true:false;
863 }
864 else return true;
865 }
866
867 \f
868 /* Classify stabs symbols */
869
870
871 #define sym_in_text_section(sym) \
872 (((sym)->n_type & (N_ABS | N_TEXT | N_DATA | N_BSS))== N_TEXT)
873
874 #define sym_in_data_section(sym) \
875 (((sym)->n_type & (N_ABS | N_TEXT | N_DATA | N_BSS))== N_DATA)
876
877 #define sym_in_bss_section(sym) \
878 (((sym)->n_type & (N_ABS | N_TEXT | N_DATA | N_BSS))== N_BSS)
879
880 /* Symbol is undefined if type is N_UNDF|N_EXT and if it has
881 zero in the "value" field. Nonzeroes there are fortrancommon
882 symbols. */
883 #define sym_is_undefined(sym) \
884 ((sym)->n_type == (N_UNDF | N_EXT) && (sym)->n_value == 0)
885
886 /* Symbol is a global definition if N_EXT is on and if it has
887 a nonzero type field. */
888 #define sym_is_global_defn(sym) \
889 (((sym)->n_type & N_EXT) && (sym)->n_type & N_TYPE)
890
891 /* Symbol is debugger info if any bits outside N_TYPE or N_EXT
892 are on. */
893 #define sym_is_debugger_info(sym) \
894 ((sym)->n_type & ~(N_EXT | N_TYPE))
895
896 #define sym_is_fortrancommon(sym) \
897 (((sym)->n_type == (N_EXT)) && (sym)->n_value != 0)
898
899 /* Symbol is absolute if it has N_ABS set */
900 #define sym_is_absolute(sym) \
901 (((sym)->n_type & N_TYPE)== N_ABS)
902
903
904 #define sym_is_indirect(sym) \
905 (((sym)->n_type & N_ABS)== N_ABS)
906
907 /* Only in their own functions for ease of debugging; when sym flags have
908 stabilised these should be inlined into their (single) caller */
909
910 static void
911 translate_from_native_sym_flags (sym_pointer, cache_ptr, abfd)
912 struct nlist *sym_pointer;
913 aout_symbol_type *cache_ptr;
914 bfd *abfd;
915 {
916 switch (cache_ptr->type & N_TYPE) {
917 case N_SETA:
918 case N_SETT:
919 case N_SETD:
920 case N_SETB:
921 {
922 asection *section = bfd_make_section(abfd,
923 cache_ptr->symbol.name);
924 arelent_chain *reloc = (arelent_chain *)malloc(sizeof(arelent_chain));
925
926 switch ( (cache_ptr->type & N_TYPE) ) {
927 case N_SETA:
928 reloc->relent.section = (asection *)NULL;
929 cache_ptr->symbol.section = (asection *)NULL;
930 break;
931 case N_SETT:
932 reloc->relent.section = (asection *)obj_textsec(abfd);
933 cache_ptr->symbol.value -= reloc->relent.section->vma;
934 break;
935 case N_SETD:
936 reloc->relent.section = (asection *)obj_datasec(abfd);
937 cache_ptr->symbol.value -= reloc->relent.section->vma;
938 break;
939 case N_SETB:
940 reloc->relent.section = (asection *)obj_bsssec(abfd);
941 cache_ptr->symbol.value -= reloc->relent.section->vma;
942 break;
943 }
944 cache_ptr->symbol.section = reloc->relent.section;
945 reloc->relent.addend = cache_ptr->symbol.value ;
946 /*
947 We modify the symbol to belong to a section depending upon the
948 name of the symbol - probably __CTOR__ or __DTOR__ but we don't
949 really care, and add to the size of the section to contain a
950 pointer to the symbol. Build a reloc entry to relocate to this
951 symbol attached to this section.
952 */
953
954
955 section->flags = SEC_CONSTRUCTOR;
956 section->reloc_count++;
957 section->alignment_power = 2;
958 reloc->relent.sym_ptr_ptr = (asymbol **)NULL;
959 reloc->next = section->constructor_chain;
960 section->constructor_chain = reloc;
961 reloc->relent.address = section->size;
962 section->size += sizeof(int *);
963
964 reloc->relent.howto = howto_table_ext +CTOR_TABLE_RELOC_IDX;
965 cache_ptr->symbol.flags |= BSF_DEBUGGING ;
966 }
967 break;
968 default:
969
970 if (sym_is_debugger_info (sym_pointer)) {
971 cache_ptr->symbol.flags = BSF_DEBUGGING ;
972 /* Work out the section correct for this symbol */
973 switch (sym_pointer->n_type & N_TYPE)
974 {
975 case N_TEXT:
976 case N_FN:
977 cache_ptr->symbol.section = obj_textsec (abfd);
978 cache_ptr->symbol.value -= obj_textsec(abfd)->vma;
979 break;
980 case N_DATA:
981 cache_ptr->symbol.value -= obj_datasec(abfd)->vma;
982 cache_ptr->symbol.section = obj_datasec (abfd);
983 break;
984 case N_BSS :
985 cache_ptr->symbol.section = obj_bsssec (abfd);
986 cache_ptr->symbol.value -= obj_bsssec(abfd)->vma;
987 break;
988 case N_ABS:
989 default:
990 cache_ptr->symbol.section = 0;
991 break;
992 }
993 }
994 else {
995 if (sym_is_fortrancommon (sym_pointer))
996 {
997 cache_ptr->symbol.flags = BSF_FORT_COMM;
998 cache_ptr->symbol.section = (asection *)NULL;
999 }
1000 else {
1001 if (sym_is_undefined (sym_pointer)) {
1002 cache_ptr->symbol.flags = BSF_UNDEFINED;
1003 }
1004 else if (sym_is_global_defn (sym_pointer)) {
1005 cache_ptr->symbol.flags = BSF_GLOBAL | BSF_EXPORT;
1006 }
1007
1008 else if (sym_is_absolute (sym_pointer)) {
1009 cache_ptr->symbol.flags = BSF_ABSOLUTE;
1010 }
1011 else {
1012 cache_ptr->symbol.flags = BSF_LOCAL;
1013 }
1014
1015 /* In a.out, the value of a symbol is always relative to the
1016 * start of the file, if this is a data symbol we'll subtract
1017 * the size of the text section to get the section relative
1018 * value. If this is a bss symbol (which would be strange)
1019 * we'll subtract the size of the previous two sections
1020 * to find the section relative address.
1021 */
1022
1023 if (sym_in_text_section (sym_pointer)) {
1024 cache_ptr->symbol.value -= obj_textsec(abfd)->vma;
1025 cache_ptr->symbol.section = obj_textsec (abfd);
1026 }
1027 else if (sym_in_data_section (sym_pointer)){
1028 cache_ptr->symbol.value -= obj_datasec(abfd)->vma;
1029 cache_ptr->symbol.section = obj_datasec (abfd);
1030 }
1031 else if (sym_in_bss_section(sym_pointer)) {
1032 cache_ptr->symbol.section = obj_bsssec (abfd);
1033 cache_ptr->symbol.value -= obj_bsssec(abfd)->vma;
1034 }
1035 else {
1036 cache_ptr->symbol.section = (asection *)NULL;
1037 cache_ptr->symbol.flags |= BSF_ABSOLUTE;
1038 }
1039 }
1040 }
1041 }
1042 }
1043
1044 void
1045 translate_to_native_sym_flags (sym_pointer, cache_ptr_g, abfd)
1046 struct nlist *sym_pointer;
1047 generic_symbol_type *cache_ptr_g;
1048 bfd *abfd;
1049 {
1050 asymbol *cache_ptr = (asymbol *)cache_ptr_g;
1051
1052 /* FIXME check for wrigin bss */
1053 if (bfd_get_section(cache_ptr)) {
1054 if (bfd_get_output_section(cache_ptr) == obj_bsssec (abfd)) {
1055 sym_pointer->n_type |= N_BSS;
1056 }
1057 else if (bfd_get_output_section(cache_ptr) == obj_datasec (abfd)) {
1058 sym_pointer->n_type |= N_DATA;
1059 }
1060 else if (bfd_get_output_section(cache_ptr) == obj_textsec (abfd)) {
1061 sym_pointer->n_type |= N_TEXT;
1062 }
1063 else {
1064
1065 bfd_error_vector.nonrepresentable_section(abfd, bfd_get_output_section(cache_ptr)->name);
1066
1067 }
1068 /* Turn the symbol from section relative to absolute again */
1069 sym_pointer->n_value +=
1070 cache_ptr->section->output_section->vma
1071 + cache_ptr->section->output_offset ;
1072 }
1073 else {
1074 sym_pointer->n_type |= N_ABS;
1075 }
1076
1077 if (cache_ptr->flags & (BSF_FORT_COMM | BSF_UNDEFINED)) {
1078 sym_pointer->n_type = (N_UNDF | N_EXT);
1079 return;
1080 }
1081
1082 if (cache_ptr->flags & BSF_ABSOLUTE) {
1083 sym_pointer->n_type |= N_ABS;
1084 }
1085
1086 if (cache_ptr->flags & (BSF_GLOBAL | BSF_EXPORT)) {
1087 sym_pointer->n_type |= N_EXT;
1088 }
1089 if (cache_ptr->flags & BSF_DEBUGGING) {
1090 sym_pointer->n_type = ((aout_symbol_type *)cache_ptr)->type;
1091 }
1092
1093 }
1094 \f
1095 /* Native-level interface to symbols. */
1096
1097 /* We read the symbols into a buffer, which is discarded when this
1098 function exits. We read the strings into a buffer large enough to
1099 hold them all plus all the cached symbol entries. */
1100
1101 asymbol *
1102 sunos4_make_empty_symbol (abfd)
1103 bfd *abfd;
1104 {
1105 aout_symbol_type *new =
1106 (aout_symbol_type *)zalloc (sizeof (aout_symbol_type));
1107 new->symbol.the_bfd = abfd;
1108
1109 return &new->symbol;
1110 }
1111
1112 boolean
1113 DEFUN(sunos4_slurp_symbol_table, (abfd),
1114 bfd *abfd)
1115 {
1116 unsigned int symbol_count;
1117 size_t symbol_size;
1118 size_t string_size;
1119 struct nlist *syms;
1120 char *strings;
1121 aout_symbol_type *cached;
1122
1123 /* If there's no work to be done, don't do any */
1124 if (obj_aout_symbols (abfd) != (aout_symbol_type *)NULL) return true;
1125 symbol_size = exec_hdr(abfd)->a_syms;
1126 if (symbol_size == 0) {
1127 bfd_error = no_symbols;
1128 return false;
1129 }
1130
1131 bfd_seek (abfd, obj_str_filepos (abfd), SEEK_SET);
1132 if (bfd_read ((void *)&string_size, 4, 1, abfd) != 4)
1133 return false;
1134 string_size = bfd_h_getlong (abfd, (unsigned char *)&string_size);
1135
1136 symbol_count = symbol_size / sizeof (struct nlist);
1137
1138 /* Malloc (should alloca) space for native symbols, and
1139 malloc space for string table and symbol cache. */
1140
1141 syms = (struct nlist *) zalloc (symbol_size);
1142 if (syms == NULL) {
1143 bfd_error = no_memory;
1144 return false;
1145 }
1146
1147 cached = (aout_symbol_type *) zalloc ((size_t)(string_size + 1 +
1148 (symbol_count * sizeof (aout_symbol_type))));
1149 if (cached == NULL) {
1150 bfd_error = no_memory;
1151 free ((void *)syms);
1152 return false;
1153 }
1154
1155 strings = ((char *) cached) + (symbol_count * sizeof (aout_symbol_type));
1156
1157 bfd_seek (abfd, obj_sym_filepos (abfd), SEEK_SET);
1158 if (bfd_read ((void *)syms, 1, symbol_size, abfd) != symbol_size) {
1159 bailout:
1160 free ((void *)cached);
1161 free ((void*)syms);
1162 return false;
1163 }
1164
1165 bfd_seek (abfd, obj_str_filepos (abfd), SEEK_SET);
1166 if (bfd_read ((void *)strings, 1, string_size, abfd) != string_size) {
1167 goto bailout;
1168 }
1169
1170 /* OK, now walk the new symtable, cacheing symbol properties */
1171 {
1172 register struct nlist *sym_pointer;
1173 register struct nlist *sym_end = syms + symbol_count;
1174 register aout_symbol_type *cache_ptr = cached;
1175
1176 /* run through the table and byte swap if needed */
1177 for (sym_pointer = syms; sym_pointer < sym_end; sym_pointer++) {
1178 sym_pointer->n_un.n_strx =
1179 bfd_h_get_x (abfd, &sym_pointer->n_un.n_strx);
1180 sym_pointer->n_desc =
1181 bfd_h_get_x (abfd, &sym_pointer->n_desc);
1182 sym_pointer->n_value =
1183 bfd_h_get_x (abfd, &sym_pointer->n_value);
1184 sym_pointer->n_other = (char)
1185 bfd_h_get_x(abfd, &sym_pointer->n_other);
1186 sym_pointer->n_type = (char)
1187 bfd_h_get_x(abfd, &sym_pointer->n_type);
1188
1189 }
1190
1191 /* Run through table and copy values */
1192 for (sym_pointer = syms, cache_ptr = cached;
1193 sym_pointer < sym_end; sym_pointer++, cache_ptr++)
1194 {
1195 cache_ptr->symbol.the_bfd = abfd;
1196 if (sym_pointer->n_un.n_strx)
1197 cache_ptr->symbol.name = sym_pointer->n_un.n_strx + strings;
1198 else
1199 cache_ptr->symbol.name = (char *)NULL;
1200 cache_ptr->symbol.value = sym_pointer->n_value;
1201 cache_ptr->desc = sym_pointer->n_desc;
1202 cache_ptr->other = sym_pointer->n_other;
1203 cache_ptr->type = sym_pointer->n_type;
1204 cache_ptr->symbol.udata = 0;
1205 translate_from_native_sym_flags (sym_pointer, cache_ptr, abfd);
1206
1207 }
1208 }
1209
1210 obj_aout_symbols (abfd) = cached;
1211 bfd_get_symcount (abfd) = symbol_count;
1212 free ((void *)syms);
1213
1214 return true;
1215 }
1216
1217
1218 void
1219 DEFUN(sunos4_write_syms,(abfd),
1220 bfd *abfd)
1221 {
1222 unsigned int count ;
1223 asymbol **generic = bfd_get_outsymbols (abfd);
1224
1225 unsigned int stindex = sizeof(stindex); /* initial string length */
1226
1227 for (count = 0; count < bfd_get_symcount (abfd); count++) {
1228 asymbol *g = generic[count];
1229 struct nlist nsp;
1230
1231 if (g->name) {
1232 unsigned int length = strlen(g->name) +1;
1233 bfd_h_putlong (abfd, stindex, (unsigned char *)&nsp.n_un.n_strx);
1234 stindex += length;
1235 }
1236 else {
1237 bfd_h_putlong (abfd, 0, (unsigned char *)&nsp.n_un.n_strx);
1238 }
1239
1240 if (g->the_bfd->xvec->flavour == abfd->xvec->flavour)
1241 {
1242 nsp.n_desc = aout_symbol( g)->desc;
1243 nsp.n_other = aout_symbol(g)->other;
1244 nsp.n_type = aout_symbol(g)->type;
1245 }
1246 else
1247 {
1248 nsp.n_desc = 0;
1249 nsp.n_other = 0;
1250 nsp.n_type = 0;
1251 }
1252
1253
1254 nsp.n_value = g->value;
1255 translate_to_native_sym_flags (&nsp, (generic_symbol_type *)g, abfd);
1256
1257
1258 bfd_h_putshort (abfd, nsp.n_desc, (unsigned char *)&nsp.n_desc);
1259 bfd_h_putlong (abfd, nsp.n_value, (unsigned char *)&nsp.n_value);
1260 bfd_write((void *)&nsp,1, sizeof(nsp), abfd);
1261 }
1262
1263
1264 /* Now output the strings. Be sure to put string length into correct
1265 * byte ordering before writing it.
1266 */
1267 bfd_h_putlong (abfd, stindex, (unsigned char *)&stindex);
1268
1269 bfd_write((void *)&stindex, 1, sizeof(stindex), abfd);
1270
1271 generic = bfd_get_outsymbols(abfd);
1272 for (count = 0; count < bfd_get_symcount(abfd); count++)
1273 {
1274 asymbol *g = *(generic++);
1275
1276 if (g->name != (char *)NULL)
1277 {
1278 size_t length = strlen(g->name)+1;
1279 bfd_write((void *)g->name, 1, length, abfd);
1280 }
1281 if ((g->flags & BSF_FAKE)==0) {
1282 g->name = itos(count); /* smash the generic symbol */
1283 }
1284 }
1285 }
1286
1287
1288 void
1289 DEFUN(sunos4_reclaim_symbol_table,(abfd),
1290 bfd *abfd)
1291 {
1292 asection *section;
1293
1294 if (!bfd_get_symcount (abfd)) return;
1295
1296 for (section = abfd->sections;
1297 section != (asection *) NULL;
1298 section = section->next)
1299 if (section->relocation) {
1300 free ((void *)section->relocation);
1301 section->relocation = NULL;
1302 section->reloc_count = 0;
1303 }
1304
1305 bfd_get_symcount (abfd) = 0;
1306 free ((void *)obj_aout_symbols (abfd));
1307 obj_aout_symbols (abfd) = (aout_symbol_type *)NULL;
1308 }
1309 \f
1310 unsigned int
1311 sunos4_get_symtab_upper_bound (abfd)
1312 bfd *abfd;
1313 {
1314 if (!sunos4_slurp_symbol_table (abfd)) return 0;
1315
1316 return (bfd_get_symcount (abfd)+1) * (sizeof (aout_symbol_type *));
1317 }
1318
1319 unsigned int
1320 sunos4_get_symtab (abfd, location)
1321 bfd *abfd;
1322 asymbol **location;
1323 {
1324 unsigned int counter = 0;
1325 aout_symbol_type *symbase;
1326
1327 if (!sunos4_slurp_symbol_table (abfd)) return 0;
1328
1329 for (symbase = obj_aout_symbols(abfd); counter++ < bfd_get_symcount (abfd);)
1330 *(location++) = (asymbol *)( symbase++);
1331 *location++ =0;
1332 return bfd_get_symcount(abfd);
1333 }
1334
1335 \f
1336 /* Obsolete procedural interface; better to look at the cache directly */
1337
1338 /* User should have checked the file flags; perhaps we should return
1339 BFD_NO_MORE_SYMBOLS if there are none? */
1340
1341 int
1342 sunos4_get_symcount_upper_bound (abfd)
1343 bfd *abfd;
1344 {
1345 /* In case we're doing an output file or something...? */
1346 if (bfd_get_symcount (abfd)) return bfd_get_symcount (abfd);
1347
1348 return (exec_hdr (abfd)->a_syms) / (sizeof (struct nlist));
1349 }
1350
1351 symindex
1352 sunos4_get_first_symbol (ignore_abfd)
1353 bfd * ignore_abfd;
1354 {
1355 return 0;
1356 }
1357
1358 symindex
1359 sunos4_get_next_symbol (abfd, oidx)
1360 bfd *abfd;
1361 symindex oidx;
1362 {
1363 if (oidx == BFD_NO_MORE_SYMBOLS) return BFD_NO_MORE_SYMBOLS;
1364 return ++oidx >= bfd_get_symcount (abfd) ? BFD_NO_MORE_SYMBOLS : oidx;
1365 }
1366
1367 char *
1368 sunos4_symbol_name (abfd, idx)
1369 bfd *abfd;
1370 symindex idx;
1371 {
1372 return (obj_aout_symbols (abfd) + idx)->symbol.name;
1373 }
1374
1375 long
1376 sunos4_symbol_value (abfd, idx)
1377 bfd *abfd;
1378 symindex idx;
1379 {
1380 return (obj_aout_symbols (abfd) + idx)->symbol.value;
1381 }
1382
1383 symclass
1384 sunos4_classify_symbol (abfd, idx)
1385 bfd *abfd;
1386 symindex idx;
1387 {
1388 aout_symbol_type *sym = obj_aout_symbols (abfd) + idx;
1389
1390 if ((sym->symbol.flags & BSF_FORT_COMM) != 0) return bfd_symclass_fcommon;
1391 if ((sym->symbol.flags & BSF_GLOBAL) != 0) return bfd_symclass_global;
1392 if ((sym->symbol.flags & BSF_DEBUGGING) != 0) return bfd_symclass_debugger;
1393 if ((sym->symbol.flags & BSF_UNDEFINED) != 0) return bfd_symclass_undefined;
1394
1395 return bfd_symclass_unknown;
1396 }
1397
1398 boolean
1399 sunos4_symbol_hasclass (abfd, idx, class)
1400 bfd *abfd;
1401 symindex idx;
1402 symclass class;
1403 {
1404 aout_symbol_type *sym = obj_aout_symbols (abfd) + idx;
1405 switch (class) {
1406 case bfd_symclass_fcommon:
1407 return (sym->symbol.flags & BSF_FORT_COMM) ? true :false;
1408 case bfd_symclass_global:
1409 return (sym->symbol.flags & BSF_GLOBAL) ? true:false;
1410 case bfd_symclass_debugger:
1411 return (sym->symbol.flags & BSF_DEBUGGING) ? true:false;;
1412 case bfd_symclass_undefined:
1413 return (sym->symbol.flags & BSF_UNDEFINED) ? true:false;;
1414 default: return false;
1415 }
1416 }
1417 \f
1418 /* Standard reloc stuff */
1419 /* Output standard relocation information to a file in target byte order. */
1420
1421 void
1422 swap_std_reloc_out (abfd, p, natptr, count)
1423 bfd *abfd;
1424 arelent **p; /* Generic relocation struct */
1425 struct reloc_std_bytes *natptr;
1426 unsigned int count;
1427 {
1428 int r_index;
1429 int r_extern;
1430 unsigned int r_length;
1431 int r_pcrel;
1432 int r_baserel, r_jmptable, r_relative;
1433 unsigned int r_addend;
1434 unsigned int idx;
1435 for (idx = 0; idx < count; idx++, p++, natptr++)
1436 {
1437 arelent *g = *p;
1438 bfd_h_putlong (abfd, g->address, natptr->r_address);
1439
1440 r_length = g->howto->size; /* Size as a power of two */
1441 r_pcrel = g->howto->pc_relative; /* Relative to PC? */
1442 /* r_baserel, r_jmptable, r_relative??? FIXME-soon */
1443 r_baserel = 0;
1444 r_jmptable = 0;
1445 r_relative = 0;
1446
1447 r_addend = g->addend; /* Start here, see how it goes */
1448
1449 /* name was clobbered by sunos4_write_syms to be symbol index */
1450
1451 if (g->sym_ptr_ptr != NULL)
1452 {
1453 if ((*(g->sym_ptr_ptr))->section) {
1454 /* put the section offset into the addend for output */
1455 r_addend += (*(g->sym_ptr_ptr))->section->vma;
1456 }
1457
1458 r_index = stoi((*(g->sym_ptr_ptr))->name);
1459 r_extern = 1;
1460 }
1461 else {
1462 r_extern = 0;
1463 if (g->section == NULL) {
1464 BFD_ASSERT(0);
1465 r_index = N_ABS | N_EXT;
1466 }
1467 else if(g->section->output_section == obj_textsec(abfd)) {
1468 r_index = N_TEXT | N_EXT;
1469 r_addend += g->section->output_section->vma;
1470 }
1471 else if (g->section->output_section == obj_datasec(abfd)) {
1472 r_index = N_DATA | N_EXT;
1473 r_addend += g->section->output_section->vma;
1474 }
1475 else if (g->section->output_section == obj_bsssec(abfd)) {
1476 r_index = N_BSS | N_EXT ;
1477 r_addend += g->section->output_section->vma;
1478 }
1479 else {
1480 BFD_ASSERT(0);
1481 }
1482 }
1483
1484 /* now the fun stuff */
1485 if (abfd->xvec->header_byteorder_big_p != false) {
1486 natptr->r_index[0] = r_index >> 16;
1487 natptr->r_index[1] = r_index >> 8;
1488 natptr->r_index[2] = r_index;
1489 natptr->r_bits[0] =
1490 (r_extern? RELOC_STD_BITS_EXTERN_BIG: 0)
1491 | (r_pcrel? RELOC_STD_BITS_PCREL_BIG: 0)
1492 | (r_baserel? RELOC_STD_BITS_BASEREL_BIG: 0)
1493 | (r_jmptable? RELOC_STD_BITS_JMPTABLE_BIG: 0)
1494 | (r_relative? RELOC_STD_BITS_RELATIVE_BIG: 0)
1495 | (r_length << RELOC_STD_BITS_LENGTH_SH_BIG);
1496 } else {
1497 natptr->r_index[2] = r_index >> 16;
1498 natptr->r_index[1] = r_index >> 8;
1499 natptr->r_index[0] = r_index;
1500 natptr->r_bits[0] =
1501 (r_extern? RELOC_STD_BITS_EXTERN_LITTLE: 0)
1502 | (r_pcrel? RELOC_STD_BITS_PCREL_LITTLE: 0)
1503 | (r_baserel? RELOC_STD_BITS_BASEREL_LITTLE: 0)
1504 | (r_jmptable? RELOC_STD_BITS_JMPTABLE_LITTLE: 0)
1505 | (r_relative? RELOC_STD_BITS_RELATIVE_LITTLE: 0)
1506 | (r_length << RELOC_STD_BITS_LENGTH_SH_LITTLE);
1507 }
1508
1509
1510 }
1511 }
1512
1513
1514 /* Extended stuff */
1515 /* Output extended relocation information to a file in target byte order. */
1516
1517 void
1518 swap_ext_reloc_out (abfd, p, natptr, count)
1519 bfd *abfd;
1520 arelent **p; /* Generic relocation struct */
1521 register struct reloc_ext_bytes *natptr;
1522 unsigned int count;
1523 {
1524
1525 int r_index;
1526 int r_extern;
1527 unsigned int r_type;
1528 unsigned int r_addend;
1529 unsigned int idx;
1530 for (idx = 0; idx < count; idx++, p++, natptr++) {
1531 arelent *g = *p;
1532
1533 bfd_h_putlong (abfd, g->address, natptr->r_address);
1534
1535 /* Find a type in the output format which matches the input howto -
1536 at the moment we assume input format == output format FIXME!! */
1537 r_type = (enum reloc_type) g->howto->type;
1538
1539 r_addend = g->addend; /* Start here, see how it goes */
1540
1541 /* name was clobbered by sunos4_write_syms to be symbol index*/
1542
1543 if (g->sym_ptr_ptr != NULL)
1544 {
1545 if ((*(g->sym_ptr_ptr))->section) {
1546 /* put the section offset into the addend for output */
1547 r_addend += (*(g->sym_ptr_ptr))->section->vma;
1548 }
1549
1550 r_index = stoi((*(g->sym_ptr_ptr))->name);
1551 r_extern = 1;
1552 }
1553 else {
1554 r_extern = 0;
1555 if (g->section == NULL) {
1556 BFD_ASSERT(0);
1557 r_index = N_ABS | N_EXT;
1558 }
1559 else if(g->section->output_section == obj_textsec(abfd)) {
1560 r_index = N_TEXT | N_EXT;
1561 r_addend += g->section->output_section->vma;
1562 }
1563 else if (g->section->output_section == obj_datasec(abfd)) {
1564 r_index = N_DATA | N_EXT;
1565 r_addend += g->section->output_section->vma;
1566 }
1567 else if (g->section->output_section == obj_bsssec(abfd)) {
1568 r_index = N_BSS | N_EXT ;
1569 r_addend += g->section->output_section->vma;
1570 }
1571 else {
1572 BFD_ASSERT(0);
1573 }
1574 }
1575
1576 /* now the fun stuff */
1577 if (abfd->xvec->header_byteorder_big_p != false) {
1578 natptr->r_index[0] = r_index >> 16;
1579 natptr->r_index[1] = r_index >> 8;
1580 natptr->r_index[2] = r_index;
1581 natptr->r_bits[0] =
1582 (r_extern? RELOC_EXT_BITS_EXTERN_BIG: 0)
1583 || (r_type << RELOC_EXT_BITS_TYPE_SH_BIG);
1584 } else {
1585 natptr->r_index[2] = r_index >> 16;
1586 natptr->r_index[1] = r_index >> 8;
1587 natptr->r_index[0] = r_index;
1588 natptr->r_bits[0] =
1589 (r_extern? RELOC_EXT_BITS_EXTERN_LITTLE: 0)
1590 || (r_type << RELOC_EXT_BITS_TYPE_SH_LITTLE);
1591 }
1592
1593 bfd_h_putlong (abfd, r_addend, natptr->r_addend);
1594 }
1595 }
1596 #define MOVE_ADDRESS(ad) \
1597 if (r_extern) { \
1598 cache_ptr->sym_ptr_ptr = symbols + r_index; \
1599 cache_ptr->section = (asection *)NULL; \
1600 cache_ptr->addend = ad; \
1601 } else { \
1602 cache_ptr->sym_ptr_ptr = (asymbol **)NULL; \
1603 switch (r_index) { \
1604 case N_TEXT: \
1605 case N_TEXT | N_EXT: \
1606 cache_ptr->section = obj_textsec(abfd); \
1607 cache_ptr->addend = ad - su->textsec->vma; \
1608 break; \
1609 case N_DATA: \
1610 case N_DATA | N_EXT: \
1611 cache_ptr->section = obj_datasec(abfd); \
1612 cache_ptr->addend = ad - su->datasec->vma; \
1613 break; \
1614 case N_BSS: \
1615 case N_BSS | N_EXT: \
1616 cache_ptr->section = obj_bsssec(abfd); \
1617 cache_ptr->addend = ad - su->bsssec->vma; \
1618 break; \
1619 case N_ABS: \
1620 case N_ABS | N_EXT: \
1621 BFD_ASSERT(1); \
1622 break; \
1623 default: \
1624 BFD_ASSERT(1); \
1625 break; \
1626 } \
1627 } \
1628
1629 void
1630 swap_ext_reloc_in (abfd, bytes, cache_ptr, symbols)
1631 bfd *abfd;
1632 struct reloc_ext_bytes *bytes;
1633 arelent *cache_ptr;
1634 asymbol **symbols;
1635 {
1636 int r_index;
1637 int r_extern;
1638 unsigned int r_type;
1639 struct sunexdata *su = (struct sunexdata *)(abfd->tdata);
1640
1641 cache_ptr->address = bfd_h_getlong (abfd, bytes->r_address);
1642
1643 /* now the fun stuff */
1644 if (abfd->xvec->header_byteorder_big_p != false) {
1645 r_index = (bytes->r_index[0] << 16)
1646 | (bytes->r_index[1] << 8)
1647 | bytes->r_index[2];
1648 r_extern = (0 != (bytes->r_bits[0] & RELOC_EXT_BITS_EXTERN_BIG));
1649 r_type = (bytes->r_bits[0] & RELOC_EXT_BITS_TYPE_BIG)
1650 >> RELOC_EXT_BITS_TYPE_SH_BIG;
1651 } else {
1652 r_index = (bytes->r_index[2] << 16)
1653 | (bytes->r_index[1] << 8)
1654 | bytes->r_index[0];
1655 r_extern = (0 != (bytes->r_bits[0] & RELOC_EXT_BITS_EXTERN_LITTLE));
1656 r_type = (bytes->r_bits[0] & RELOC_EXT_BITS_TYPE_LITTLE)
1657 >> RELOC_EXT_BITS_TYPE_SH_LITTLE;
1658 }
1659
1660 cache_ptr->howto = howto_table_ext + r_type;
1661 MOVE_ADDRESS(bfd_h_getlong(abfd,bytes->r_addend));
1662
1663 }
1664
1665 void
1666 swap_std_reloc_in (abfd, bytes, cache_ptr, symbols)
1667 bfd *abfd;
1668 struct reloc_std_bytes *bytes;
1669 arelent *cache_ptr;
1670 asymbol **symbols;
1671 {
1672 int r_index;
1673 int r_extern;
1674 unsigned int r_length;
1675 int r_pcrel;
1676 int r_baserel, r_jmptable, r_relative;
1677 struct sunexdata *su = (struct sunexdata *)(abfd->tdata);
1678 cache_ptr->address = bfd_h_getlong (abfd, bytes->r_address);
1679
1680 /* now the fun stuff */
1681 if (abfd->xvec->header_byteorder_big_p != false) {
1682 r_index = (bytes->r_index[0] << 16)
1683 | (bytes->r_index[1] << 8)
1684 | bytes->r_index[2];
1685 r_extern = (0 != (bytes->r_bits[0] & RELOC_STD_BITS_EXTERN_BIG));
1686 r_pcrel = (0 != (bytes->r_bits[0] & RELOC_STD_BITS_PCREL_BIG));
1687 r_baserel = (0 != (bytes->r_bits[0] & RELOC_STD_BITS_BASEREL_BIG));
1688 r_jmptable= (0 != (bytes->r_bits[0] & RELOC_STD_BITS_JMPTABLE_BIG));
1689 r_relative= (0 != (bytes->r_bits[0] & RELOC_STD_BITS_RELATIVE_BIG));
1690 r_length = (bytes->r_bits[0] & RELOC_STD_BITS_LENGTH_BIG)
1691 >> RELOC_STD_BITS_LENGTH_SH_BIG;
1692 } else {
1693 r_index = (bytes->r_index[2] << 16)
1694 | (bytes->r_index[1] << 8)
1695 | bytes->r_index[0];
1696 r_extern = (0 != (bytes->r_bits[0] & RELOC_STD_BITS_EXTERN_LITTLE));
1697 r_pcrel = (0 != (bytes->r_bits[0] & RELOC_STD_BITS_PCREL_LITTLE));
1698 r_baserel = (0 != (bytes->r_bits[0] & RELOC_STD_BITS_BASEREL_LITTLE));
1699 r_jmptable= (0 != (bytes->r_bits[0] & RELOC_STD_BITS_JMPTABLE_LITTLE));
1700 r_relative= (0 != (bytes->r_bits[0] & RELOC_STD_BITS_RELATIVE_LITTLE));
1701 r_length = (bytes->r_bits[0] & RELOC_STD_BITS_LENGTH_LITTLE)
1702 >> RELOC_STD_BITS_LENGTH_SH_LITTLE;
1703 }
1704
1705 cache_ptr->howto = howto_table_std + r_length + 4 * r_pcrel;
1706 /* FIXME-soon: Roll baserel, jmptable, relative bits into howto setting */
1707
1708 MOVE_ADDRESS(0);
1709 }
1710
1711 /* Reloc hackery */
1712
1713 boolean
1714 sunos4_slurp_reloc_table (abfd, asect, symbols)
1715 bfd *abfd;
1716 sec_ptr asect;
1717 asymbol **symbols;
1718 {
1719 unsigned int count;
1720 size_t reloc_size;
1721 void *relocs;
1722 arelent *reloc_cache;
1723 size_t each_size;
1724
1725 if (asect->relocation) return true;
1726
1727 if (asect->flags & SEC_CONSTRUCTOR) return true;
1728
1729 if (asect == obj_datasec (abfd)) {
1730 reloc_size = exec_hdr(abfd)->a_drsize;
1731 goto doit;
1732 }
1733
1734 if (asect == obj_textsec (abfd)) {
1735 reloc_size = exec_hdr(abfd)->a_trsize;
1736 goto doit;
1737 }
1738
1739 bfd_error = invalid_operation;
1740 return false;
1741
1742 doit:
1743 bfd_seek (abfd, asect->rel_filepos, SEEK_SET);
1744 each_size = reloc_size_func(abfd);
1745
1746 count = reloc_size / each_size;
1747
1748 relocs = malloc (reloc_size);
1749 if (!relocs) {
1750 bfd_error = no_memory;
1751 return false;
1752 }
1753 reloc_cache = (arelent *) zalloc ((size_t)(count * sizeof (arelent)));
1754 if (reloc_cache == (arelent *)NULL) {
1755 free (relocs);
1756 bfd_error = no_memory;
1757 return false;
1758 }
1759
1760 if (bfd_read ( relocs, 1, reloc_size, abfd) != reloc_size) {
1761 bfd_error = system_call_error;
1762 free (reloc_cache);
1763 free (relocs);
1764 return false;
1765 }
1766
1767 if (each_size == RELOC_EXT_SIZE)
1768 {
1769 register struct reloc_ext_bytes *rptr = relocs;
1770 unsigned int counter = 0;
1771 arelent *cache_ptr = reloc_cache;
1772
1773 for (; counter < count; counter++, rptr++, cache_ptr++) {
1774 swap_ext_reloc_in(abfd, rptr, cache_ptr, symbols);
1775 }
1776 }
1777 else {
1778 register struct reloc_std_bytes *rptr = relocs;
1779 unsigned int counter = 0;
1780 arelent *cache_ptr = reloc_cache;
1781
1782 for (; counter < count; counter++, rptr++, cache_ptr++) {
1783 swap_std_reloc_in(abfd, rptr, cache_ptr, symbols);
1784 }
1785
1786 }
1787 free (relocs);
1788 asect->relocation = reloc_cache;
1789 asect->reloc_count = count;
1790 return true;
1791 }
1792
1793
1794
1795 /* Write out a relocation section into an object file. */
1796
1797 static boolean
1798 sunos4_squirt_out_relocs (abfd, section)
1799 bfd *abfd;
1800 asection *section;
1801 {
1802 arelent **generic;
1803 unsigned char *native;
1804 size_t each_size;
1805
1806 unsigned int count = section->reloc_count;
1807 size_t natsize;
1808
1809 if (count == 0) return true;
1810
1811 each_size = reloc_size_func(abfd);
1812 natsize = each_size * count;
1813 native = (unsigned char *) zalloc (natsize);
1814 if (!native) {
1815 bfd_error = no_memory;
1816 return false;
1817 }
1818
1819 generic = section->orelocation;
1820
1821 if (each_size == RELOC_EXT_SIZE)
1822 {
1823 swap_ext_reloc_out (abfd,
1824 generic,
1825 (struct reloc_ext_bytes *)native,
1826 count);
1827 }
1828 else
1829 {
1830 swap_std_reloc_out(abfd, generic, native, count);
1831 }
1832
1833 if ( bfd_write ((void *) native, 1, natsize, abfd) != natsize) {
1834 free(native);
1835 return false;
1836 }
1837 free (native);
1838
1839 return true;
1840 }
1841
1842 /* This is stupid. This function should be a boolean predicate */
1843 unsigned int
1844 sunos4_canonicalize_reloc (abfd, section, relptr, symbols)
1845 bfd *abfd;
1846 sec_ptr section;
1847 arelent **relptr;
1848 asymbol **symbols;
1849 {
1850 arelent *tblptr = section->relocation;
1851 unsigned int count;
1852
1853 if (!(tblptr || sunos4_slurp_reloc_table (abfd, section, symbols)))
1854 return 0;
1855
1856 if (section->flags & SEC_CONSTRUCTOR) {
1857 arelent_chain *chain = section->constructor_chain;
1858 for (count = 0; count < section->reloc_count; count ++) {
1859 *relptr ++ = &chain->relent;
1860 chain = chain->next;
1861 }
1862 }
1863 else {
1864 tblptr = section->relocation;
1865 if (!tblptr) return 0;
1866
1867 for (count = 0; count++ < section->reloc_count;)
1868 {
1869 *relptr++ = tblptr++;
1870 }
1871 }
1872 *relptr = 0;
1873
1874 return section->reloc_count;
1875 }
1876
1877 unsigned int
1878 sunos4_get_reloc_upper_bound (abfd, asect)
1879 bfd *abfd;
1880 sec_ptr asect;
1881 {
1882 if (bfd_get_format (abfd) != bfd_object) {
1883 bfd_error = invalid_operation;
1884 return 0;
1885 }
1886 if (asect->flags & SEC_CONSTRUCTOR) {
1887 return (sizeof (arelent *) * (asect->reloc_count+1));
1888 }
1889
1890
1891 if (asect == obj_datasec (abfd))
1892 return (sizeof (arelent *) *
1893 ((exec_hdr(abfd)->a_drsize / reloc_size_func(abfd))
1894 +1));
1895
1896 if (asect == obj_textsec (abfd))
1897 return (sizeof (arelent *) *
1898 ((exec_hdr(abfd)->a_trsize / reloc_size_func(abfd))
1899 +1));
1900
1901 bfd_error = invalid_operation;
1902 return 0;
1903 }
1904
1905 void
1906 sunos4_reclaim_reloc (ignore_abfd, section)
1907 bfd *ignore_abfd;
1908 sec_ptr section;
1909 {
1910 if (section->relocation) {
1911 free (section->relocation);
1912 section->relocation = NULL;
1913 section->reloc_count = 0;
1914 }
1915 }
1916 \f
1917
1918 alent *
1919 sunos4_get_lineno(ignore_abfd, ignore_symbol)
1920 bfd *ignore_abfd;
1921 generic_symbol_type *ignore_symbol;
1922 {
1923 return (alent *)NULL;
1924 }
1925
1926 void
1927 sunos4_print_symbol(ignore_abfd, file, symbol, how)
1928 bfd *ignore_abfd;
1929 FILE *file;
1930 asymbol *symbol;
1931 bfd_print_symbol_enum_type how;
1932 {
1933 switch (how) {
1934 case bfd_print_symbol_name_enum:
1935 fprintf(file,"%s", symbol->name);
1936 break;
1937 case bfd_print_symbol_type_enum:
1938 fprintf(file,"%4x %2x %2x",(unsigned)(aout_symbol(symbol)->desc & 0xffff),
1939 (unsigned)( aout_symbol(symbol)->other & 0xff),
1940 (unsigned)(aout_symbol(symbol)->type));
1941 break;
1942 case bfd_print_symbol_all_enum:
1943 {
1944 char *section_name = symbol->section == (asection *)NULL ?
1945 "*abs" : symbol->section->name;
1946
1947 bfd_print_symbol_vandf((void *)file,symbol);
1948
1949 fprintf(file," %-5s %04x %02x %02x %s",
1950 section_name,
1951 (unsigned)(aout_symbol(symbol)->desc & 0xffff),
1952 (unsigned)(aout_symbol(symbol)->other & 0xff),
1953 (unsigned)(aout_symbol(symbol)->type & 0xff),
1954 symbol->name);
1955 }
1956 break;
1957 }
1958 }
1959 /* Once we know all the stuff that could be consed, we know how to clean
1960 it up. So why don't we? */
1961
1962 boolean
1963 sunos4_close_and_cleanup (abfd)
1964 bfd *abfd;
1965 {
1966 if (!bfd_read_p (abfd))
1967 switch (abfd->format) {
1968 case bfd_archive:
1969 if (!_bfd_write_archive_contents (abfd)) return false; break;
1970 case bfd_object:
1971 if (!sunos4_write_object_contents (abfd)) return false; break;
1972 default: bfd_error = invalid_operation; return false;
1973 }
1974
1975 #define cleaner(ptr) if (abfd->ptr) free (abfd->ptr)
1976 cleaner (tdata);
1977
1978 if (abfd->my_archive)
1979 cleaner (filename);
1980
1981 #undef cleaner
1982 return true;
1983 }
1984
1985 /*
1986 provided a bfd, a section and an offset into the section, calculate
1987 and return the name of the source file and the line nearest to the
1988 wanted location.
1989 */
1990
1991 boolean
1992 DEFUN(sunos4_find_nearest_line,(abfd,
1993 section,
1994 symbols,
1995 offset,
1996 filename_ptr,
1997 functionname_ptr,
1998 line_ptr),
1999 bfd *abfd AND
2000 asection *section AND
2001 asymbol **symbols AND
2002 bfd_vma offset AND
2003 char **filename_ptr AND
2004 char **functionname_ptr AND
2005 unsigned int *line_ptr)
2006 {
2007 /* Run down the file looking for the filename, function and linenumber */
2008 asymbol **p;
2009 static char buffer[100];
2010 bfd_vma high_line_vma = ~0;
2011 bfd_vma low_func_vma = 0;
2012 asymbol *func = 0;
2013 *filename_ptr = abfd->filename;
2014 *functionname_ptr = 0;
2015 *line_ptr = 0;
2016 if (symbols != (asymbol **)NULL) {
2017 for (p = symbols; *p; p++) {
2018 aout_symbol_type *q = (aout_symbol_type *)(*p);
2019 switch (q->type){
2020 case N_SO:
2021 *filename_ptr = q->symbol.name;
2022 if (obj_textsec(abfd) != section) {
2023 return true;
2024 }
2025 break;
2026 case N_SLINE:
2027
2028 case N_DSLINE:
2029 case N_BSLINE:
2030 /* We'll keep this if it resolves nearer than the one we have already */
2031 if (q->symbol.value >= offset &&
2032 q->symbol.value < high_line_vma) {
2033 *line_ptr = q->desc;
2034 high_line_vma = q->symbol.value;
2035 }
2036 break;
2037 case N_FUN:
2038 {
2039 /* We'll keep this if it is nearer than the one we have already */
2040 if (q->symbol.value >= low_func_vma &&
2041 q->symbol.value <= offset) {
2042 low_func_vma = q->symbol.value;
2043 func = (asymbol *)q;
2044 }
2045 if (*line_ptr && func) {
2046 char *function = func->name;
2047 char *p;
2048 strncpy(buffer, function, sizeof(buffer)-1);
2049 buffer[sizeof(buffer)-1] = 0;
2050 /* Have to remove : stuff */
2051 p = strchr(buffer,':');
2052 if (p != NULL) {*p = NULL; }
2053 *functionname_ptr = buffer;
2054 return true;
2055
2056 }
2057 }
2058 break;
2059 }
2060 }
2061 }
2062
2063 return true;
2064
2065 }
2066
2067 bfd_target aoutvec =
2068 {
2069 "a.out-generic-big", /* name */
2070 bfd_target_aout_flavour_enum,
2071 true, /* target byte order */
2072 true, /* target headers byte order */
2073 (HAS_RELOC | EXEC_P | /* object flags */
2074 HAS_LINENO | HAS_DEBUG |
2075 HAS_SYMS | HAS_LOCALS | DYNAMIC | WP_TEXT | D_PAGED),
2076 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* section flags */
2077 0, /* valid reloc types */
2078 ' ', /* ar_pad_char */
2079 16, /* ar_max_namelen */
2080 sunos4_close_and_cleanup, /* _close_and_cleanup */
2081 sunos4_set_section_contents, /* bfd_set_section_contents */
2082 sunos4_get_section_contents, /* bfd_get_section_contents */
2083 sunos4_new_section_hook, /* new_section_hook */
2084 sunos4_core_file_failing_command, /* _core_file_failing_command */
2085 sunos4_core_file_failing_signal, /* _core_file_failing_signal */
2086 sunos4_core_file_matches_executable_p, /* _core_file_matches_ex...p */
2087
2088 bfd_slurp_bsd_armap, /* bfd_slurp_armap */
2089 bfd_true, /* bfd_slurp_extended_name_table */
2090 bfd_bsd_truncate_arname, /* bfd_truncate_arname */
2091
2092 sunos4_get_symtab_upper_bound, /* get_symtab_upper_bound */
2093 sunos4_get_symtab, /* canonicalize_symtab */
2094 sunos4_reclaim_symbol_table, /* bfd_reclaim_symbol_table */
2095 sunos4_get_reloc_upper_bound, /* get_reloc_upper_bound */
2096 sunos4_canonicalize_reloc, /* bfd_canonicalize_reloc */
2097 sunos4_reclaim_reloc, /* bfd_reclaim_reloc */
2098 sunos4_get_symcount_upper_bound, /* bfd_get_symcount_upper_bound */
2099 sunos4_get_first_symbol, /* bfd_get_first_symbol */
2100 sunos4_get_next_symbol, /* bfd_get_next_symbol */
2101 sunos4_classify_symbol, /* bfd_classify_symbol */
2102 sunos4_symbol_hasclass, /* bfd_symbol_hasclass */
2103 sunos4_symbol_name, /* bfd_symbol_name */
2104 sunos4_symbol_value, /* bfd_symbol_value */
2105
2106 _do_getblong, _do_putblong, _do_getbshort, _do_putbshort, /* data */
2107 _do_getblong, _do_putblong, _do_getbshort, _do_putbshort, /* hdrs */
2108
2109 {_bfd_dummy_target, sunos4_object_p, /* bfd_check_format */
2110 bfd_generic_archive_p, sunos4_core_file_p},
2111 {bfd_false, sunos4_mkobject, /* bfd_zxset_format */
2112 _bfd_generic_mkarchive, bfd_false},
2113 sunos4_make_empty_symbol,
2114 sunos4_print_symbol,
2115 sunos4_get_lineno,
2116 sunos4_set_arch_mach,
2117 bsd_write_armap,
2118 bfd_generic_openr_next_archived_file,
2119 sunos4_find_nearest_line, /* bfd_find_nearest_line */
2120 bfd_generic_stat_arch_elt /* bfd_stat_arch_elt */
2121 };
2122
2123 bfd_target aout_little_vec =
2124 {
2125 "a.out-generic-little", /* name */
2126 bfd_target_aout_flavour_enum,
2127 true, /* target byte order */
2128 true, /* target headers byte order */
2129 (HAS_RELOC | EXEC_P | /* object flags */
2130 HAS_LINENO | HAS_DEBUG |
2131 HAS_SYMS | HAS_LOCALS | DYNAMIC | WP_TEXT | D_PAGED),
2132 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* section flags */
2133 0, /* valid reloc types */
2134 ' ', /* ar_pad_char */
2135 16, /* ar_max_namelen */
2136 sunos4_close_and_cleanup, /* _close_and_cleanup */
2137 sunos4_set_section_contents, /* bfd_set_section_contents */
2138 sunos4_get_section_contents, /* bfd_get_section_contents */
2139 sunos4_new_section_hook, /* new_section_hook */
2140 sunos4_core_file_failing_command, /* _core_file_failing_command */
2141 sunos4_core_file_failing_signal, /* _core_file_failing_signal */
2142 sunos4_core_file_matches_executable_p, /* _core_file_matches_ex...p */
2143
2144 bfd_slurp_bsd_armap, /* bfd_slurp_armap */
2145 bfd_true, /* bfd_slurp_extended_name_table */
2146 bfd_bsd_truncate_arname, /* bfd_truncate_arname */
2147
2148 sunos4_get_symtab_upper_bound, /* get_symtab_upper_bound */
2149 sunos4_get_symtab, /* canonicalize_symtab */
2150 sunos4_reclaim_symbol_table, /* bfd_reclaim_symbol_table */
2151 sunos4_get_reloc_upper_bound, /* get_reloc_upper_bound */
2152 sunos4_canonicalize_reloc, /* bfd_canonicalize_reloc */
2153 sunos4_reclaim_reloc, /* bfd_reclaim_reloc */
2154 sunos4_get_symcount_upper_bound, /* bfd_get_symcount_upper_bound */
2155 sunos4_get_first_symbol, /* bfd_get_first_symbol */
2156 sunos4_get_next_symbol, /* bfd_get_next_symbol */
2157 sunos4_classify_symbol, /* bfd_classify_symbol */
2158 sunos4_symbol_hasclass, /* bfd_symbol_hasclass */
2159 sunos4_symbol_name, /* bfd_symbol_name */
2160 sunos4_symbol_value, /* bfd_symbol_value */
2161
2162 _do_getllong, _do_putllong, _do_getlshort, _do_putlshort, /* data */
2163 _do_getllong, _do_putllong, _do_getlshort, _do_putlshort, /* hdrs */
2164
2165 {_bfd_dummy_target, sunos4_object_p, /* bfd_check_format */
2166 bfd_generic_archive_p, sunos4_core_file_p},
2167 {bfd_false, sunos4_mkobject, /* bfd_zxset_format */
2168 _bfd_generic_mkarchive, bfd_false},
2169 sunos4_make_empty_symbol,
2170 sunos4_print_symbol,
2171 sunos4_get_lineno,
2172 sunos4_set_arch_mach,
2173 bsd_write_armap,
2174 bfd_generic_openr_next_archived_file,
2175 sunos4_find_nearest_line, /* bfd_find_nearest_line */
2176 bfd_generic_stat_arch_elt /* bfd_stat_arch_elt */
2177 };
2178
GDB Binutils - Deliverables
This page took 0.110568 seconds and 3 git commands to generate.