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
|
/* BFD back end for traditional Unix core files (U-area and sections, raw)
Copyright (C) 1988, 1989, 1991 Free Software Foundation, Inc. */
/* This file does not define a particular back-end, but it defines routines
that can be used by other back-ends. */
#include "bfd.h"
#include <stdio.h>
#include "libbfd.h"
#include "liba.out.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 <sys/stat.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;
};
bfd_target *
trad_unix_core_file_p (abfd)
bfd *abfd;
{
#if HOST_SYS == SUN_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. */
core_datasec (abfd)->vma = TEXT_START_ADDR + (NBPG * u.u_tsize);
core_stacksec (abfd)->vma = 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;
}
int
trad_unix_core_file_failing_signal (abfd)
bfd *abfd;
{
return -1; /* FIXME, where is it? */
}
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 */
}
|
