filter out invalid S_FUN entries
[reactos.git] / reactos / tools / rsym.c
1 /*
2 * Usage: rsym input-file output-file
3 */
4 #include <stdio.h>
5 #include <string.h>
6 #include <stdlib.h>
7
8 #define IMAGE_DOS_MAGIC 0x5a4d
9 #define IMAGE_PE_MAGIC 0x00004550
10
11 #define IMAGE_SIZEOF_SHORT_NAME 8
12
13 #define IMAGE_NUMBEROF_DIRECTORY_ENTRIES 16
14
15 typedef void* PVOID;
16 typedef unsigned char BYTE;
17 typedef unsigned short WORD;
18 typedef unsigned long DWORD;
19 typedef signed long LONG;
20 typedef unsigned long ULONG;
21
22 #pragma pack(push,2)
23 typedef struct _IMAGE_DOS_HEADER {
24 WORD e_magic;
25 WORD e_cblp;
26 WORD e_cp;
27 WORD e_crlc;
28 WORD e_cparhdr;
29 WORD e_minalloc;
30 WORD e_maxalloc;
31 WORD e_ss;
32 WORD e_sp;
33 WORD e_csum;
34 WORD e_ip;
35 WORD e_cs;
36 WORD e_lfarlc;
37 WORD e_ovno;
38 WORD e_res[4];
39 WORD e_oemid;
40 WORD e_oeminfo;
41 WORD e_res2[10];
42 LONG e_lfanew;
43 } IMAGE_DOS_HEADER,*PIMAGE_DOS_HEADER;
44 #pragma pack(pop)
45 #pragma pack(push,4)
46 typedef struct _IMAGE_DATA_DIRECTORY {
47 DWORD VirtualAddress;
48 DWORD Size;
49 } IMAGE_DATA_DIRECTORY,*PIMAGE_DATA_DIRECTORY;
50 typedef struct _IMAGE_OPTIONAL_HEADER {
51 WORD Magic;
52 BYTE MajorLinkerVersion;
53 BYTE MinorLinkerVersion;
54 DWORD SizeOfCode;
55 DWORD SizeOfInitializedData;
56 DWORD SizeOfUninitializedData;
57 DWORD AddressOfEntryPoint;
58 DWORD BaseOfCode;
59 DWORD BaseOfData;
60 DWORD ImageBase;
61 DWORD SectionAlignment;
62 DWORD FileAlignment;
63 WORD MajorOperatingSystemVersion;
64 WORD MinorOperatingSystemVersion;
65 WORD MajorImageVersion;
66 WORD MinorImageVersion;
67 WORD MajorSubsystemVersion;
68 WORD MinorSubsystemVersion;
69 DWORD Reserved1;
70 DWORD SizeOfImage;
71 DWORD SizeOfHeaders;
72 DWORD CheckSum;
73 WORD Subsystem;
74 WORD DllCharacteristics;
75 DWORD SizeOfStackReserve;
76 DWORD SizeOfStackCommit;
77 DWORD SizeOfHeapReserve;
78 DWORD SizeOfHeapCommit;
79 DWORD LoaderFlags;
80 DWORD NumberOfRvaAndSizes;
81 IMAGE_DATA_DIRECTORY DataDirectory[IMAGE_NUMBEROF_DIRECTORY_ENTRIES];
82 } IMAGE_OPTIONAL_HEADER,*PIMAGE_OPTIONAL_HEADER;
83 typedef struct _IMAGE_FILE_HEADER {
84 WORD Machine;
85 WORD NumberOfSections;
86 DWORD TimeDateStamp;
87 DWORD PointerToSymbolTable;
88 DWORD NumberOfSymbols;
89 WORD SizeOfOptionalHeader;
90 WORD Characteristics;
91 } IMAGE_FILE_HEADER, *PIMAGE_FILE_HEADER;
92 typedef struct _IMAGE_SECTION_HEADER {
93 BYTE Name[IMAGE_SIZEOF_SHORT_NAME];
94 union {
95 DWORD PhysicalAddress;
96 DWORD VirtualSize;
97 } Misc;
98 DWORD VirtualAddress;
99 DWORD SizeOfRawData;
100 DWORD PointerToRawData;
101 DWORD PointerToRelocations;
102 DWORD PointerToLinenumbers;
103 WORD NumberOfRelocations;
104 WORD NumberOfLinenumbers;
105 DWORD Characteristics;
106 } IMAGE_SECTION_HEADER,*PIMAGE_SECTION_HEADER;
107 #pragma pack(pop)
108
109 typedef struct _SYMBOLFILE_HEADER {
110 unsigned long StabsOffset;
111 unsigned long StabsLength;
112 unsigned long StabstrOffset;
113 unsigned long StabstrLength;
114 } SYMBOLFILE_HEADER, *PSYMBOLFILE_HEADER;
115
116 typedef struct _STAB_ENTRY {
117 unsigned long n_strx; /* index into string table of name */
118 unsigned char n_type; /* type of symbol */
119 unsigned char n_other; /* misc info (usually empty) */
120 unsigned short n_desc; /* description field */
121 unsigned long n_value; /* value of symbol */
122 } STAB_ENTRY, *PSTAB_ENTRY;
123
124 #define N_FUN 0x24
125 #define N_SLINE 0x44
126 #define N_SO 0x64
127
128 typedef struct
129 {
130 unsigned long OldOffset;
131 unsigned long NewOffset;
132 char* Name;
133 unsigned long Length;
134 } STR_ENTRY, *PSTR_ENTRY;
135
136 char* convert_path(char* origpath)
137 {
138 char* newpath;
139 int i;
140
141 newpath = strdup(origpath);
142
143 i = 0;
144 while (newpath[i] != 0)
145 {
146 #ifdef UNIX_PATHS
147 if (newpath[i] == '\\')
148 {
149 newpath[i] = '/';
150 }
151 #else
152 #ifdef DOS_PATHS
153 if (newpath[i] == '/')
154 {
155 newpath[i] = '\\';
156 }
157 #endif
158 #endif
159 i++;
160 }
161 return(newpath);
162 }
163
164 #define TRANSFER_SIZE (65536)
165
166 int main(int argc, char* argv[])
167 {
168 SYMBOLFILE_HEADER SymbolFileHeader;
169 IMAGE_DOS_HEADER PEDosHeader;
170 IMAGE_FILE_HEADER PEFileHeader;
171 PIMAGE_OPTIONAL_HEADER PEOptHeader;
172 PIMAGE_SECTION_HEADER PESectionHeaders;
173 ULONG ImageBase;
174 PVOID SymbolsBase;
175 ULONG SymbolsLength;
176 PVOID SymbolStringsBase;
177 ULONG SymbolStringsLength;
178 ULONG Idx;
179 char* path1;
180 char* path2;
181 FILE* in;
182 FILE* out;
183 int n_in;
184 int n_out;
185 PSTAB_ENTRY StabEntry;
186 ULONG Count;
187 ULONG i;
188 ULONG SymbolsCount;
189 PSTR_ENTRY StrEntry;
190 ULONG StrCount;
191 ULONG j;
192
193 if (argc != 3)
194 {
195 fprintf(stderr, "Too many arguments\n");
196 exit(1);
197 }
198
199 path1 = convert_path(argv[1]);
200 path2 = convert_path(argv[2]);
201
202 in = fopen(path1, "rb");
203 if (in == NULL)
204 {
205 perror("Cannot open input file");
206 exit(1);
207 }
208
209 out = fopen(path2, "wb");
210 if (out == NULL)
211 {
212 perror("Cannot open output file");
213 fclose(in);
214 exit(1);
215 }
216
217 /* Check if MZ header exists */
218 n_in = fread(&PEDosHeader, 1, sizeof(PEDosHeader), in);
219 if (PEDosHeader.e_magic != IMAGE_DOS_MAGIC && PEDosHeader.e_lfanew != 0L)
220 {
221 perror("Input file is not a PE image.\n");
222 }
223
224 /* Read PE file header */
225 /* sizeof(ULONG) = sizeof(MAGIC) */
226 fseek(in, PEDosHeader.e_lfanew + sizeof(ULONG), SEEK_SET);
227 n_in = fread(&PEFileHeader, 1, sizeof(PEFileHeader), in);
228
229 /* Read optional header */
230 PEOptHeader = malloc(PEFileHeader.SizeOfOptionalHeader);
231 fread ( PEOptHeader, 1, PEFileHeader.SizeOfOptionalHeader, in );
232 ImageBase = PEOptHeader->ImageBase;
233
234 /* Read PE section headers */
235 PESectionHeaders = malloc(PEFileHeader.NumberOfSections * sizeof(IMAGE_SECTION_HEADER));
236 fseek(in, PEDosHeader.e_lfanew + sizeof(ULONG) + sizeof(IMAGE_FILE_HEADER)
237 + sizeof(IMAGE_OPTIONAL_HEADER), SEEK_SET);
238 n_in = fread(PESectionHeaders, 1, PEFileHeader.NumberOfSections * sizeof(IMAGE_SECTION_HEADER), in);
239
240 /* Copy .stab and .stabstr sections if available */
241 SymbolsBase = NULL;
242 SymbolsLength = 0;
243 SymbolStringsBase = NULL;
244 SymbolStringsLength = 0;
245
246 for (Idx = 0; Idx < PEFileHeader.NumberOfSections; Idx++)
247 {
248 //printf("section: '%.08s'\n", PESectionHeaders[Idx].Name);
249 if ((strncmp(PESectionHeaders[Idx].Name, ".stab", 5) == 0)
250 && (PESectionHeaders[Idx].Name[5] == 0))
251 {
252 //printf(".stab section found. Size %d\n",
253 // PESectionHeaders[Idx].SizeOfRawData);
254
255 SymbolsLength = PESectionHeaders[Idx].SizeOfRawData;
256 SymbolsBase = malloc(SymbolsLength);
257
258 fseek(in, PESectionHeaders[Idx].PointerToRawData, SEEK_SET);
259 n_in = fread(SymbolsBase, 1, SymbolsLength, in);
260 }
261
262 if (strncmp(PESectionHeaders[Idx].Name, ".stabstr", 8) == 0)
263 {
264 //printf(".stabstr section found. Size %d\n",
265 // PESectionHeaders[Idx].SizeOfRawData);
266
267 SymbolStringsLength = PESectionHeaders[Idx].SizeOfRawData;
268 SymbolStringsBase = malloc(SymbolStringsLength);
269
270 fseek(in, PESectionHeaders[Idx].PointerToRawData, SEEK_SET);
271 n_in = fread(SymbolStringsBase, 1, SymbolStringsLength, in);
272 }
273 }
274
275 StabEntry = SymbolsBase;
276 SymbolsCount = SymbolsLength / sizeof(STAB_ENTRY);
277 Count = 0;
278
279 for (i = 0; i < SymbolsCount; i++)
280 {
281 switch ( StabEntry[i].n_type )
282 {
283 case N_FUN:
284 if ( StabEntry[i].n_desc == 0 ) // line # 0 isn't valid
285 continue;
286 break;
287 case N_SLINE:
288 break;
289 case N_SO:
290 break;
291 default:
292 continue;
293 }
294 memmove(&StabEntry[Count], &StabEntry[i], sizeof(STAB_ENTRY));
295 if ( StabEntry[Count].n_value >= ImageBase )
296 StabEntry[Count].n_value -= ImageBase;
297 Count++;
298 }
299
300 StrEntry = malloc(sizeof(STR_ENTRY) * Count);
301 StrCount = 0;
302
303 for (i = 0; i < Count; i++)
304 {
305 for (j = 0; j < StrCount; j++)
306 {
307 if (StabEntry[i].n_strx == StrEntry[j].OldOffset)
308 {
309 StabEntry[i].n_strx = StrEntry[j].NewOffset;
310 break;
311 }
312 }
313 if (j >= StrCount)
314 {
315 StrEntry[StrCount].OldOffset = StabEntry[i].n_strx;
316 StrEntry[StrCount].Name = (char*)SymbolStringsBase + StrEntry[StrCount].OldOffset;
317 StrEntry[StrCount].Length = strlen(StrEntry[StrCount].Name) + 1;
318 if (StrCount == 0)
319 {
320 StrEntry[StrCount].NewOffset = 0;
321 }
322 else
323 {
324 StrEntry[StrCount].NewOffset = StrEntry[StrCount-1].NewOffset + StrEntry[StrCount-1].Length;
325 }
326 StabEntry[i].n_strx = StrEntry[StrCount].NewOffset;
327 StrCount++;
328 }
329 }
330
331 SymbolFileHeader.StabsOffset = sizeof(SYMBOLFILE_HEADER);
332 SymbolFileHeader.StabsLength = Count * sizeof(STAB_ENTRY);
333 SymbolFileHeader.StabstrOffset = SymbolFileHeader.StabsOffset + SymbolFileHeader.StabsLength;
334 SymbolFileHeader.StabstrLength = StrEntry[StrCount-1].NewOffset + StrEntry[StrCount-1].Length;
335
336 n_out = fwrite(&SymbolFileHeader, 1, sizeof(SYMBOLFILE_HEADER), out);
337 n_out = fwrite(SymbolsBase, 1, SymbolFileHeader.StabsLength, out);
338 for (i = 0; i < StrCount; i++)
339 {
340 fwrite(StrEntry[i].Name, 1, StrEntry[i].Length, out);
341 }
342
343 fclose(out);
344 exit(0);
345 }