1 | /*
|
---|
2 | * TCCPE.C - PE file output for the Tiny C Compiler
|
---|
3 | *
|
---|
4 | * Copyright (c) 2005-2007 grischka
|
---|
5 | *
|
---|
6 | * This library is free software; you can redistribute it and/or
|
---|
7 | * modify it under the terms of the GNU Lesser General Public
|
---|
8 | * License as published by the Free Software Foundation; either
|
---|
9 | * version 2 of the License, or (at your option) any later version.
|
---|
10 | *
|
---|
11 | * This library is distributed in the hope that it will be useful,
|
---|
12 | * but WITHOUT ANY WARRANTY; without even the implied warranty of
|
---|
13 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
---|
14 | * Lesser General Public License for more details.
|
---|
15 | *
|
---|
16 | * You should have received a copy of the GNU Lesser General Public
|
---|
17 | * License along with this library; if not, write to the Free Software
|
---|
18 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
---|
19 | */
|
---|
20 |
|
---|
21 | #include "tcc.h"
|
---|
22 |
|
---|
23 | #ifndef _WIN32
|
---|
24 | #define stricmp strcasecmp
|
---|
25 | #define strnicmp strncasecmp
|
---|
26 | #endif
|
---|
27 |
|
---|
28 | #ifndef MAX_PATH
|
---|
29 | #define MAX_PATH 260
|
---|
30 | #endif
|
---|
31 |
|
---|
32 | #define PE_MERGE_DATA
|
---|
33 | // #define PE_PRINT_SECTIONS
|
---|
34 |
|
---|
35 | #ifdef TCC_TARGET_X86_64
|
---|
36 | # define ADDR3264 ULONGLONG
|
---|
37 | #else
|
---|
38 | # define ADDR3264 DWORD
|
---|
39 | #endif
|
---|
40 |
|
---|
41 | #ifdef _WIN32
|
---|
42 | void dbg_printf (const char *fmt, ...)
|
---|
43 | {
|
---|
44 | char buffer[4000];
|
---|
45 | va_list arg;
|
---|
46 | int x;
|
---|
47 | va_start(arg, fmt);
|
---|
48 | x = vsprintf (buffer, fmt, arg);
|
---|
49 | strcpy(buffer+x, "\n");
|
---|
50 | OutputDebugString(buffer);
|
---|
51 | }
|
---|
52 | #endif
|
---|
53 |
|
---|
54 | /* ----------------------------------------------------------- */
|
---|
55 | #ifndef IMAGE_NT_SIGNATURE
|
---|
56 | /* ----------------------------------------------------------- */
|
---|
57 | /* definitions below are from winnt.h */
|
---|
58 |
|
---|
59 | typedef unsigned char BYTE;
|
---|
60 | typedef unsigned short WORD;
|
---|
61 | typedef unsigned int DWORD;
|
---|
62 | typedef unsigned long long ULONGLONG;
|
---|
63 | #pragma pack(push, 1)
|
---|
64 |
|
---|
65 | typedef struct _IMAGE_DOS_HEADER { /* DOS .EXE header */
|
---|
66 | WORD e_magic; /* Magic number */
|
---|
67 | WORD e_cblp; /* Bytes on last page of file */
|
---|
68 | WORD e_cp; /* Pages in file */
|
---|
69 | WORD e_crlc; /* Relocations */
|
---|
70 | WORD e_cparhdr; /* Size of header in paragraphs */
|
---|
71 | WORD e_minalloc; /* Minimum extra paragraphs needed */
|
---|
72 | WORD e_maxalloc; /* Maximum extra paragraphs needed */
|
---|
73 | WORD e_ss; /* Initial (relative) SS value */
|
---|
74 | WORD e_sp; /* Initial SP value */
|
---|
75 | WORD e_csum; /* Checksum */
|
---|
76 | WORD e_ip; /* Initial IP value */
|
---|
77 | WORD e_cs; /* Initial (relative) CS value */
|
---|
78 | WORD e_lfarlc; /* File address of relocation table */
|
---|
79 | WORD e_ovno; /* Overlay number */
|
---|
80 | WORD e_res[4]; /* Reserved words */
|
---|
81 | WORD e_oemid; /* OEM identifier (for e_oeminfo) */
|
---|
82 | WORD e_oeminfo; /* OEM information; e_oemid specific */
|
---|
83 | WORD e_res2[10]; /* Reserved words */
|
---|
84 | DWORD e_lfanew; /* File address of new exe header */
|
---|
85 | } IMAGE_DOS_HEADER, *PIMAGE_DOS_HEADER;
|
---|
86 |
|
---|
87 | #define IMAGE_NT_SIGNATURE 0x00004550 /* PE00 */
|
---|
88 | #define SIZE_OF_NT_SIGNATURE 4
|
---|
89 |
|
---|
90 | typedef struct _IMAGE_FILE_HEADER {
|
---|
91 | WORD Machine;
|
---|
92 | WORD NumberOfSections;
|
---|
93 | DWORD TimeDateStamp;
|
---|
94 | DWORD PointerToSymbolTable;
|
---|
95 | DWORD NumberOfSymbols;
|
---|
96 | WORD SizeOfOptionalHeader;
|
---|
97 | WORD Characteristics;
|
---|
98 | } IMAGE_FILE_HEADER, *PIMAGE_FILE_HEADER;
|
---|
99 |
|
---|
100 |
|
---|
101 | #define IMAGE_SIZEOF_FILE_HEADER 20
|
---|
102 |
|
---|
103 | typedef struct _IMAGE_DATA_DIRECTORY {
|
---|
104 | DWORD VirtualAddress;
|
---|
105 | DWORD Size;
|
---|
106 | } IMAGE_DATA_DIRECTORY, *PIMAGE_DATA_DIRECTORY;
|
---|
107 |
|
---|
108 |
|
---|
109 | typedef struct _IMAGE_OPTIONAL_HEADER {
|
---|
110 | /* Standard fields. */
|
---|
111 | WORD Magic;
|
---|
112 | BYTE MajorLinkerVersion;
|
---|
113 | BYTE MinorLinkerVersion;
|
---|
114 | DWORD SizeOfCode;
|
---|
115 | DWORD SizeOfInitializedData;
|
---|
116 | DWORD SizeOfUninitializedData;
|
---|
117 | DWORD AddressOfEntryPoint;
|
---|
118 | DWORD BaseOfCode;
|
---|
119 | #ifndef TCC_TARGET_X86_64
|
---|
120 | DWORD BaseOfData;
|
---|
121 | #endif
|
---|
122 | /* NT additional fields. */
|
---|
123 | ADDR3264 ImageBase;
|
---|
124 | DWORD SectionAlignment;
|
---|
125 | DWORD FileAlignment;
|
---|
126 | WORD MajorOperatingSystemVersion;
|
---|
127 | WORD MinorOperatingSystemVersion;
|
---|
128 | WORD MajorImageVersion;
|
---|
129 | WORD MinorImageVersion;
|
---|
130 | WORD MajorSubsystemVersion;
|
---|
131 | WORD MinorSubsystemVersion;
|
---|
132 | DWORD Win32VersionValue;
|
---|
133 | DWORD SizeOfImage;
|
---|
134 | DWORD SizeOfHeaders;
|
---|
135 | DWORD CheckSum;
|
---|
136 | WORD Subsystem;
|
---|
137 | WORD DllCharacteristics;
|
---|
138 | ADDR3264 SizeOfStackReserve;
|
---|
139 | ADDR3264 SizeOfStackCommit;
|
---|
140 | ADDR3264 SizeOfHeapReserve;
|
---|
141 | ADDR3264 SizeOfHeapCommit;
|
---|
142 | DWORD LoaderFlags;
|
---|
143 | DWORD NumberOfRvaAndSizes;
|
---|
144 | IMAGE_DATA_DIRECTORY DataDirectory[16];
|
---|
145 | } IMAGE_OPTIONAL_HEADER32, IMAGE_OPTIONAL_HEADER64, IMAGE_OPTIONAL_HEADER;
|
---|
146 |
|
---|
147 | #define IMAGE_DIRECTORY_ENTRY_EXPORT 0 /* Export Directory */
|
---|
148 | #define IMAGE_DIRECTORY_ENTRY_IMPORT 1 /* Import Directory */
|
---|
149 | #define IMAGE_DIRECTORY_ENTRY_RESOURCE 2 /* Resource Directory */
|
---|
150 | #define IMAGE_DIRECTORY_ENTRY_EXCEPTION 3 /* Exception Directory */
|
---|
151 | #define IMAGE_DIRECTORY_ENTRY_SECURITY 4 /* Security Directory */
|
---|
152 | #define IMAGE_DIRECTORY_ENTRY_BASERELOC 5 /* Base Relocation Table */
|
---|
153 | #define IMAGE_DIRECTORY_ENTRY_DEBUG 6 /* Debug Directory */
|
---|
154 | /* IMAGE_DIRECTORY_ENTRY_COPYRIGHT 7 (X86 usage) */
|
---|
155 | #define IMAGE_DIRECTORY_ENTRY_ARCHITECTURE 7 /* Architecture Specific Data */
|
---|
156 | #define IMAGE_DIRECTORY_ENTRY_GLOBALPTR 8 /* RVA of GP */
|
---|
157 | #define IMAGE_DIRECTORY_ENTRY_TLS 9 /* TLS Directory */
|
---|
158 | #define IMAGE_DIRECTORY_ENTRY_LOAD_CONFIG 10 /* Load Configuration Directory */
|
---|
159 | #define IMAGE_DIRECTORY_ENTRY_BOUND_IMPORT 11 /* Bound Import Directory in headers */
|
---|
160 | #define IMAGE_DIRECTORY_ENTRY_IAT 12 /* Import Address Table */
|
---|
161 | #define IMAGE_DIRECTORY_ENTRY_DELAY_IMPORT 13 /* Delay Load Import Descriptors */
|
---|
162 | #define IMAGE_DIRECTORY_ENTRY_COM_DESCRIPTOR 14 /* COM Runtime descriptor */
|
---|
163 |
|
---|
164 | /* Section header format. */
|
---|
165 | #define IMAGE_SIZEOF_SHORT_NAME 8
|
---|
166 |
|
---|
167 | typedef struct _IMAGE_SECTION_HEADER {
|
---|
168 | BYTE Name[IMAGE_SIZEOF_SHORT_NAME];
|
---|
169 | union {
|
---|
170 | DWORD PhysicalAddress;
|
---|
171 | DWORD VirtualSize;
|
---|
172 | } Misc;
|
---|
173 | DWORD VirtualAddress;
|
---|
174 | DWORD SizeOfRawData;
|
---|
175 | DWORD PointerToRawData;
|
---|
176 | DWORD PointerToRelocations;
|
---|
177 | DWORD PointerToLinenumbers;
|
---|
178 | WORD NumberOfRelocations;
|
---|
179 | WORD NumberOfLinenumbers;
|
---|
180 | DWORD Characteristics;
|
---|
181 | } IMAGE_SECTION_HEADER, *PIMAGE_SECTION_HEADER;
|
---|
182 |
|
---|
183 | #define IMAGE_SIZEOF_SECTION_HEADER 40
|
---|
184 |
|
---|
185 | typedef struct _IMAGE_EXPORT_DIRECTORY {
|
---|
186 | DWORD Characteristics;
|
---|
187 | DWORD TimeDateStamp;
|
---|
188 | WORD MajorVersion;
|
---|
189 | WORD MinorVersion;
|
---|
190 | DWORD Name;
|
---|
191 | DWORD Base;
|
---|
192 | DWORD NumberOfFunctions;
|
---|
193 | DWORD NumberOfNames;
|
---|
194 | DWORD AddressOfFunctions;
|
---|
195 | DWORD AddressOfNames;
|
---|
196 | DWORD AddressOfNameOrdinals;
|
---|
197 | } IMAGE_EXPORT_DIRECTORY,*PIMAGE_EXPORT_DIRECTORY;
|
---|
198 |
|
---|
199 | typedef struct _IMAGE_IMPORT_DESCRIPTOR {
|
---|
200 | union {
|
---|
201 | DWORD Characteristics;
|
---|
202 | DWORD OriginalFirstThunk;
|
---|
203 | };
|
---|
204 | DWORD TimeDateStamp;
|
---|
205 | DWORD ForwarderChain;
|
---|
206 | DWORD Name;
|
---|
207 | DWORD FirstThunk;
|
---|
208 | } IMAGE_IMPORT_DESCRIPTOR;
|
---|
209 |
|
---|
210 | typedef struct _IMAGE_BASE_RELOCATION {
|
---|
211 | DWORD VirtualAddress;
|
---|
212 | DWORD SizeOfBlock;
|
---|
213 | // WORD TypeOffset[1];
|
---|
214 | } IMAGE_BASE_RELOCATION;
|
---|
215 |
|
---|
216 | #define IMAGE_SIZEOF_BASE_RELOCATION 8
|
---|
217 |
|
---|
218 | #define IMAGE_REL_BASED_ABSOLUTE 0
|
---|
219 | #define IMAGE_REL_BASED_HIGH 1
|
---|
220 | #define IMAGE_REL_BASED_LOW 2
|
---|
221 | #define IMAGE_REL_BASED_HIGHLOW 3
|
---|
222 | #define IMAGE_REL_BASED_HIGHADJ 4
|
---|
223 | #define IMAGE_REL_BASED_MIPS_JMPADDR 5
|
---|
224 | #define IMAGE_REL_BASED_SECTION 6
|
---|
225 | #define IMAGE_REL_BASED_REL32 7
|
---|
226 |
|
---|
227 | #pragma pack(pop)
|
---|
228 |
|
---|
229 | /* ----------------------------------------------------------- */
|
---|
230 | #endif /* ndef IMAGE_NT_SIGNATURE */
|
---|
231 | /* ----------------------------------------------------------- */
|
---|
232 | #pragma pack(push, 1)
|
---|
233 |
|
---|
234 | struct pe_header
|
---|
235 | {
|
---|
236 | IMAGE_DOS_HEADER doshdr;
|
---|
237 | BYTE dosstub[0x40];
|
---|
238 | DWORD nt_sig;
|
---|
239 | IMAGE_FILE_HEADER filehdr;
|
---|
240 | #ifdef TCC_TARGET_X86_64
|
---|
241 | IMAGE_OPTIONAL_HEADER64 opthdr;
|
---|
242 | #else
|
---|
243 | #ifdef _WIN64
|
---|
244 | IMAGE_OPTIONAL_HEADER32 opthdr;
|
---|
245 | #else
|
---|
246 | IMAGE_OPTIONAL_HEADER opthdr;
|
---|
247 | #endif
|
---|
248 | #endif
|
---|
249 | };
|
---|
250 |
|
---|
251 | struct pe_reloc_header {
|
---|
252 | DWORD offset;
|
---|
253 | DWORD size;
|
---|
254 | };
|
---|
255 |
|
---|
256 | struct pe_rsrc_header {
|
---|
257 | struct _IMAGE_FILE_HEADER filehdr;
|
---|
258 | struct _IMAGE_SECTION_HEADER sectionhdr;
|
---|
259 | };
|
---|
260 |
|
---|
261 | struct pe_rsrc_reloc {
|
---|
262 | DWORD offset;
|
---|
263 | DWORD size;
|
---|
264 | WORD type;
|
---|
265 | };
|
---|
266 |
|
---|
267 | #pragma pack(pop)
|
---|
268 |
|
---|
269 | /* ------------------------------------------------------------- */
|
---|
270 | /* internal temporary structures */
|
---|
271 |
|
---|
272 | /*
|
---|
273 | #define IMAGE_SCN_CNT_CODE 0x00000020
|
---|
274 | #define IMAGE_SCN_CNT_INITIALIZED_DATA 0x00000040
|
---|
275 | #define IMAGE_SCN_CNT_UNINITIALIZED_DATA 0x00000080
|
---|
276 | #define IMAGE_SCN_MEM_DISCARDABLE 0x02000000
|
---|
277 | #define IMAGE_SCN_MEM_SHARED 0x10000000
|
---|
278 | #define IMAGE_SCN_MEM_EXECUTE 0x20000000
|
---|
279 | #define IMAGE_SCN_MEM_READ 0x40000000
|
---|
280 | #define IMAGE_SCN_MEM_WRITE 0x80000000
|
---|
281 | */
|
---|
282 |
|
---|
283 | enum {
|
---|
284 | sec_text = 0,
|
---|
285 | sec_data ,
|
---|
286 | sec_bss ,
|
---|
287 | sec_idata ,
|
---|
288 | sec_pdata ,
|
---|
289 | sec_other ,
|
---|
290 | sec_rsrc ,
|
---|
291 | sec_stab ,
|
---|
292 | sec_reloc ,
|
---|
293 | sec_last
|
---|
294 | };
|
---|
295 |
|
---|
296 | static const DWORD pe_sec_flags[] = {
|
---|
297 | 0x60000020, /* ".text" , */
|
---|
298 | 0xC0000040, /* ".data" , */
|
---|
299 | 0xC0000080, /* ".bss" , */
|
---|
300 | 0x40000040, /* ".idata" , */
|
---|
301 | 0x40000040, /* ".pdata" , */
|
---|
302 | 0xE0000060, /* < other > , */
|
---|
303 | 0x40000040, /* ".rsrc" , */
|
---|
304 | 0x42000802, /* ".stab" , */
|
---|
305 | 0x42000040, /* ".reloc" , */
|
---|
306 | };
|
---|
307 |
|
---|
308 | struct section_info {
|
---|
309 | int cls, ord;
|
---|
310 | char name[32];
|
---|
311 | DWORD sh_addr;
|
---|
312 | DWORD sh_size;
|
---|
313 | DWORD sh_flags;
|
---|
314 | unsigned char *data;
|
---|
315 | DWORD data_size;
|
---|
316 | IMAGE_SECTION_HEADER ish;
|
---|
317 | };
|
---|
318 |
|
---|
319 | struct import_symbol {
|
---|
320 | int sym_index;
|
---|
321 | int iat_index;
|
---|
322 | int thk_offset;
|
---|
323 | };
|
---|
324 |
|
---|
325 | struct pe_import_info {
|
---|
326 | int dll_index;
|
---|
327 | int sym_count;
|
---|
328 | struct import_symbol **symbols;
|
---|
329 | };
|
---|
330 |
|
---|
331 | struct pe_info {
|
---|
332 | TCCState *s1;
|
---|
333 | Section *reloc;
|
---|
334 | Section *thunk;
|
---|
335 | const char *filename;
|
---|
336 | int type;
|
---|
337 | DWORD sizeofheaders;
|
---|
338 | ADDR3264 imagebase;
|
---|
339 | DWORD start_addr;
|
---|
340 | DWORD imp_offs;
|
---|
341 | DWORD imp_size;
|
---|
342 | DWORD iat_offs;
|
---|
343 | DWORD iat_size;
|
---|
344 | DWORD exp_offs;
|
---|
345 | DWORD exp_size;
|
---|
346 | int subsystem;
|
---|
347 | DWORD section_align;
|
---|
348 | DWORD file_align;
|
---|
349 | struct section_info *sec_info;
|
---|
350 | int sec_count;
|
---|
351 | struct pe_import_info **imp_info;
|
---|
352 | int imp_count;
|
---|
353 | };
|
---|
354 |
|
---|
355 | #define PE_NUL 0
|
---|
356 | #define PE_DLL 1
|
---|
357 | #define PE_GUI 2
|
---|
358 | #define PE_EXE 3
|
---|
359 | #define PE_RUN 4
|
---|
360 |
|
---|
361 | /* --------------------------------------------*/
|
---|
362 |
|
---|
363 | static const char *pe_export_name(TCCState *s1, ElfW(Sym) *sym)
|
---|
364 | {
|
---|
365 | const char *name = symtab_section->link->data + sym->st_name;
|
---|
366 | if (s1->leading_underscore && name[0] == '_' && !(sym->st_other & 2))
|
---|
367 | return name + 1;
|
---|
368 | return name;
|
---|
369 | }
|
---|
370 |
|
---|
371 | static int pe_find_import(TCCState * s1, ElfW(Sym) *sym)
|
---|
372 | {
|
---|
373 | char buffer[200];
|
---|
374 | const char *s, *p;
|
---|
375 | int sym_index = 0, n = 0;
|
---|
376 |
|
---|
377 | do {
|
---|
378 | s = pe_export_name(s1, sym);
|
---|
379 | if (n) {
|
---|
380 | /* second try: */
|
---|
381 | if (sym->st_other & 2) {
|
---|
382 | /* try w/0 stdcall deco (windows API convention) */
|
---|
383 | p = strrchr(s, '@');
|
---|
384 | if (!p || s[0] != '_')
|
---|
385 | break;
|
---|
386 | strcpy(buffer, s+1)[p-s-1] = 0;
|
---|
387 | } else if (s[0] != '_') { /* try non-ansi function */
|
---|
388 | buffer[0] = '_', strcpy(buffer + 1, s);
|
---|
389 | } else if (0 == memcmp(s, "__imp__", 7)) { /* mingw 2.0 */
|
---|
390 | strcpy(buffer, s + 6);
|
---|
391 | } else if (0 == memcmp(s, "_imp___", 7)) { /* mingw 3.7 */
|
---|
392 | strcpy(buffer, s + 6);
|
---|
393 | } else {
|
---|
394 | break;
|
---|
395 | }
|
---|
396 | s = buffer;
|
---|
397 | }
|
---|
398 | sym_index = find_elf_sym(s1->dynsymtab_section, s);
|
---|
399 | // printf("find (%d) %d %s\n", n, sym_index, s);
|
---|
400 | } while (0 == sym_index && ++n < 2);
|
---|
401 | return sym_index;
|
---|
402 | }
|
---|
403 |
|
---|
404 | /*----------------------------------------------------------------------------*/
|
---|
405 |
|
---|
406 | static int dynarray_assoc(void **pp, int n, int key)
|
---|
407 | {
|
---|
408 | int i;
|
---|
409 | for (i = 0; i < n; ++i, ++pp)
|
---|
410 | if (key == **(int **) pp)
|
---|
411 | return i;
|
---|
412 | return -1;
|
---|
413 | }
|
---|
414 |
|
---|
415 | #if 0
|
---|
416 | ST_FN DWORD umin(DWORD a, DWORD b)
|
---|
417 | {
|
---|
418 | return a < b ? a : b;
|
---|
419 | }
|
---|
420 | #endif
|
---|
421 |
|
---|
422 | static DWORD umax(DWORD a, DWORD b)
|
---|
423 | {
|
---|
424 | return a < b ? b : a;
|
---|
425 | }
|
---|
426 |
|
---|
427 | static DWORD pe_file_align(struct pe_info *pe, DWORD n)
|
---|
428 | {
|
---|
429 | return (n + (pe->file_align - 1)) & ~(pe->file_align - 1);
|
---|
430 | }
|
---|
431 |
|
---|
432 | static DWORD pe_virtual_align(struct pe_info *pe, DWORD n)
|
---|
433 | {
|
---|
434 | return (n + (pe->section_align - 1)) & ~(pe->section_align - 1);
|
---|
435 | }
|
---|
436 |
|
---|
437 | static void pe_align_section(Section *s, int a)
|
---|
438 | {
|
---|
439 | int i = s->data_offset & (a-1);
|
---|
440 | if (i)
|
---|
441 | section_ptr_add(s, a - i);
|
---|
442 | }
|
---|
443 |
|
---|
444 | static void pe_set_datadir(struct pe_header *hdr, int dir, DWORD addr, DWORD size)
|
---|
445 | {
|
---|
446 | hdr->opthdr.DataDirectory[dir].VirtualAddress = addr;
|
---|
447 | hdr->opthdr.DataDirectory[dir].Size = size;
|
---|
448 | }
|
---|
449 |
|
---|
450 | static int pe_fwrite(void *data, unsigned len, FILE *fp, DWORD *psum)
|
---|
451 | {
|
---|
452 | if (psum) {
|
---|
453 | DWORD sum = *psum;
|
---|
454 | WORD *p = data;
|
---|
455 | int i;
|
---|
456 | for (i = len; i > 0; i -= 2) {
|
---|
457 | sum += (i >= 2) ? *p++ : *(BYTE*)p;
|
---|
458 | sum = (sum + (sum >> 16)) & 0xFFFF;
|
---|
459 | }
|
---|
460 | *psum = sum;
|
---|
461 | }
|
---|
462 | return len == fwrite(data, 1, len, fp) ? 0 : -1;
|
---|
463 | }
|
---|
464 |
|
---|
465 | static void pe_fpad(FILE *fp, DWORD new_pos)
|
---|
466 | {
|
---|
467 | DWORD pos = ftell(fp);
|
---|
468 | while (++pos <= new_pos)
|
---|
469 | fputc(0, fp);
|
---|
470 | }
|
---|
471 |
|
---|
472 | /*----------------------------------------------------------------------------*/
|
---|
473 | static int pe_write(struct pe_info *pe)
|
---|
474 | {
|
---|
475 | static const struct pe_header pe_template = {
|
---|
476 | {
|
---|
477 | /* IMAGE_DOS_HEADER doshdr */
|
---|
478 | 0x5A4D, /*WORD e_magic; Magic number */
|
---|
479 | 0x0090, /*WORD e_cblp; Bytes on last page of file */
|
---|
480 | 0x0003, /*WORD e_cp; Pages in file */
|
---|
481 | 0x0000, /*WORD e_crlc; Relocations */
|
---|
482 |
|
---|
483 | 0x0004, /*WORD e_cparhdr; Size of header in paragraphs */
|
---|
484 | 0x0000, /*WORD e_minalloc; Minimum extra paragraphs needed */
|
---|
485 | 0xFFFF, /*WORD e_maxalloc; Maximum extra paragraphs needed */
|
---|
486 | 0x0000, /*WORD e_ss; Initial (relative) SS value */
|
---|
487 |
|
---|
488 | 0x00B8, /*WORD e_sp; Initial SP value */
|
---|
489 | 0x0000, /*WORD e_csum; Checksum */
|
---|
490 | 0x0000, /*WORD e_ip; Initial IP value */
|
---|
491 | 0x0000, /*WORD e_cs; Initial (relative) CS value */
|
---|
492 | 0x0040, /*WORD e_lfarlc; File address of relocation table */
|
---|
493 | 0x0000, /*WORD e_ovno; Overlay number */
|
---|
494 | {0,0,0,0}, /*WORD e_res[4]; Reserved words */
|
---|
495 | 0x0000, /*WORD e_oemid; OEM identifier (for e_oeminfo) */
|
---|
496 | 0x0000, /*WORD e_oeminfo; OEM information; e_oemid specific */
|
---|
497 | {0,0,0,0,0,0,0,0,0,0}, /*WORD e_res2[10]; Reserved words */
|
---|
498 | 0x00000080 /*DWORD e_lfanew; File address of new exe header */
|
---|
499 | },{
|
---|
500 | /* BYTE dosstub[0x40] */
|
---|
501 | /* 14 code bytes + "This program cannot be run in DOS mode.\r\r\n$" + 6 * 0x00 */
|
---|
502 | 0x0e,0x1f,0xba,0x0e,0x00,0xb4,0x09,0xcd,0x21,0xb8,0x01,0x4c,0xcd,0x21,0x54,0x68,
|
---|
503 | 0x69,0x73,0x20,0x70,0x72,0x6f,0x67,0x72,0x61,0x6d,0x20,0x63,0x61,0x6e,0x6e,0x6f,
|
---|
504 | 0x74,0x20,0x62,0x65,0x20,0x72,0x75,0x6e,0x20,0x69,0x6e,0x20,0x44,0x4f,0x53,0x20,
|
---|
505 | 0x6d,0x6f,0x64,0x65,0x2e,0x0d,0x0d,0x0a,0x24,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
|
---|
506 | },
|
---|
507 | 0x00004550, /* DWORD nt_sig = IMAGE_NT_SIGNATURE */
|
---|
508 | {
|
---|
509 | /* IMAGE_FILE_HEADER filehdr */
|
---|
510 | #if defined(TCC_TARGET_I386)
|
---|
511 | 0x014C, /*WORD Machine; */
|
---|
512 | #elif defined(TCC_TARGET_X86_64)
|
---|
513 | 0x8664, /*WORD Machine; */
|
---|
514 | #elif defined(TCC_TARGET_ARM)
|
---|
515 | 0x01C0, /*WORD Machine; */
|
---|
516 | #endif
|
---|
517 | 0x0003, /*WORD NumberOfSections; */
|
---|
518 | 0x00000000, /*DWORD TimeDateStamp; */
|
---|
519 | 0x00000000, /*DWORD PointerToSymbolTable; */
|
---|
520 | 0x00000000, /*DWORD NumberOfSymbols; */
|
---|
521 | #if defined(TCC_TARGET_X86_64)
|
---|
522 | 0x00F0, /*WORD SizeOfOptionalHeader; */
|
---|
523 | 0x022F /*WORD Characteristics; */
|
---|
524 | #define CHARACTERISTICS_DLL 0x222E
|
---|
525 | #elif defined(TCC_TARGET_I386)
|
---|
526 | 0x00E0, /*WORD SizeOfOptionalHeader; */
|
---|
527 | 0x030F /*WORD Characteristics; */
|
---|
528 | #define CHARACTERISTICS_DLL 0x230E
|
---|
529 | #elif defined(TCC_TARGET_ARM)
|
---|
530 | 0x00E0, /*WORD SizeOfOptionalHeader; */
|
---|
531 | 0x010F, /*WORD Characteristics; */
|
---|
532 | #define CHARACTERISTICS_DLL 0x230F
|
---|
533 | #endif
|
---|
534 | },{
|
---|
535 | /* IMAGE_OPTIONAL_HEADER opthdr */
|
---|
536 | /* Standard fields. */
|
---|
537 | #ifdef TCC_TARGET_X86_64
|
---|
538 | 0x020B, /*WORD Magic; */
|
---|
539 | #else
|
---|
540 | 0x010B, /*WORD Magic; */
|
---|
541 | #endif
|
---|
542 | 0x06, /*BYTE MajorLinkerVersion; */
|
---|
543 | 0x00, /*BYTE MinorLinkerVersion; */
|
---|
544 | 0x00000000, /*DWORD SizeOfCode; */
|
---|
545 | 0x00000000, /*DWORD SizeOfInitializedData; */
|
---|
546 | 0x00000000, /*DWORD SizeOfUninitializedData; */
|
---|
547 | 0x00000000, /*DWORD AddressOfEntryPoint; */
|
---|
548 | 0x00000000, /*DWORD BaseOfCode; */
|
---|
549 | #ifndef TCC_TARGET_X86_64
|
---|
550 | 0x00000000, /*DWORD BaseOfData; */
|
---|
551 | #endif
|
---|
552 | /* NT additional fields. */
|
---|
553 | #if defined(TCC_TARGET_ARM)
|
---|
554 | 0x00100000, /*DWORD ImageBase; */
|
---|
555 | #else
|
---|
556 | 0x00400000, /*DWORD ImageBase; */
|
---|
557 | #endif
|
---|
558 | 0x00001000, /*DWORD SectionAlignment; */
|
---|
559 | 0x00000200, /*DWORD FileAlignment; */
|
---|
560 | 0x0004, /*WORD MajorOperatingSystemVersion; */
|
---|
561 | 0x0000, /*WORD MinorOperatingSystemVersion; */
|
---|
562 | 0x0000, /*WORD MajorImageVersion; */
|
---|
563 | 0x0000, /*WORD MinorImageVersion; */
|
---|
564 | 0x0004, /*WORD MajorSubsystemVersion; */
|
---|
565 | 0x0000, /*WORD MinorSubsystemVersion; */
|
---|
566 | 0x00000000, /*DWORD Win32VersionValue; */
|
---|
567 | 0x00000000, /*DWORD SizeOfImage; */
|
---|
568 | 0x00000200, /*DWORD SizeOfHeaders; */
|
---|
569 | 0x00000000, /*DWORD CheckSum; */
|
---|
570 | 0x0002, /*WORD Subsystem; */
|
---|
571 | 0x0000, /*WORD DllCharacteristics; */
|
---|
572 | 0x00100000, /*DWORD SizeOfStackReserve; */
|
---|
573 | 0x00001000, /*DWORD SizeOfStackCommit; */
|
---|
574 | 0x00100000, /*DWORD SizeOfHeapReserve; */
|
---|
575 | 0x00001000, /*DWORD SizeOfHeapCommit; */
|
---|
576 | 0x00000000, /*DWORD LoaderFlags; */
|
---|
577 | 0x00000010, /*DWORD NumberOfRvaAndSizes; */
|
---|
578 |
|
---|
579 | /* IMAGE_DATA_DIRECTORY DataDirectory[16]; */
|
---|
580 | {{0,0}, {0,0}, {0,0}, {0,0}, {0,0}, {0,0}, {0,0}, {0,0},
|
---|
581 | {0,0}, {0,0}, {0,0}, {0,0}, {0,0}, {0,0}, {0,0}, {0,0}}
|
---|
582 | }};
|
---|
583 |
|
---|
584 | struct pe_header pe_header = pe_template;
|
---|
585 |
|
---|
586 | int i;
|
---|
587 | FILE *op;
|
---|
588 | DWORD file_offset, sum;
|
---|
589 | struct section_info *si;
|
---|
590 | IMAGE_SECTION_HEADER *psh;
|
---|
591 |
|
---|
592 | op = fopen(pe->filename, "wb");
|
---|
593 | if (NULL == op) {
|
---|
594 | tcc_error_noabort("could not write '%s': %s", pe->filename, strerror(errno));
|
---|
595 | return -1;
|
---|
596 | }
|
---|
597 |
|
---|
598 | pe->sizeofheaders = pe_file_align(pe,
|
---|
599 | sizeof (struct pe_header)
|
---|
600 | + pe->sec_count * sizeof (IMAGE_SECTION_HEADER)
|
---|
601 | );
|
---|
602 |
|
---|
603 | file_offset = pe->sizeofheaders;
|
---|
604 |
|
---|
605 | if (2 == pe->s1->verbose)
|
---|
606 | printf("-------------------------------"
|
---|
607 | "\n virt file size section" "\n");
|
---|
608 | for (i = 0; i < pe->sec_count; ++i) {
|
---|
609 | DWORD addr, size;
|
---|
610 | const char *sh_name;
|
---|
611 |
|
---|
612 | si = pe->sec_info + i;
|
---|
613 | sh_name = si->name;
|
---|
614 | addr = si->sh_addr - pe->imagebase;
|
---|
615 | size = si->sh_size;
|
---|
616 | psh = &si->ish;
|
---|
617 |
|
---|
618 | if (2 == pe->s1->verbose)
|
---|
619 | printf("%6x %6x %6x %s\n",
|
---|
620 | (unsigned)addr, (unsigned)file_offset, (unsigned)size, sh_name);
|
---|
621 |
|
---|
622 | switch (si->cls) {
|
---|
623 | case sec_text:
|
---|
624 | pe_header.opthdr.BaseOfCode = addr;
|
---|
625 | pe_header.opthdr.AddressOfEntryPoint = addr + pe->start_addr;
|
---|
626 | break;
|
---|
627 |
|
---|
628 | case sec_data:
|
---|
629 | #ifndef TCC_TARGET_X86_64
|
---|
630 | pe_header.opthdr.BaseOfData = addr;
|
---|
631 | #endif
|
---|
632 | break;
|
---|
633 |
|
---|
634 | case sec_bss:
|
---|
635 | break;
|
---|
636 |
|
---|
637 | case sec_reloc:
|
---|
638 | pe_set_datadir(&pe_header, IMAGE_DIRECTORY_ENTRY_BASERELOC, addr, size);
|
---|
639 | break;
|
---|
640 |
|
---|
641 | case sec_rsrc:
|
---|
642 | pe_set_datadir(&pe_header, IMAGE_DIRECTORY_ENTRY_RESOURCE, addr, size);
|
---|
643 | break;
|
---|
644 |
|
---|
645 | case sec_pdata:
|
---|
646 | pe_set_datadir(&pe_header, IMAGE_DIRECTORY_ENTRY_EXCEPTION, addr, size);
|
---|
647 | break;
|
---|
648 |
|
---|
649 | case sec_stab:
|
---|
650 | break;
|
---|
651 | }
|
---|
652 |
|
---|
653 | if (pe->thunk == pe->s1->sections[si->ord]) {
|
---|
654 | if (pe->imp_size) {
|
---|
655 | pe_set_datadir(&pe_header, IMAGE_DIRECTORY_ENTRY_IMPORT,
|
---|
656 | pe->imp_offs + addr, pe->imp_size);
|
---|
657 | pe_set_datadir(&pe_header, IMAGE_DIRECTORY_ENTRY_IAT,
|
---|
658 | pe->iat_offs + addr, pe->iat_size);
|
---|
659 | }
|
---|
660 | if (pe->exp_size) {
|
---|
661 | pe_set_datadir(&pe_header, IMAGE_DIRECTORY_ENTRY_EXPORT,
|
---|
662 | pe->exp_offs + addr, pe->exp_size);
|
---|
663 | }
|
---|
664 | }
|
---|
665 |
|
---|
666 | pstrcpy((char*)psh->Name, sizeof psh->Name, sh_name);
|
---|
667 |
|
---|
668 | psh->Characteristics = pe_sec_flags[si->cls];
|
---|
669 | psh->VirtualAddress = addr;
|
---|
670 | psh->Misc.VirtualSize = size;
|
---|
671 | pe_header.opthdr.SizeOfImage =
|
---|
672 | umax(pe_virtual_align(pe, size + addr), pe_header.opthdr.SizeOfImage);
|
---|
673 |
|
---|
674 | if (si->data_size) {
|
---|
675 | psh->PointerToRawData = file_offset;
|
---|
676 | file_offset = pe_file_align(pe, file_offset + si->data_size);
|
---|
677 | psh->SizeOfRawData = file_offset - psh->PointerToRawData;
|
---|
678 | }
|
---|
679 | }
|
---|
680 |
|
---|
681 | //pe_header.filehdr.TimeDateStamp = time(NULL);
|
---|
682 | pe_header.filehdr.NumberOfSections = pe->sec_count;
|
---|
683 | pe_header.opthdr.SizeOfHeaders = pe->sizeofheaders;
|
---|
684 | pe_header.opthdr.ImageBase = pe->imagebase;
|
---|
685 | pe_header.opthdr.Subsystem = pe->subsystem;
|
---|
686 | if (pe->s1->pe_stack_size)
|
---|
687 | pe_header.opthdr.SizeOfStackReserve = pe->s1->pe_stack_size;
|
---|
688 | if (PE_DLL == pe->type)
|
---|
689 | pe_header.filehdr.Characteristics = CHARACTERISTICS_DLL;
|
---|
690 |
|
---|
691 | sum = 0;
|
---|
692 | pe_fwrite(&pe_header, sizeof pe_header, op, &sum);
|
---|
693 | for (i = 0; i < pe->sec_count; ++i)
|
---|
694 | pe_fwrite(&pe->sec_info[i].ish, sizeof(IMAGE_SECTION_HEADER), op, &sum);
|
---|
695 | pe_fpad(op, pe->sizeofheaders);
|
---|
696 | for (i = 0; i < pe->sec_count; ++i) {
|
---|
697 | si = pe->sec_info + i;
|
---|
698 | psh = &si->ish;
|
---|
699 | if (si->data_size) {
|
---|
700 | pe_fwrite(si->data, si->data_size, op, &sum);
|
---|
701 | file_offset = psh->PointerToRawData + psh->SizeOfRawData;
|
---|
702 | pe_fpad(op, file_offset);
|
---|
703 | }
|
---|
704 | }
|
---|
705 |
|
---|
706 | pe_header.opthdr.CheckSum = sum + file_offset;
|
---|
707 | fseek(op, offsetof(struct pe_header, opthdr.CheckSum), SEEK_SET);
|
---|
708 | pe_fwrite(&pe_header.opthdr.CheckSum, sizeof pe_header.opthdr.CheckSum, op, NULL);
|
---|
709 | fclose (op);
|
---|
710 |
|
---|
711 | if (2 == pe->s1->verbose)
|
---|
712 | printf("-------------------------------\n");
|
---|
713 | if (pe->s1->verbose)
|
---|
714 | printf("<- %s (%u bytes)\n", pe->filename, (unsigned)file_offset);
|
---|
715 |
|
---|
716 | return 0;
|
---|
717 | }
|
---|
718 |
|
---|
719 | /*----------------------------------------------------------------------------*/
|
---|
720 |
|
---|
721 | #if defined(TCC_TARGET_X86_64)
|
---|
722 | #define REL_TYPE_DIRECT R_X86_64_64
|
---|
723 | #define R_XXX_THUNKFIX R_X86_64_PC32
|
---|
724 | #define R_XXX_RELATIVE R_X86_64_RELATIVE
|
---|
725 |
|
---|
726 | #elif defined(TCC_TARGET_I386)
|
---|
727 | #define REL_TYPE_DIRECT R_386_32
|
---|
728 | #define R_XXX_THUNKFIX R_386_32
|
---|
729 | #define R_XXX_RELATIVE R_386_RELATIVE
|
---|
730 |
|
---|
731 | #elif defined(TCC_TARGET_ARM)
|
---|
732 | #define REL_TYPE_DIRECT R_ARM_ABS32
|
---|
733 | #define R_XXX_THUNKFIX R_ARM_ABS32
|
---|
734 | #define R_XXX_RELATIVE R_ARM_RELATIVE
|
---|
735 |
|
---|
736 | #endif
|
---|
737 | /*----------------------------------------------------------------------------*/
|
---|
738 |
|
---|
739 | static struct import_symbol *pe_add_import(struct pe_info *pe, int sym_index)
|
---|
740 | {
|
---|
741 | int i;
|
---|
742 | int dll_index;
|
---|
743 | struct pe_import_info *p;
|
---|
744 | struct import_symbol *s;
|
---|
745 | ElfW(Sym) *isym;
|
---|
746 |
|
---|
747 | isym = (ElfW(Sym) *)pe->s1->dynsymtab_section->data + sym_index;
|
---|
748 | dll_index = isym->st_size;
|
---|
749 |
|
---|
750 | i = dynarray_assoc ((void**)pe->imp_info, pe->imp_count, dll_index);
|
---|
751 | if (-1 != i) {
|
---|
752 | p = pe->imp_info[i];
|
---|
753 | goto found_dll;
|
---|
754 | }
|
---|
755 | p = tcc_mallocz(sizeof *p);
|
---|
756 | p->dll_index = dll_index;
|
---|
757 | dynarray_add((void***)&pe->imp_info, &pe->imp_count, p);
|
---|
758 |
|
---|
759 | found_dll:
|
---|
760 | i = dynarray_assoc ((void**)p->symbols, p->sym_count, sym_index);
|
---|
761 | if (-1 != i)
|
---|
762 | return p->symbols[i];
|
---|
763 |
|
---|
764 | s = tcc_mallocz(sizeof *s);
|
---|
765 | dynarray_add((void***)&p->symbols, &p->sym_count, s);
|
---|
766 | s->sym_index = sym_index;
|
---|
767 | return s;
|
---|
768 | }
|
---|
769 |
|
---|
770 | /*----------------------------------------------------------------------------*/
|
---|
771 | static void pe_build_imports(struct pe_info *pe)
|
---|
772 | {
|
---|
773 | int thk_ptr, ent_ptr, dll_ptr, sym_cnt, i;
|
---|
774 | DWORD rva_base = pe->thunk->sh_addr - pe->imagebase;
|
---|
775 | int ndlls = pe->imp_count;
|
---|
776 |
|
---|
777 | for (sym_cnt = i = 0; i < ndlls; ++i)
|
---|
778 | sym_cnt += pe->imp_info[i]->sym_count;
|
---|
779 |
|
---|
780 | if (0 == sym_cnt)
|
---|
781 | return;
|
---|
782 |
|
---|
783 | pe_align_section(pe->thunk, 16);
|
---|
784 |
|
---|
785 | pe->imp_offs = dll_ptr = pe->thunk->data_offset;
|
---|
786 | pe->imp_size = (ndlls + 1) * sizeof(IMAGE_IMPORT_DESCRIPTOR);
|
---|
787 | pe->iat_offs = dll_ptr + pe->imp_size;
|
---|
788 | pe->iat_size = (sym_cnt + ndlls) * sizeof(ADDR3264);
|
---|
789 | section_ptr_add(pe->thunk, pe->imp_size + 2*pe->iat_size);
|
---|
790 |
|
---|
791 | thk_ptr = pe->iat_offs;
|
---|
792 | ent_ptr = pe->iat_offs + pe->iat_size;
|
---|
793 |
|
---|
794 | for (i = 0; i < pe->imp_count; ++i) {
|
---|
795 | IMAGE_IMPORT_DESCRIPTOR *hdr;
|
---|
796 | int k, n, dllindex;
|
---|
797 | ADDR3264 v;
|
---|
798 | struct pe_import_info *p = pe->imp_info[i];
|
---|
799 | const char *name;
|
---|
800 | DLLReference *dllref;
|
---|
801 |
|
---|
802 | dllindex = p->dll_index;
|
---|
803 | if (dllindex)
|
---|
804 | name = (dllref = pe->s1->loaded_dlls[dllindex-1])->name;
|
---|
805 | else
|
---|
806 | name = "", dllref = NULL;
|
---|
807 |
|
---|
808 | /* put the dll name into the import header */
|
---|
809 | v = put_elf_str(pe->thunk, name);
|
---|
810 | hdr = (IMAGE_IMPORT_DESCRIPTOR*)(pe->thunk->data + dll_ptr);
|
---|
811 | hdr->FirstThunk = thk_ptr + rva_base;
|
---|
812 | hdr->OriginalFirstThunk = ent_ptr + rva_base;
|
---|
813 | hdr->Name = v + rva_base;
|
---|
814 |
|
---|
815 | for (k = 0, n = p->sym_count; k <= n; ++k) {
|
---|
816 | if (k < n) {
|
---|
817 | int iat_index = p->symbols[k]->iat_index;
|
---|
818 | int sym_index = p->symbols[k]->sym_index;
|
---|
819 | ElfW(Sym) *imp_sym = (ElfW(Sym) *)pe->s1->dynsymtab_section->data + sym_index;
|
---|
820 | ElfW(Sym) *org_sym = (ElfW(Sym) *)symtab_section->data + iat_index;
|
---|
821 | const char *name = pe->s1->dynsymtab_section->link->data + imp_sym->st_name;
|
---|
822 |
|
---|
823 | org_sym->st_value = thk_ptr;
|
---|
824 | org_sym->st_shndx = pe->thunk->sh_num;
|
---|
825 | v = pe->thunk->data_offset + rva_base;
|
---|
826 | section_ptr_add(pe->thunk, sizeof(WORD)); /* hint, not used */
|
---|
827 | put_elf_str(pe->thunk, name);
|
---|
828 | #ifdef TCC_IS_NATIVE
|
---|
829 | if (pe->type == PE_RUN) {
|
---|
830 | v = imp_sym->st_value;
|
---|
831 | if (dllref) {
|
---|
832 | if ( !dllref->handle )
|
---|
833 | dllref->handle = LoadLibrary(dllref->name);
|
---|
834 | v = (ADDR3264)GetProcAddress(dllref->handle, name);
|
---|
835 | }
|
---|
836 | if (!v)
|
---|
837 | tcc_error_noabort("undefined symbol '%s'", name);
|
---|
838 | }
|
---|
839 | #endif
|
---|
840 | } else {
|
---|
841 | v = 0; /* last entry is zero */
|
---|
842 | }
|
---|
843 | *(ADDR3264*)(pe->thunk->data+thk_ptr) =
|
---|
844 | *(ADDR3264*)(pe->thunk->data+ent_ptr) = v;
|
---|
845 | thk_ptr += sizeof (ADDR3264);
|
---|
846 | ent_ptr += sizeof (ADDR3264);
|
---|
847 | }
|
---|
848 | dll_ptr += sizeof(IMAGE_IMPORT_DESCRIPTOR);
|
---|
849 | dynarray_reset(&p->symbols, &p->sym_count);
|
---|
850 | }
|
---|
851 | dynarray_reset(&pe->imp_info, &pe->imp_count);
|
---|
852 | }
|
---|
853 |
|
---|
854 | /* ------------------------------------------------------------- */
|
---|
855 |
|
---|
856 | struct pe_sort_sym
|
---|
857 | {
|
---|
858 | int index;
|
---|
859 | const char *name;
|
---|
860 | };
|
---|
861 |
|
---|
862 | static int sym_cmp(const void *va, const void *vb)
|
---|
863 | {
|
---|
864 | const char *ca = (*(struct pe_sort_sym**)va)->name;
|
---|
865 | const char *cb = (*(struct pe_sort_sym**)vb)->name;
|
---|
866 | return strcmp(ca, cb);
|
---|
867 | }
|
---|
868 |
|
---|
869 | static void pe_build_exports(struct pe_info *pe)
|
---|
870 | {
|
---|
871 | ElfW(Sym) *sym;
|
---|
872 | int sym_index, sym_end;
|
---|
873 | DWORD rva_base, func_o, name_o, ord_o, str_o;
|
---|
874 | IMAGE_EXPORT_DIRECTORY *hdr;
|
---|
875 | int sym_count, ord;
|
---|
876 | struct pe_sort_sym **sorted, *p;
|
---|
877 |
|
---|
878 | FILE *op;
|
---|
879 | char buf[MAX_PATH];
|
---|
880 | const char *dllname;
|
---|
881 | const char *name;
|
---|
882 |
|
---|
883 | rva_base = pe->thunk->sh_addr - pe->imagebase;
|
---|
884 | sym_count = 0, sorted = NULL, op = NULL;
|
---|
885 |
|
---|
886 | sym_end = symtab_section->data_offset / sizeof(ElfW(Sym));
|
---|
887 | for (sym_index = 1; sym_index < sym_end; ++sym_index) {
|
---|
888 | sym = (ElfW(Sym)*)symtab_section->data + sym_index;
|
---|
889 | name = pe_export_name(pe->s1, sym);
|
---|
890 | if ((sym->st_other & 1)
|
---|
891 | /* export only symbols from actually written sections */
|
---|
892 | && pe->s1->sections[sym->st_shndx]->sh_addr) {
|
---|
893 | p = tcc_malloc(sizeof *p);
|
---|
894 | p->index = sym_index;
|
---|
895 | p->name = name;
|
---|
896 | dynarray_add((void***)&sorted, &sym_count, p);
|
---|
897 | }
|
---|
898 | #if 0
|
---|
899 | if (sym->st_other & 1)
|
---|
900 | printf("export: %s\n", name);
|
---|
901 | if (sym->st_other & 2)
|
---|
902 | printf("stdcall: %s\n", name);
|
---|
903 | #endif
|
---|
904 | }
|
---|
905 |
|
---|
906 | if (0 == sym_count)
|
---|
907 | return;
|
---|
908 |
|
---|
909 | qsort (sorted, sym_count, sizeof *sorted, sym_cmp);
|
---|
910 |
|
---|
911 | pe_align_section(pe->thunk, 16);
|
---|
912 | dllname = tcc_basename(pe->filename);
|
---|
913 |
|
---|
914 | pe->exp_offs = pe->thunk->data_offset;
|
---|
915 | func_o = pe->exp_offs + sizeof(IMAGE_EXPORT_DIRECTORY);
|
---|
916 | name_o = func_o + sym_count * sizeof (DWORD);
|
---|
917 | ord_o = name_o + sym_count * sizeof (DWORD);
|
---|
918 | str_o = ord_o + sym_count * sizeof(WORD);
|
---|
919 |
|
---|
920 | hdr = section_ptr_add(pe->thunk, str_o - pe->exp_offs);
|
---|
921 | hdr->Characteristics = 0;
|
---|
922 | hdr->Base = 1;
|
---|
923 | hdr->NumberOfFunctions = sym_count;
|
---|
924 | hdr->NumberOfNames = sym_count;
|
---|
925 | hdr->AddressOfFunctions = func_o + rva_base;
|
---|
926 | hdr->AddressOfNames = name_o + rva_base;
|
---|
927 | hdr->AddressOfNameOrdinals = ord_o + rva_base;
|
---|
928 | hdr->Name = str_o + rva_base;
|
---|
929 | put_elf_str(pe->thunk, dllname);
|
---|
930 |
|
---|
931 | #if 1
|
---|
932 | /* automatically write exports to <output-filename>.def */
|
---|
933 | pstrcpy(buf, sizeof buf, pe->filename);
|
---|
934 | strcpy(tcc_fileextension(buf), ".def");
|
---|
935 | op = fopen(buf, "w");
|
---|
936 | if (NULL == op) {
|
---|
937 | tcc_error_noabort("could not create '%s': %s", buf, strerror(errno));
|
---|
938 | } else {
|
---|
939 | fprintf(op, "LIBRARY %s\n\nEXPORTS\n", dllname);
|
---|
940 | if (pe->s1->verbose)
|
---|
941 | printf("<- %s (%d symbols)\n", buf, sym_count);
|
---|
942 | }
|
---|
943 | #endif
|
---|
944 |
|
---|
945 | for (ord = 0; ord < sym_count; ++ord)
|
---|
946 | {
|
---|
947 | p = sorted[ord], sym_index = p->index, name = p->name;
|
---|
948 | /* insert actual address later in pe_relocate_rva */
|
---|
949 | put_elf_reloc(symtab_section, pe->thunk,
|
---|
950 | func_o, R_XXX_RELATIVE, sym_index);
|
---|
951 | *(DWORD*)(pe->thunk->data + name_o)
|
---|
952 | = pe->thunk->data_offset + rva_base;
|
---|
953 | *(WORD*)(pe->thunk->data + ord_o)
|
---|
954 | = ord;
|
---|
955 | put_elf_str(pe->thunk, name);
|
---|
956 | func_o += sizeof (DWORD);
|
---|
957 | name_o += sizeof (DWORD);
|
---|
958 | ord_o += sizeof (WORD);
|
---|
959 | if (op)
|
---|
960 | fprintf(op, "%s\n", name);
|
---|
961 | }
|
---|
962 | pe->exp_size = pe->thunk->data_offset - pe->exp_offs;
|
---|
963 | dynarray_reset(&sorted, &sym_count);
|
---|
964 | if (op)
|
---|
965 | fclose(op);
|
---|
966 | }
|
---|
967 |
|
---|
968 | /* ------------------------------------------------------------- */
|
---|
969 | static void pe_build_reloc (struct pe_info *pe)
|
---|
970 | {
|
---|
971 | DWORD offset, block_ptr, addr;
|
---|
972 | int count, i;
|
---|
973 | ElfW_Rel *rel, *rel_end;
|
---|
974 | Section *s = NULL, *sr;
|
---|
975 |
|
---|
976 | offset = addr = block_ptr = count = i = 0;
|
---|
977 | rel = rel_end = NULL;
|
---|
978 |
|
---|
979 | for(;;) {
|
---|
980 | if (rel < rel_end) {
|
---|
981 | int type = ELFW(R_TYPE)(rel->r_info);
|
---|
982 | addr = rel->r_offset + s->sh_addr;
|
---|
983 | ++ rel;
|
---|
984 | if (type != REL_TYPE_DIRECT)
|
---|
985 | continue;
|
---|
986 | if (count == 0) { /* new block */
|
---|
987 | block_ptr = pe->reloc->data_offset;
|
---|
988 | section_ptr_add(pe->reloc, sizeof(struct pe_reloc_header));
|
---|
989 | offset = addr & 0xFFFFFFFF<<12;
|
---|
990 | }
|
---|
991 | if ((addr -= offset) < (1<<12)) { /* one block spans 4k addresses */
|
---|
992 | WORD *wp = section_ptr_add(pe->reloc, sizeof (WORD));
|
---|
993 | *wp = addr | IMAGE_REL_BASED_HIGHLOW<<12;
|
---|
994 | ++count;
|
---|
995 | continue;
|
---|
996 | }
|
---|
997 | -- rel;
|
---|
998 |
|
---|
999 | } else if (i < pe->sec_count) {
|
---|
1000 | sr = (s = pe->s1->sections[pe->sec_info[i++].ord])->reloc;
|
---|
1001 | if (sr) {
|
---|
1002 | rel = (ElfW_Rel *)sr->data;
|
---|
1003 | rel_end = (ElfW_Rel *)(sr->data + sr->data_offset);
|
---|
1004 | }
|
---|
1005 | continue;
|
---|
1006 | }
|
---|
1007 |
|
---|
1008 | if (count) {
|
---|
1009 | /* store the last block and ready for a new one */
|
---|
1010 | struct pe_reloc_header *hdr;
|
---|
1011 | if (count & 1) /* align for DWORDS */
|
---|
1012 | section_ptr_add(pe->reloc, sizeof(WORD)), ++count;
|
---|
1013 | hdr = (struct pe_reloc_header *)(pe->reloc->data + block_ptr);
|
---|
1014 | hdr -> offset = offset - pe->imagebase;
|
---|
1015 | hdr -> size = count * sizeof(WORD) + sizeof(struct pe_reloc_header);
|
---|
1016 | count = 0;
|
---|
1017 | }
|
---|
1018 |
|
---|
1019 | if (rel >= rel_end)
|
---|
1020 | break;
|
---|
1021 | }
|
---|
1022 | }
|
---|
1023 |
|
---|
1024 | /* ------------------------------------------------------------- */
|
---|
1025 | static int pe_section_class(Section *s)
|
---|
1026 | {
|
---|
1027 | int type, flags;
|
---|
1028 | const char *name;
|
---|
1029 |
|
---|
1030 | type = s->sh_type;
|
---|
1031 | flags = s->sh_flags;
|
---|
1032 | name = s->name;
|
---|
1033 | if (flags & SHF_ALLOC) {
|
---|
1034 | if (type == SHT_PROGBITS) {
|
---|
1035 | if (flags & SHF_EXECINSTR)
|
---|
1036 | return sec_text;
|
---|
1037 | if (flags & SHF_WRITE)
|
---|
1038 | return sec_data;
|
---|
1039 | if (0 == strcmp(name, ".rsrc"))
|
---|
1040 | return sec_rsrc;
|
---|
1041 | if (0 == strcmp(name, ".iedat"))
|
---|
1042 | return sec_idata;
|
---|
1043 | if (0 == strcmp(name, ".pdata"))
|
---|
1044 | return sec_pdata;
|
---|
1045 | return sec_other;
|
---|
1046 | } else if (type == SHT_NOBITS) {
|
---|
1047 | if (flags & SHF_WRITE)
|
---|
1048 | return sec_bss;
|
---|
1049 | }
|
---|
1050 | } else {
|
---|
1051 | if (0 == strcmp(name, ".reloc"))
|
---|
1052 | return sec_reloc;
|
---|
1053 | if (0 == strncmp(name, ".stab", 5)) /* .stab and .stabstr */
|
---|
1054 | return sec_stab;
|
---|
1055 | }
|
---|
1056 | return -1;
|
---|
1057 | }
|
---|
1058 |
|
---|
1059 | static int pe_assign_addresses (struct pe_info *pe)
|
---|
1060 | {
|
---|
1061 | int i, k, o, c;
|
---|
1062 | DWORD addr;
|
---|
1063 | int *section_order;
|
---|
1064 | struct section_info *si;
|
---|
1065 | Section *s;
|
---|
1066 |
|
---|
1067 | // pe->thunk = new_section(pe->s1, ".iedat", SHT_PROGBITS, SHF_ALLOC);
|
---|
1068 |
|
---|
1069 | section_order = tcc_malloc(pe->s1->nb_sections * sizeof (int));
|
---|
1070 | for (o = k = 0 ; k < sec_last; ++k) {
|
---|
1071 | for (i = 1; i < pe->s1->nb_sections; ++i) {
|
---|
1072 | s = pe->s1->sections[i];
|
---|
1073 | if (k == pe_section_class(s)) {
|
---|
1074 | // printf("%s %d\n", s->name, k);
|
---|
1075 | s->sh_addr = pe->imagebase;
|
---|
1076 | section_order[o++] = i;
|
---|
1077 | }
|
---|
1078 | }
|
---|
1079 | }
|
---|
1080 |
|
---|
1081 | pe->sec_info = tcc_mallocz(o * sizeof (struct section_info));
|
---|
1082 | addr = pe->imagebase + 1;
|
---|
1083 |
|
---|
1084 | for (i = 0; i < o; ++i)
|
---|
1085 | {
|
---|
1086 | k = section_order[i];
|
---|
1087 | s = pe->s1->sections[k];
|
---|
1088 | c = pe_section_class(s);
|
---|
1089 | si = &pe->sec_info[pe->sec_count];
|
---|
1090 |
|
---|
1091 | #ifdef PE_MERGE_DATA
|
---|
1092 | if (c == sec_bss && pe->sec_count && si[-1].cls == sec_data) {
|
---|
1093 | /* append .bss to .data */
|
---|
1094 | s->sh_addr = addr = ((addr-1) | (s->sh_addralign-1)) + 1;
|
---|
1095 | addr += s->data_offset;
|
---|
1096 | si[-1].sh_size = addr - si[-1].sh_addr;
|
---|
1097 | continue;
|
---|
1098 | }
|
---|
1099 | #endif
|
---|
1100 | if (c == sec_stab && 0 == pe->s1->do_debug)
|
---|
1101 | continue;
|
---|
1102 |
|
---|
1103 | strcpy(si->name, s->name);
|
---|
1104 | si->cls = c;
|
---|
1105 | si->ord = k;
|
---|
1106 | si->sh_addr = s->sh_addr = addr = pe_virtual_align(pe, addr);
|
---|
1107 | si->sh_flags = s->sh_flags;
|
---|
1108 |
|
---|
1109 | if (c == sec_data && NULL == pe->thunk)
|
---|
1110 | pe->thunk = s;
|
---|
1111 |
|
---|
1112 | if (s == pe->thunk) {
|
---|
1113 | pe_build_imports(pe);
|
---|
1114 | pe_build_exports(pe);
|
---|
1115 | }
|
---|
1116 |
|
---|
1117 | if (c == sec_reloc)
|
---|
1118 | pe_build_reloc (pe);
|
---|
1119 |
|
---|
1120 | if (s->data_offset)
|
---|
1121 | {
|
---|
1122 | if (s->sh_type != SHT_NOBITS) {
|
---|
1123 | si->data = s->data;
|
---|
1124 | si->data_size = s->data_offset;
|
---|
1125 | }
|
---|
1126 |
|
---|
1127 | addr += s->data_offset;
|
---|
1128 | si->sh_size = s->data_offset;
|
---|
1129 | ++pe->sec_count;
|
---|
1130 | }
|
---|
1131 | // printf("%08x %05x %s\n", si->sh_addr, si->sh_size, si->name);
|
---|
1132 | }
|
---|
1133 |
|
---|
1134 | #if 0
|
---|
1135 | for (i = 1; i < pe->s1->nb_sections; ++i) {
|
---|
1136 | Section *s = pe->s1->sections[i];
|
---|
1137 | int type = s->sh_type;
|
---|
1138 | int flags = s->sh_flags;
|
---|
1139 | printf("section %-16s %-10s %5x %s,%s,%s\n",
|
---|
1140 | s->name,
|
---|
1141 | type == SHT_PROGBITS ? "progbits" :
|
---|
1142 | type == SHT_NOBITS ? "nobits" :
|
---|
1143 | type == SHT_SYMTAB ? "symtab" :
|
---|
1144 | type == SHT_STRTAB ? "strtab" :
|
---|
1145 | type == SHT_RELX ? "rel" : "???",
|
---|
1146 | s->data_offset,
|
---|
1147 | flags & SHF_ALLOC ? "alloc" : "",
|
---|
1148 | flags & SHF_WRITE ? "write" : "",
|
---|
1149 | flags & SHF_EXECINSTR ? "exec" : ""
|
---|
1150 | );
|
---|
1151 | }
|
---|
1152 | pe->s1->verbose = 2;
|
---|
1153 | #endif
|
---|
1154 |
|
---|
1155 | tcc_free(section_order);
|
---|
1156 | return 0;
|
---|
1157 | }
|
---|
1158 |
|
---|
1159 | /* ------------------------------------------------------------- */
|
---|
1160 | static void pe_relocate_rva (struct pe_info *pe, Section *s)
|
---|
1161 | {
|
---|
1162 | Section *sr = s->reloc;
|
---|
1163 | ElfW_Rel *rel, *rel_end;
|
---|
1164 | rel_end = (ElfW_Rel *)(sr->data + sr->data_offset);
|
---|
1165 | for(rel = (ElfW_Rel *)sr->data; rel < rel_end; rel++) {
|
---|
1166 | if (ELFW(R_TYPE)(rel->r_info) == R_XXX_RELATIVE) {
|
---|
1167 | int sym_index = ELFW(R_SYM)(rel->r_info);
|
---|
1168 | DWORD addr = s->sh_addr;
|
---|
1169 | if (sym_index) {
|
---|
1170 | ElfW(Sym) *sym = (ElfW(Sym) *)symtab_section->data + sym_index;
|
---|
1171 | addr = sym->st_value;
|
---|
1172 | }
|
---|
1173 | // printf("reloc rva %08x %08x %s\n", (DWORD)rel->r_offset, addr, s->name);
|
---|
1174 | *(DWORD*)(s->data + rel->r_offset) += addr - pe->imagebase;
|
---|
1175 | }
|
---|
1176 | }
|
---|
1177 | }
|
---|
1178 |
|
---|
1179 | /*----------------------------------------------------------------------------*/
|
---|
1180 |
|
---|
1181 | static int pe_isafunc(int sym_index)
|
---|
1182 | {
|
---|
1183 | Section *sr = text_section->reloc;
|
---|
1184 | ElfW_Rel *rel, *rel_end;
|
---|
1185 | Elf32_Word info = ELF32_R_INFO(sym_index, R_386_PC32);
|
---|
1186 | if (!sr)
|
---|
1187 | return 0;
|
---|
1188 | rel_end = (ElfW_Rel *)(sr->data + sr->data_offset);
|
---|
1189 | for (rel = (ElfW_Rel *)sr->data; rel < rel_end; rel++)
|
---|
1190 | if (rel->r_info == info)
|
---|
1191 | return 1;
|
---|
1192 | return 0;
|
---|
1193 | }
|
---|
1194 |
|
---|
1195 | /*----------------------------------------------------------------------------*/
|
---|
1196 | static int pe_check_symbols(struct pe_info *pe)
|
---|
1197 | {
|
---|
1198 | ElfW(Sym) *sym;
|
---|
1199 | int sym_index, sym_end;
|
---|
1200 | int ret = 0;
|
---|
1201 |
|
---|
1202 | pe_align_section(text_section, 8);
|
---|
1203 |
|
---|
1204 | sym_end = symtab_section->data_offset / sizeof(ElfW(Sym));
|
---|
1205 | for (sym_index = 1; sym_index < sym_end; ++sym_index) {
|
---|
1206 |
|
---|
1207 | sym = (ElfW(Sym) *)symtab_section->data + sym_index;
|
---|
1208 | if (sym->st_shndx == SHN_UNDEF) {
|
---|
1209 |
|
---|
1210 | const char *name = symtab_section->link->data + sym->st_name;
|
---|
1211 | unsigned type = ELFW(ST_TYPE)(sym->st_info);
|
---|
1212 | int imp_sym = pe_find_import(pe->s1, sym);
|
---|
1213 | struct import_symbol *is;
|
---|
1214 |
|
---|
1215 | if (0 == imp_sym)
|
---|
1216 | goto not_found;
|
---|
1217 |
|
---|
1218 | if (type == STT_NOTYPE) {
|
---|
1219 | /* symbols from assembler have no type, find out which */
|
---|
1220 | if (pe_isafunc(sym_index))
|
---|
1221 | type = STT_FUNC;
|
---|
1222 | else
|
---|
1223 | type = STT_OBJECT;
|
---|
1224 | }
|
---|
1225 |
|
---|
1226 | is = pe_add_import(pe, imp_sym);
|
---|
1227 |
|
---|
1228 | if (type == STT_FUNC) {
|
---|
1229 | unsigned long offset = is->thk_offset;
|
---|
1230 | if (offset) {
|
---|
1231 | /* got aliased symbol, like stricmp and _stricmp */
|
---|
1232 |
|
---|
1233 | } else {
|
---|
1234 | char buffer[100];
|
---|
1235 | WORD *p;
|
---|
1236 |
|
---|
1237 | offset = text_section->data_offset;
|
---|
1238 | /* add the 'jmp IAT[x]' instruction */
|
---|
1239 | #ifdef TCC_TARGET_ARM
|
---|
1240 | p = section_ptr_add(text_section, 8+4); // room for code and address
|
---|
1241 | (*(DWORD*)(p)) = 0xE59FC000; // arm code ldr ip, [pc] ; PC+8+0 = 0001xxxx
|
---|
1242 | (*(DWORD*)(p+2)) = 0xE59CF000; // arm code ldr pc, [ip]
|
---|
1243 | #else
|
---|
1244 | p = section_ptr_add(text_section, 8);
|
---|
1245 | *p = 0x25FF;
|
---|
1246 | #ifdef TCC_TARGET_X86_64
|
---|
1247 | *(DWORD*)(p+1) = (DWORD)-4;
|
---|
1248 | #endif
|
---|
1249 | #endif
|
---|
1250 | /* add a helper symbol, will be patched later in
|
---|
1251 | pe_build_imports */
|
---|
1252 | sprintf(buffer, "IAT.%s", name);
|
---|
1253 | is->iat_index = put_elf_sym(
|
---|
1254 | symtab_section, 0, sizeof(DWORD),
|
---|
1255 | ELFW(ST_INFO)(STB_GLOBAL, STT_OBJECT),
|
---|
1256 | 0, SHN_UNDEF, buffer);
|
---|
1257 | #ifdef TCC_TARGET_ARM
|
---|
1258 | put_elf_reloc(symtab_section, text_section,
|
---|
1259 | offset + 8, R_XXX_THUNKFIX, is->iat_index); // offset to IAT position
|
---|
1260 | #else
|
---|
1261 | put_elf_reloc(symtab_section, text_section,
|
---|
1262 | offset + 2, R_XXX_THUNKFIX, is->iat_index);
|
---|
1263 | #endif
|
---|
1264 | is->thk_offset = offset;
|
---|
1265 | }
|
---|
1266 |
|
---|
1267 | /* tcc_realloc might have altered sym's address */
|
---|
1268 | sym = (ElfW(Sym) *)symtab_section->data + sym_index;
|
---|
1269 |
|
---|
1270 | /* patch the original symbol */
|
---|
1271 | sym->st_value = offset;
|
---|
1272 | sym->st_shndx = text_section->sh_num;
|
---|
1273 | sym->st_other &= ~1; /* do not export */
|
---|
1274 | continue;
|
---|
1275 | }
|
---|
1276 |
|
---|
1277 | if (type == STT_OBJECT) { /* data, ptr to that should be */
|
---|
1278 | if (0 == is->iat_index) {
|
---|
1279 | /* original symbol will be patched later in pe_build_imports */
|
---|
1280 | is->iat_index = sym_index;
|
---|
1281 | continue;
|
---|
1282 | }
|
---|
1283 | }
|
---|
1284 |
|
---|
1285 | not_found:
|
---|
1286 | tcc_error_noabort("undefined symbol '%s'", name);
|
---|
1287 | ret = -1;
|
---|
1288 |
|
---|
1289 | } else if (pe->s1->rdynamic
|
---|
1290 | && ELFW(ST_BIND)(sym->st_info) != STB_LOCAL) {
|
---|
1291 | /* if -rdynamic option, then export all non local symbols */
|
---|
1292 | sym->st_other |= 1;
|
---|
1293 | }
|
---|
1294 | }
|
---|
1295 | return ret;
|
---|
1296 | }
|
---|
1297 |
|
---|
1298 | /*----------------------------------------------------------------------------*/
|
---|
1299 | #ifdef PE_PRINT_SECTIONS
|
---|
1300 | static void pe_print_section(FILE * f, Section * s)
|
---|
1301 | {
|
---|
1302 | /* just if you'r curious */
|
---|
1303 | BYTE *p, *e, b;
|
---|
1304 | int i, n, l, m;
|
---|
1305 | p = s->data;
|
---|
1306 | e = s->data + s->data_offset;
|
---|
1307 | l = e - p;
|
---|
1308 |
|
---|
1309 | fprintf(f, "section \"%s\"", s->name);
|
---|
1310 | if (s->link)
|
---|
1311 | fprintf(f, "\nlink \"%s\"", s->link->name);
|
---|
1312 | if (s->reloc)
|
---|
1313 | fprintf(f, "\nreloc \"%s\"", s->reloc->name);
|
---|
1314 | fprintf(f, "\nv_addr %08X", (unsigned)s->sh_addr);
|
---|
1315 | fprintf(f, "\ncontents %08X", (unsigned)l);
|
---|
1316 | fprintf(f, "\n\n");
|
---|
1317 |
|
---|
1318 | if (s->sh_type == SHT_NOBITS)
|
---|
1319 | return;
|
---|
1320 |
|
---|
1321 | if (0 == l)
|
---|
1322 | return;
|
---|
1323 |
|
---|
1324 | if (s->sh_type == SHT_SYMTAB)
|
---|
1325 | m = sizeof(ElfW(Sym));
|
---|
1326 | else if (s->sh_type == SHT_RELX)
|
---|
1327 | m = sizeof(ElfW_Rel);
|
---|
1328 | else
|
---|
1329 | m = 16;
|
---|
1330 |
|
---|
1331 | fprintf(f, "%-8s", "offset");
|
---|
1332 | for (i = 0; i < m; ++i)
|
---|
1333 | fprintf(f, " %02x", i);
|
---|
1334 | n = 56;
|
---|
1335 |
|
---|
1336 | if (s->sh_type == SHT_SYMTAB || s->sh_type == SHT_RELX) {
|
---|
1337 | const char *fields1[] = {
|
---|
1338 | "name",
|
---|
1339 | "value",
|
---|
1340 | "size",
|
---|
1341 | "bind",
|
---|
1342 | "type",
|
---|
1343 | "other",
|
---|
1344 | "shndx",
|
---|
1345 | NULL
|
---|
1346 | };
|
---|
1347 |
|
---|
1348 | const char *fields2[] = {
|
---|
1349 | "offs",
|
---|
1350 | "type",
|
---|
1351 | "symb",
|
---|
1352 | NULL
|
---|
1353 | };
|
---|
1354 |
|
---|
1355 | const char **p;
|
---|
1356 |
|
---|
1357 | if (s->sh_type == SHT_SYMTAB)
|
---|
1358 | p = fields1, n = 106;
|
---|
1359 | else
|
---|
1360 | p = fields2, n = 58;
|
---|
1361 |
|
---|
1362 | for (i = 0; p[i]; ++i)
|
---|
1363 | fprintf(f, "%6s", p[i]);
|
---|
1364 | fprintf(f, " symbol");
|
---|
1365 | }
|
---|
1366 |
|
---|
1367 | fprintf(f, "\n");
|
---|
1368 | for (i = 0; i < n; ++i)
|
---|
1369 | fprintf(f, "-");
|
---|
1370 | fprintf(f, "\n");
|
---|
1371 |
|
---|
1372 | for (i = 0; i < l;)
|
---|
1373 | {
|
---|
1374 | fprintf(f, "%08X", i);
|
---|
1375 | for (n = 0; n < m; ++n) {
|
---|
1376 | if (n + i < l)
|
---|
1377 | fprintf(f, " %02X", p[i + n]);
|
---|
1378 | else
|
---|
1379 | fprintf(f, " ");
|
---|
1380 | }
|
---|
1381 |
|
---|
1382 | if (s->sh_type == SHT_SYMTAB) {
|
---|
1383 | ElfW(Sym) *sym = (ElfW(Sym) *) (p + i);
|
---|
1384 | const char *name = s->link->data + sym->st_name;
|
---|
1385 | fprintf(f, " %04X %04X %04X %02X %02X %02X %04X \"%s\"",
|
---|
1386 | (unsigned)sym->st_name,
|
---|
1387 | (unsigned)sym->st_value,
|
---|
1388 | (unsigned)sym->st_size,
|
---|
1389 | (unsigned)ELFW(ST_BIND)(sym->st_info),
|
---|
1390 | (unsigned)ELFW(ST_TYPE)(sym->st_info),
|
---|
1391 | (unsigned)sym->st_other,
|
---|
1392 | (unsigned)sym->st_shndx,
|
---|
1393 | name);
|
---|
1394 |
|
---|
1395 | } else if (s->sh_type == SHT_RELX) {
|
---|
1396 | ElfW_Rel *rel = (ElfW_Rel *) (p + i);
|
---|
1397 | ElfW(Sym) *sym =
|
---|
1398 | (ElfW(Sym) *) s->link->data + ELFW(R_SYM)(rel->r_info);
|
---|
1399 | const char *name = s->link->link->data + sym->st_name;
|
---|
1400 | fprintf(f, " %04X %02X %04X \"%s\"",
|
---|
1401 | (unsigned)rel->r_offset,
|
---|
1402 | (unsigned)ELFW(R_TYPE)(rel->r_info),
|
---|
1403 | (unsigned)ELFW(R_SYM)(rel->r_info),
|
---|
1404 | name);
|
---|
1405 | } else {
|
---|
1406 | fprintf(f, " ");
|
---|
1407 | for (n = 0; n < m; ++n) {
|
---|
1408 | if (n + i < l) {
|
---|
1409 | b = p[i + n];
|
---|
1410 | if (b < 32 || b >= 127)
|
---|
1411 | b = '.';
|
---|
1412 | fprintf(f, "%c", b);
|
---|
1413 | }
|
---|
1414 | }
|
---|
1415 | }
|
---|
1416 | i += m;
|
---|
1417 | fprintf(f, "\n");
|
---|
1418 | }
|
---|
1419 | fprintf(f, "\n\n");
|
---|
1420 | }
|
---|
1421 |
|
---|
1422 | static void pe_print_sections(TCCState *s1, const char *fname)
|
---|
1423 | {
|
---|
1424 | Section *s;
|
---|
1425 | FILE *f;
|
---|
1426 | int i;
|
---|
1427 | f = fopen(fname, "w");
|
---|
1428 | for (i = 1; i < s1->nb_sections; ++i) {
|
---|
1429 | s = s1->sections[i];
|
---|
1430 | pe_print_section(f, s);
|
---|
1431 | }
|
---|
1432 | pe_print_section(f, s1->dynsymtab_section);
|
---|
1433 | fclose(f);
|
---|
1434 | }
|
---|
1435 | #endif
|
---|
1436 |
|
---|
1437 | /* ------------------------------------------------------------- */
|
---|
1438 | /* helper function for load/store to insert one more indirection */
|
---|
1439 |
|
---|
1440 | ST_FUNC SValue *pe_getimport(SValue *sv, SValue *v2)
|
---|
1441 | {
|
---|
1442 | Sym *sym;
|
---|
1443 | ElfW(Sym) *esym;
|
---|
1444 | int r2;
|
---|
1445 |
|
---|
1446 | if ((sv->r & (VT_VALMASK|VT_SYM)) != (VT_CONST|VT_SYM) || (sv->r2 != VT_CONST))
|
---|
1447 | return sv;
|
---|
1448 | sym = sv->sym;
|
---|
1449 | if ((sym->type.t & (VT_EXTERN|VT_STATIC)) != VT_EXTERN)
|
---|
1450 | return sv;
|
---|
1451 | if (!sym->c)
|
---|
1452 | put_extern_sym(sym, NULL, 0, 0);
|
---|
1453 | esym = &((ElfW(Sym) *)symtab_section->data)[sym->c];
|
---|
1454 | if (!(esym->st_other & 4))
|
---|
1455 | return sv;
|
---|
1456 |
|
---|
1457 | // printf("import %04x %04x %04x %s\n", sv->type.t, sym->type.t, sv->r, get_tok_str(sv->sym->v, NULL));
|
---|
1458 |
|
---|
1459 | memset(v2, 0, sizeof *v2);
|
---|
1460 | v2->type.t = VT_PTR;
|
---|
1461 | v2->r = VT_CONST | VT_SYM | VT_LVAL;
|
---|
1462 | v2->sym = sv->sym;
|
---|
1463 |
|
---|
1464 | r2 = get_reg(RC_INT);
|
---|
1465 | load(r2, v2);
|
---|
1466 | v2->r = r2;
|
---|
1467 |
|
---|
1468 | if (sv->c.ui) {
|
---|
1469 | vpushv(v2);
|
---|
1470 | vpushi(sv->c.ui);
|
---|
1471 | gen_opi('+');
|
---|
1472 | *v2 = *vtop--;
|
---|
1473 | }
|
---|
1474 |
|
---|
1475 | v2->type.t = sv->type.t;
|
---|
1476 | v2->r |= sv->r & VT_LVAL;
|
---|
1477 | return v2;
|
---|
1478 | }
|
---|
1479 |
|
---|
1480 | ST_FUNC int pe_putimport(TCCState *s1, int dllindex, const char *name, addr_t value)
|
---|
1481 | {
|
---|
1482 | return add_elf_sym(
|
---|
1483 | s1->dynsymtab_section,
|
---|
1484 | value,
|
---|
1485 | dllindex, /* st_size */
|
---|
1486 | ELFW(ST_INFO)(STB_GLOBAL, STT_NOTYPE),
|
---|
1487 | 0,
|
---|
1488 | value ? SHN_ABS : SHN_UNDEF,
|
---|
1489 | name
|
---|
1490 | );
|
---|
1491 | }
|
---|
1492 |
|
---|
1493 | static int add_dllref(TCCState *s1, const char *dllname)
|
---|
1494 | {
|
---|
1495 | DLLReference *dllref;
|
---|
1496 | int i;
|
---|
1497 | for (i = 0; i < s1->nb_loaded_dlls; ++i)
|
---|
1498 | if (0 == strcmp(s1->loaded_dlls[i]->name, dllname))
|
---|
1499 | return i + 1;
|
---|
1500 | dllref = tcc_mallocz(sizeof(DLLReference) + strlen(dllname));
|
---|
1501 | strcpy(dllref->name, dllname);
|
---|
1502 | dynarray_add((void ***) &s1->loaded_dlls, &s1->nb_loaded_dlls, dllref);
|
---|
1503 | return s1->nb_loaded_dlls;
|
---|
1504 | }
|
---|
1505 |
|
---|
1506 | /* ------------------------------------------------------------- */
|
---|
1507 |
|
---|
1508 | static int read_mem(int fd, unsigned offset, void *buffer, unsigned len)
|
---|
1509 | {
|
---|
1510 | lseek(fd, offset, SEEK_SET);
|
---|
1511 | return len == read(fd, buffer, len);
|
---|
1512 | }
|
---|
1513 |
|
---|
1514 | /* -------------------------------------------------------------
|
---|
1515 | * This is for compiled windows resources in 'coff' format
|
---|
1516 | * as generated by 'windres.exe -O coff ...'.
|
---|
1517 | */
|
---|
1518 |
|
---|
1519 | static int pe_load_res(TCCState *s1, int fd)
|
---|
1520 | {
|
---|
1521 | struct pe_rsrc_header hdr;
|
---|
1522 | Section *rsrc_section;
|
---|
1523 | int i, ret = -1;
|
---|
1524 | BYTE *ptr;
|
---|
1525 | unsigned offs;
|
---|
1526 |
|
---|
1527 | if (!read_mem(fd, 0, &hdr, sizeof hdr))
|
---|
1528 | goto quit;
|
---|
1529 |
|
---|
1530 | if (hdr.filehdr.Machine != 0x014C
|
---|
1531 | || hdr.filehdr.NumberOfSections != 1
|
---|
1532 | || strcmp(hdr.sectionhdr.Name, ".rsrc") != 0)
|
---|
1533 | goto quit;
|
---|
1534 |
|
---|
1535 | rsrc_section = new_section(s1, ".rsrc", SHT_PROGBITS, SHF_ALLOC);
|
---|
1536 | ptr = section_ptr_add(rsrc_section, hdr.sectionhdr.SizeOfRawData);
|
---|
1537 | offs = hdr.sectionhdr.PointerToRawData;
|
---|
1538 | if (!read_mem(fd, offs, ptr, hdr.sectionhdr.SizeOfRawData))
|
---|
1539 | goto quit;
|
---|
1540 | offs = hdr.sectionhdr.PointerToRelocations;
|
---|
1541 | for (i = 0; i < hdr.sectionhdr.NumberOfRelocations; ++i)
|
---|
1542 | {
|
---|
1543 | struct pe_rsrc_reloc rel;
|
---|
1544 | if (!read_mem(fd, offs, &rel, sizeof rel))
|
---|
1545 | goto quit;
|
---|
1546 | // printf("rsrc_reloc: %x %x %x\n", rel.offset, rel.size, rel.type);
|
---|
1547 | if (rel.type != 7) /* DIR32NB */
|
---|
1548 | goto quit;
|
---|
1549 | put_elf_reloc(symtab_section, rsrc_section,
|
---|
1550 | rel.offset, R_XXX_RELATIVE, 0);
|
---|
1551 | offs += sizeof rel;
|
---|
1552 | }
|
---|
1553 | ret = 0;
|
---|
1554 | quit:
|
---|
1555 | return ret;
|
---|
1556 | }
|
---|
1557 |
|
---|
1558 | /* ------------------------------------------------------------- */
|
---|
1559 | static char *trimfront(char *p)
|
---|
1560 | {
|
---|
1561 | while (*p && (unsigned char)*p <= ' ')
|
---|
1562 | ++p;
|
---|
1563 | return p;
|
---|
1564 | }
|
---|
1565 |
|
---|
1566 | static char *trimback(char *a, char *e)
|
---|
1567 | {
|
---|
1568 | while (e > a && (unsigned char)e[-1] <= ' ')
|
---|
1569 | --e;
|
---|
1570 | *e = 0;;
|
---|
1571 | return a;
|
---|
1572 | }
|
---|
1573 |
|
---|
1574 | static char *get_line(char *line, int size, int fd)
|
---|
1575 | {
|
---|
1576 | int n;
|
---|
1577 | for (n = 0; n < size - 1; )
|
---|
1578 | if (read(fd, line + n, 1) < 1 || line[n++] == '\n')
|
---|
1579 | break;
|
---|
1580 | if (0 == n)
|
---|
1581 | return NULL;
|
---|
1582 | trimback(line, line + n);
|
---|
1583 | return trimfront(line);
|
---|
1584 | }
|
---|
1585 |
|
---|
1586 | /* ------------------------------------------------------------- */
|
---|
1587 | static int pe_load_def(TCCState *s1, int fd)
|
---|
1588 | {
|
---|
1589 | int state = 0, ret = -1, dllindex = 0;
|
---|
1590 | char line[400], dllname[80], *p;
|
---|
1591 |
|
---|
1592 | for (;;) {
|
---|
1593 | p = get_line(line, sizeof line, fd);
|
---|
1594 | if (NULL == p)
|
---|
1595 | break;
|
---|
1596 | if (0 == *p || ';' == *p)
|
---|
1597 | continue;
|
---|
1598 | switch (state) {
|
---|
1599 | case 0:
|
---|
1600 | if (0 != strnicmp(p, "LIBRARY", 7))
|
---|
1601 | goto quit;
|
---|
1602 | pstrcpy(dllname, sizeof dllname, trimfront(p+7));
|
---|
1603 | ++state;
|
---|
1604 | continue;
|
---|
1605 |
|
---|
1606 | case 1:
|
---|
1607 | if (0 != stricmp(p, "EXPORTS"))
|
---|
1608 | goto quit;
|
---|
1609 | ++state;
|
---|
1610 | continue;
|
---|
1611 |
|
---|
1612 | case 2:
|
---|
1613 | dllindex = add_dllref(s1, dllname);
|
---|
1614 | ++state;
|
---|
1615 |
|
---|
1616 | default:
|
---|
1617 | pe_putimport(s1, dllindex, p, 0);
|
---|
1618 | continue;
|
---|
1619 | }
|
---|
1620 | }
|
---|
1621 | ret = 0;
|
---|
1622 | quit:
|
---|
1623 | return ret;
|
---|
1624 | }
|
---|
1625 |
|
---|
1626 | /* ------------------------------------------------------------- */
|
---|
1627 | #define TINY_IMPDEF_GET_EXPORT_NAMES_ONLY
|
---|
1628 | #include "win32/tools/tiny_impdef.c"
|
---|
1629 |
|
---|
1630 | static int pe_load_dll(TCCState *s1, const char *dllname, int fd)
|
---|
1631 | {
|
---|
1632 | char *p, *q;
|
---|
1633 | int index;
|
---|
1634 | p = get_export_names(fd);
|
---|
1635 | if (!p)
|
---|
1636 | return -1;
|
---|
1637 | index = add_dllref(s1, dllname);
|
---|
1638 | for (q = p; *q; q += 1 + strlen(q))
|
---|
1639 | pe_putimport(s1, index, q, 0);
|
---|
1640 | tcc_free(p);
|
---|
1641 | return 0;
|
---|
1642 | }
|
---|
1643 |
|
---|
1644 | /* ------------------------------------------------------------- */
|
---|
1645 | ST_FUNC int pe_load_file(struct TCCState *s1, const char *filename, int fd)
|
---|
1646 | {
|
---|
1647 | int ret = -1;
|
---|
1648 | char buf[10];
|
---|
1649 | if (0 == strcmp(tcc_fileextension(filename), ".def"))
|
---|
1650 | ret = pe_load_def(s1, fd);
|
---|
1651 | else if (pe_load_res(s1, fd) == 0)
|
---|
1652 | ret = 0;
|
---|
1653 | else if (read_mem(fd, 0, buf, sizeof buf) && 0 == strncmp(buf, "MZ", 2))
|
---|
1654 | ret = pe_load_dll(s1, tcc_basename(filename), fd);
|
---|
1655 | return ret;
|
---|
1656 | }
|
---|
1657 |
|
---|
1658 | /* ------------------------------------------------------------- */
|
---|
1659 | #ifdef TCC_TARGET_X86_64
|
---|
1660 | static unsigned pe_add_uwwind_info(TCCState *s1)
|
---|
1661 | {
|
---|
1662 | if (NULL == s1->uw_pdata) {
|
---|
1663 | s1->uw_pdata = find_section(tcc_state, ".pdata");
|
---|
1664 | s1->uw_pdata->sh_addralign = 4;
|
---|
1665 | s1->uw_sym = put_elf_sym(symtab_section, 0, 0, 0, 0, text_section->sh_num, NULL);
|
---|
1666 | }
|
---|
1667 |
|
---|
1668 | if (0 == s1->uw_offs) {
|
---|
1669 | /* As our functions all have the same stackframe, we use one entry for all */
|
---|
1670 | static const unsigned char uw_info[] = {
|
---|
1671 | 0x01, // UBYTE: 3 Version , UBYTE: 5 Flags
|
---|
1672 | 0x04, // UBYTE Size of prolog
|
---|
1673 | 0x02, // UBYTE Count of unwind codes
|
---|
1674 | 0x05, // UBYTE: 4 Frame Register (rbp), UBYTE: 4 Frame Register offset (scaled)
|
---|
1675 | // USHORT * n Unwind codes array
|
---|
1676 | // 0x0b, 0x01, 0xff, 0xff, // stack size
|
---|
1677 | 0x04, 0x03, // set frame ptr (mov rsp -> rbp)
|
---|
1678 | 0x01, 0x50 // push reg (rbp)
|
---|
1679 | };
|
---|
1680 |
|
---|
1681 | Section *s = text_section;
|
---|
1682 | unsigned char *p;
|
---|
1683 |
|
---|
1684 | section_ptr_add(s, -s->data_offset & 3); /* align */
|
---|
1685 | s1->uw_offs = s->data_offset;
|
---|
1686 | p = section_ptr_add(s, sizeof uw_info);
|
---|
1687 | memcpy(p, uw_info, sizeof uw_info);
|
---|
1688 | }
|
---|
1689 |
|
---|
1690 | return s1->uw_offs;
|
---|
1691 | }
|
---|
1692 |
|
---|
1693 | ST_FUNC void pe_add_unwind_data(unsigned start, unsigned end, unsigned stack)
|
---|
1694 | {
|
---|
1695 | TCCState *s1 = tcc_state;
|
---|
1696 | Section *pd;
|
---|
1697 | unsigned o, n, d;
|
---|
1698 | struct /* _RUNTIME_FUNCTION */ {
|
---|
1699 | DWORD BeginAddress;
|
---|
1700 | DWORD EndAddress;
|
---|
1701 | DWORD UnwindData;
|
---|
1702 | } *p;
|
---|
1703 |
|
---|
1704 | d = pe_add_uwwind_info(s1);
|
---|
1705 | pd = s1->uw_pdata;
|
---|
1706 | o = pd->data_offset;
|
---|
1707 | p = section_ptr_add(pd, sizeof *p);
|
---|
1708 |
|
---|
1709 | /* record this function */
|
---|
1710 | p->BeginAddress = start;
|
---|
1711 | p->EndAddress = end;
|
---|
1712 | p->UnwindData = d;
|
---|
1713 |
|
---|
1714 | /* put relocations on it */
|
---|
1715 | for (n = o + sizeof *p; o < n; o += sizeof p->BeginAddress)
|
---|
1716 | put_elf_reloc(symtab_section, pd, o, R_X86_64_RELATIVE, s1->uw_sym);
|
---|
1717 | }
|
---|
1718 | #endif
|
---|
1719 | /* ------------------------------------------------------------- */
|
---|
1720 | #ifdef TCC_TARGET_X86_64
|
---|
1721 | #define PE_STDSYM(n,s) n
|
---|
1722 | #else
|
---|
1723 | #define PE_STDSYM(n,s) "_" n s
|
---|
1724 | #endif
|
---|
1725 |
|
---|
1726 | static void pe_add_runtime(TCCState *s1, struct pe_info *pe)
|
---|
1727 | {
|
---|
1728 | const char *start_symbol;
|
---|
1729 | ADDR3264 addr = 0;
|
---|
1730 | int pe_type = 0;
|
---|
1731 |
|
---|
1732 | if (find_elf_sym(symtab_section, PE_STDSYM("WinMain","@16")))
|
---|
1733 | pe_type = PE_GUI;
|
---|
1734 | else
|
---|
1735 | if (TCC_OUTPUT_DLL == s1->output_type) {
|
---|
1736 | pe_type = PE_DLL;
|
---|
1737 | /* need this for 'tccelf.c:relocate_section()' */
|
---|
1738 | s1->output_type = TCC_OUTPUT_EXE;
|
---|
1739 | }
|
---|
1740 | else
|
---|
1741 | pe_type = PE_EXE;
|
---|
1742 |
|
---|
1743 | start_symbol =
|
---|
1744 | TCC_OUTPUT_MEMORY == s1->output_type
|
---|
1745 | ? PE_GUI == pe_type ? "__runwinmain" : "_main"
|
---|
1746 | : PE_DLL == pe_type ? PE_STDSYM("__dllstart","@12")
|
---|
1747 | : PE_GUI == pe_type ? "__winstart" : "__start"
|
---|
1748 | ;
|
---|
1749 |
|
---|
1750 | if (!s1->leading_underscore || strchr(start_symbol, '@')) {
|
---|
1751 | ++start_symbol;
|
---|
1752 | if (start_symbol[0] != '_')
|
---|
1753 | start_symbol = NULL;
|
---|
1754 | }
|
---|
1755 |
|
---|
1756 | /* grab the startup code from libtcc1 */
|
---|
1757 | if (start_symbol)
|
---|
1758 | add_elf_sym(symtab_section,
|
---|
1759 | 0, 0,
|
---|
1760 | ELFW(ST_INFO)(STB_GLOBAL, STT_NOTYPE), 0,
|
---|
1761 | SHN_UNDEF, start_symbol);
|
---|
1762 |
|
---|
1763 | if (0 == s1->nostdlib) {
|
---|
1764 | static const char *libs[] = {
|
---|
1765 | "libtcc1.a", "msvcrt", "kernel32", "", "user32", "gdi32", NULL
|
---|
1766 | };
|
---|
1767 | const char **pp, *p;
|
---|
1768 | for (pp = libs; 0 != (p = *pp); ++pp) {
|
---|
1769 | if (0 == *p) {
|
---|
1770 | if (PE_DLL != pe_type && PE_GUI != pe_type)
|
---|
1771 | break;
|
---|
1772 | } else if (pp == libs ? tcc_add_dll(s1, p, 0) : tcc_add_library(s1, p)) {
|
---|
1773 | tcc_error_noabort("cannot find library: %s", p);
|
---|
1774 | break;
|
---|
1775 | }
|
---|
1776 | }
|
---|
1777 | }
|
---|
1778 |
|
---|
1779 | if (TCC_OUTPUT_MEMORY == s1->output_type)
|
---|
1780 | pe_type = PE_RUN;
|
---|
1781 |
|
---|
1782 | if (start_symbol) {
|
---|
1783 | addr = get_elf_sym_addr(s1, start_symbol, 1);
|
---|
1784 | if (PE_RUN == pe_type && addr)
|
---|
1785 | /* for -run GUI's, put '_runwinmain' instead of 'main' */
|
---|
1786 | add_elf_sym(symtab_section,
|
---|
1787 | addr, 0,
|
---|
1788 | ELFW(ST_INFO)(STB_GLOBAL, STT_NOTYPE), 0,
|
---|
1789 | text_section->sh_num, "main");
|
---|
1790 | }
|
---|
1791 |
|
---|
1792 | pe->type = pe_type;
|
---|
1793 | pe->start_addr = addr;
|
---|
1794 | }
|
---|
1795 |
|
---|
1796 | ST_FUNC int pe_output_file(TCCState * s1, const char *filename)
|
---|
1797 | {
|
---|
1798 | int ret;
|
---|
1799 | struct pe_info pe;
|
---|
1800 | int i;
|
---|
1801 |
|
---|
1802 | memset(&pe, 0, sizeof pe);
|
---|
1803 | pe.filename = filename;
|
---|
1804 | pe.s1 = s1;
|
---|
1805 |
|
---|
1806 | tcc_add_bcheck(s1);
|
---|
1807 | pe_add_runtime(s1, &pe);
|
---|
1808 | relocate_common_syms(); /* assign bss adresses */
|
---|
1809 | tcc_add_linker_symbols(s1);
|
---|
1810 |
|
---|
1811 | ret = pe_check_symbols(&pe);
|
---|
1812 | if (ret)
|
---|
1813 | ;
|
---|
1814 | else if (filename) {
|
---|
1815 | if (PE_DLL == pe.type) {
|
---|
1816 | pe.reloc = new_section(pe.s1, ".reloc", SHT_PROGBITS, 0);
|
---|
1817 | /* XXX: check if is correct for arm-pe target */
|
---|
1818 | pe.imagebase = 0x10000000;
|
---|
1819 | } else {
|
---|
1820 | #if defined(TCC_TARGET_ARM)
|
---|
1821 | pe.imagebase = 0x00010000;
|
---|
1822 | #else
|
---|
1823 | pe.imagebase = 0x00400000;
|
---|
1824 | #endif
|
---|
1825 | }
|
---|
1826 |
|
---|
1827 | #if defined(TCC_TARGET_ARM)
|
---|
1828 | /* we use "console" subsystem by default */
|
---|
1829 | pe.subsystem = 9;
|
---|
1830 | #else
|
---|
1831 | if (PE_DLL == pe.type || PE_GUI == pe.type)
|
---|
1832 | pe.subsystem = 2;
|
---|
1833 | else
|
---|
1834 | pe.subsystem = 3;
|
---|
1835 | #endif
|
---|
1836 | /* Allow override via -Wl,-subsystem=... option */
|
---|
1837 | if (s1->pe_subsystem != 0)
|
---|
1838 | pe.subsystem = s1->pe_subsystem;
|
---|
1839 |
|
---|
1840 | /* set default file/section alignment */
|
---|
1841 | if (pe.subsystem == 1) {
|
---|
1842 | pe.section_align = 0x20;
|
---|
1843 | pe.file_align = 0x20;
|
---|
1844 | } else {
|
---|
1845 | pe.section_align = 0x1000;
|
---|
1846 | pe.file_align = 0x200;
|
---|
1847 | }
|
---|
1848 |
|
---|
1849 | if (s1->section_align != 0)
|
---|
1850 | pe.section_align = s1->section_align;
|
---|
1851 | if (s1->pe_file_align != 0)
|
---|
1852 | pe.file_align = s1->pe_file_align;
|
---|
1853 |
|
---|
1854 | if ((pe.subsystem >= 10) && (pe.subsystem <= 12))
|
---|
1855 | pe.imagebase = 0;
|
---|
1856 |
|
---|
1857 | if (s1->has_text_addr)
|
---|
1858 | pe.imagebase = s1->text_addr;
|
---|
1859 |
|
---|
1860 | pe_assign_addresses(&pe);
|
---|
1861 | relocate_syms(s1, 0);
|
---|
1862 | for (i = 1; i < s1->nb_sections; ++i) {
|
---|
1863 | Section *s = s1->sections[i];
|
---|
1864 | if (s->reloc) {
|
---|
1865 | relocate_section(s1, s);
|
---|
1866 | pe_relocate_rva(&pe, s);
|
---|
1867 | }
|
---|
1868 | }
|
---|
1869 | if (s1->nb_errors)
|
---|
1870 | ret = -1;
|
---|
1871 | else
|
---|
1872 | ret = pe_write(&pe);
|
---|
1873 | tcc_free(pe.sec_info);
|
---|
1874 | } else {
|
---|
1875 | #ifdef TCC_IS_NATIVE
|
---|
1876 | pe.thunk = data_section;
|
---|
1877 | pe_build_imports(&pe);
|
---|
1878 | #endif
|
---|
1879 | }
|
---|
1880 |
|
---|
1881 | #ifdef PE_PRINT_SECTIONS
|
---|
1882 | pe_print_sections(s1, "tcc.log");
|
---|
1883 | #endif
|
---|
1884 | return ret;
|
---|
1885 | }
|
---|
1886 |
|
---|
1887 | /* ------------------------------------------------------------- */
|
---|