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