1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
|
/* BFD back end for traditional Unix core files (U-area and raw sections)
Copyright (C) 1988, 1989, 1991 Free Software Foundation, Inc.
Written by John Gilmore of Cygnus Support.
This file is part of BFD, the Binary File Descriptor library.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
/* This file does not define a particular back-end, but it defines routines
that can be used by other back-ends. */
#include <sysdep.h>
#include "bfd.h"
#include <stdio.h>
#include "libbfd.h"
#include "libaout.h" /* BFD a.out internal data structures */
#include <sys/types.h>
#include <sys/param.h>
#include <sys/dir.h>
#include <signal.h>
#include <machine/reg.h>
#include <sys/user.h> /* After a.out.h */
#include <sys/file.h>
#include <errno.h>
/* need this cast b/c ptr is really void * */
#define core_hdr(bfd) (((struct core_data *) (bfd->tdata))->hdr)
#define core_datasec(bfd) (((struct core_data *) ((bfd)->tdata))->data_section)
#define core_stacksec(bfd) (((struct core_data*)((bfd)->tdata))->stack_section)
#define core_regsec(bfd) (((struct core_data *) ((bfd)->tdata))->reg_section)
#define core_upage(bfd) (((struct core_data *) ((bfd)->tdata))->upage)
/* These are stored in the bfd's tdata */
struct core_data {
struct user *upage; /* core file header */
asection *data_section;
asection *stack_section;
asection *reg_section;
};
/* ARGSUSED */
bfd_target *
trad_unix_core_file_p (abfd)
bfd *abfd;
{
#if HOST_SYS == SUN4_SYS
return 0;
#else
int val;
char *rawptr;
struct user u;
unsigned int reg_offset, fp_reg_offset;
/* 4.2-style (and perhaps also sysV-style) core dump file. */
val = bfd_read ((void *)&u, 1, sizeof u, abfd);
if (val != sizeof u)
return 0; /* Too small to be a core file */
/* Sanity check perhaps??? */
if (u.u_dsize > 0x1000000) /* Remember, it's in pages... */
return 0;
if (u.u_ssize > 0x1000000)
return 0;
/* Check that the size claimed is no greater than the file size. FIXME. */
/* OK, we believe you. You're a core file (sure, sure). */
/* Allocate both the upage and the struct core_data at once, so
a single free() will free them both. */
rawptr = (char *)zalloc (sizeof (u) + sizeof (struct core_data));
if (rawptr == NULL) {
bfd_error = no_memory;
return 0;
}
set_tdata (abfd, (struct core_data *)rawptr);
core_upage (abfd) = (struct user *)(rawptr + sizeof (struct core_data));
*core_upage (abfd) = u; /* Save that upage! */
/* create the sections. This is raunchy, but bfd_close wants to reclaim
them */
core_stacksec (abfd) = (asection *) zalloc (sizeof (asection));
if (core_stacksec (abfd) == NULL) {
loser:
bfd_error = no_memory;
free ((void *)rawptr);
return 0;
}
core_datasec (abfd) = (asection *) zalloc (sizeof (asection));
if (core_datasec (abfd) == NULL) {
loser1:
free ((void *)core_stacksec (abfd));
goto loser;
}
core_regsec (abfd) = (asection *) zalloc (sizeof (asection));
if (core_regsec (abfd) == NULL) {
loser2:
free ((void *)core_datasec (abfd));
goto loser1;
}
core_stacksec (abfd)->name = ".stack";
core_datasec (abfd)->name = ".data";
core_regsec (abfd)->name = ".reg";
core_stacksec (abfd)->flags = SEC_ALLOC + SEC_LOAD;
core_datasec (abfd)->flags = SEC_ALLOC + SEC_LOAD;
core_regsec (abfd)->flags = SEC_ALLOC;
core_datasec (abfd)->size = NBPG * u.u_dsize;
core_stacksec (abfd)->size = NBPG * u.u_ssize;
core_regsec (abfd)->size = NBPG * UPAGES; /* Larger than sizeof struct u */
/* What a hack... we'd like to steal it from the exec file,
since the upage does not seem to provide it. FIXME. */
#ifdef HOST_DATA_START_ADDR
core_datasec (abfd)->vma = HOST_DATA_START_ADDR;
#else
core_datasec (abfd)->vma = HOST_TEXT_START_ADDR + (NBPG * u.u_tsize);
#endif
core_stacksec (abfd)->vma = HOST_STACK_END_ADDR - (NBPG * u.u_ssize);
core_regsec (abfd)->vma = -1;
core_datasec (abfd)->filepos = NBPG * UPAGES;
core_stacksec (abfd)->filepos = (NBPG * UPAGES) + NBPG * u.u_dsize;
core_regsec (abfd)->filepos = 0; /* Register segment is the upage */
/* Align to word at least */
core_stacksec (abfd)->alignment_power = 2;
core_datasec (abfd)->alignment_power = 2;
core_regsec (abfd)->alignment_power = 2;
abfd->sections = core_stacksec (abfd);
core_stacksec (abfd)->next = core_datasec (abfd);
core_datasec (abfd)->next = core_regsec (abfd);
abfd->section_count = 3;
return abfd->xvec;
#endif
}
char *
trad_unix_core_file_failing_command (abfd)
bfd *abfd;
{
if (*core_upage (abfd)->u_comm)
return core_upage (abfd)->u_comm;
else
return 0;
}
/* ARGSUSED */
int
trad_unix_core_file_failing_signal (ignore_abfd)
bfd *ignore_abfd;
{
return -1; /* FIXME, where is it? */
}
/* ARGSUSED */
boolean
trad_unix_core_file_matches_executable_p (core_bfd, exec_bfd)
bfd *core_bfd, *exec_bfd;
{
return true; /* FIXME, We have no way of telling at this point */
}
|
