| @@ -0,0 +1,1220 @@ |
| | 1 | /* |
| | 2 | * TCCPE.C - PE file output for the TinyC Compiler |
| | 3 | * |
| | 4 | * Copyright (c) 2005 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 | typedef unsigned char BYTE; |
| | 22 | typedef unsigned short WORD; |
| | 23 | typedef unsigned long DWORD; |
| | 24 | #define ST static |
| | 25 | |
| | 26 | /* XXX: move that to TCC ? */ |
| | 27 | int verbose = 0; |
| | 28 | |
| | 29 | /* definitions below are from winnt.h */ |
| | 30 | |
| | 31 | typedef struct _IMAGE_DOS_HEADER { /* DOS .EXE header */ |
| | 32 | WORD e_magic; /* Magic number */ |
| | 33 | WORD e_cblp; /* Bytes on last page of file */ |
| | 34 | WORD e_cp; /* Pages in file */ |
| | 35 | WORD e_crlc; /* Relocations */ |
| | 36 | WORD e_cparhdr; /* Size of header in paragraphs */ |
| | 37 | WORD e_minalloc; /* Minimum extra paragraphs needed */ |
| | 38 | WORD e_maxalloc; /* Maximum extra paragraphs needed */ |
| | 39 | WORD e_ss; /* Initial (relative) SS value */ |
| | 40 | WORD e_sp; /* Initial SP value */ |
| | 41 | WORD e_csum; /* Checksum */ |
| | 42 | WORD e_ip; /* Initial IP value */ |
| | 43 | WORD e_cs; /* Initial (relative) CS value */ |
| | 44 | WORD e_lfarlc; /* File address of relocation table */ |
| | 45 | WORD e_ovno; /* Overlay number */ |
| | 46 | WORD e_res[4]; /* Reserved words */ |
| | 47 | WORD e_oemid; /* OEM identifier (for e_oeminfo) */ |
| | 48 | WORD e_oeminfo; /* OEM information; e_oemid specific */ |
| | 49 | WORD e_res2[10]; /* Reserved words */ |
| | 50 | DWORD e_lfanew; /* File address of new exe header */ |
| | 51 | BYTE e_code[0x40]; |
| | 52 | |
| | 53 | } IMAGE_DOS_HEADER, *PIMAGE_DOS_HEADER; |
| | 54 | |
| | 55 | #define IMAGE_NT_SIGNATURE 0x00004550 /* PE00 */ |
| | 56 | #define SIZE_OF_NT_SIGNATURE 4 |
| | 57 | |
| | 58 | typedef struct _IMAGE_FILE_HEADER { |
| | 59 | WORD Machine; |
| | 60 | WORD NumberOfSections; |
| | 61 | DWORD TimeDateStamp; |
| | 62 | DWORD PointerToSymbolTable; |
| | 63 | DWORD NumberOfSymbols; |
| | 64 | WORD SizeOfOptionalHeader; |
| | 65 | WORD Characteristics; |
| | 66 | } IMAGE_FILE_HEADER, *PIMAGE_FILE_HEADER; |
| | 67 | |
| | 68 | |
| | 69 | #define IMAGE_SIZEOF_FILE_HEADER 20 |
| | 70 | |
| | 71 | typedef struct _IMAGE_DATA_DIRECTORY { |
| | 72 | DWORD VirtualAddress; |
| | 73 | DWORD Size; |
| | 74 | } IMAGE_DATA_DIRECTORY, *PIMAGE_DATA_DIRECTORY; |
| | 75 | |
| | 76 | |
| | 77 | typedef struct _IMAGE_OPTIONAL_HEADER { |
| | 78 | /* Standard fields. */ |
| | 79 | WORD Magic; |
| | 80 | BYTE MajorLinkerVersion; |
| | 81 | BYTE MinorLinkerVersion; |
| | 82 | DWORD SizeOfCode; |
| | 83 | DWORD SizeOfInitializedData; |
| | 84 | DWORD SizeOfUninitializedData; |
| | 85 | DWORD AddressOfEntryPoint; |
| | 86 | DWORD BaseOfCode; |
| | 87 | DWORD BaseOfData; |
| | 88 | |
| | 89 | /* NT additional fields. */ |
| | 90 | DWORD ImageBase; |
| | 91 | DWORD SectionAlignment; |
| | 92 | DWORD FileAlignment; |
| | 93 | WORD MajorOperatingSystemVersion; |
| | 94 | WORD MinorOperatingSystemVersion; |
| | 95 | WORD MajorImageVersion; |
| | 96 | WORD MinorImageVersion; |
| | 97 | WORD MajorSubsystemVersion; |
| | 98 | WORD MinorSubsystemVersion; |
| | 99 | DWORD Win32VersionValue; |
| | 100 | DWORD SizeOfImage; |
| | 101 | DWORD SizeOfHeaders; |
| | 102 | DWORD CheckSum; |
| | 103 | WORD Subsystem; |
| | 104 | WORD DllCharacteristics; |
| | 105 | DWORD SizeOfStackReserve; |
| | 106 | DWORD SizeOfStackCommit; |
| | 107 | DWORD SizeOfHeapReserve; |
| | 108 | DWORD SizeOfHeapCommit; |
| | 109 | DWORD LoaderFlags; |
| | 110 | DWORD NumberOfRvaAndSizes; |
| | 111 | IMAGE_DATA_DIRECTORY DataDirectory[16]; |
| | 112 | |
| | 113 | } IMAGE_OPTIONAL_HEADER32, *PIMAGE_OPTIONAL_HEADER32; |
| | 114 | |
| | 115 | |
| | 116 | #define IMAGE_DIRECTORY_ENTRY_EXPORT 0 /* Export Directory */ |
| | 117 | #define IMAGE_DIRECTORY_ENTRY_IMPORT 1 /* Import Directory */ |
| | 118 | #define IMAGE_DIRECTORY_ENTRY_RESOURCE 2 /* Resource Directory */ |
| | 119 | #define IMAGE_DIRECTORY_ENTRY_EXCEPTION 3 /* Exception Directory */ |
| | 120 | #define IMAGE_DIRECTORY_ENTRY_SECURITY 4 /* Security Directory */ |
| | 121 | #define IMAGE_DIRECTORY_ENTRY_BASERELOC 5 /* Base Relocation Table */ |
| | 122 | #define IMAGE_DIRECTORY_ENTRY_DEBUG 6 /* Debug Directory */ |
| | 123 | /* IMAGE_DIRECTORY_ENTRY_COPYRIGHT 7 (X86 usage) */ |
| | 124 | #define IMAGE_DIRECTORY_ENTRY_ARCHITECTURE 7 /* Architecture Specific Data */ |
| | 125 | #define IMAGE_DIRECTORY_ENTRY_GLOBALPTR 8 /* RVA of GP */ |
| | 126 | #define IMAGE_DIRECTORY_ENTRY_TLS 9 /* TLS Directory */ |
| | 127 | #define IMAGE_DIRECTORY_ENTRY_LOAD_CONFIG 10 /* Load Configuration Directory */ |
| | 128 | #define IMAGE_DIRECTORY_ENTRY_BOUND_IMPORT 11 /* Bound Import Directory in headers */ |
| | 129 | #define IMAGE_DIRECTORY_ENTRY_IAT 12 /* Import Address Table */ |
| | 130 | #define IMAGE_DIRECTORY_ENTRY_DELAY_IMPORT 13 /* Delay Load Import Descriptors */ |
| | 131 | #define IMAGE_DIRECTORY_ENTRY_COM_DESCRIPTOR 14 /* COM Runtime descriptor */ |
| | 132 | |
| | 133 | /* Section header format. */ |
| | 134 | #define IMAGE_SIZEOF_SHORT_NAME 8 |
| | 135 | |
| | 136 | typedef struct _IMAGE_SECTION_HEADER { |
| | 137 | BYTE Name[IMAGE_SIZEOF_SHORT_NAME]; |
| | 138 | union { |
| | 139 | DWORD PhysicalAddress; |
| | 140 | DWORD VirtualSize; |
| | 141 | } Misc; |
| | 142 | DWORD VirtualAddress; |
| | 143 | DWORD SizeOfRawData; |
| | 144 | DWORD PointerToRawData; |
| | 145 | DWORD PointerToRelocations; |
| | 146 | DWORD PointerToLinenumbers; |
| | 147 | WORD NumberOfRelocations; |
| | 148 | WORD NumberOfLinenumbers; |
| | 149 | DWORD Characteristics; |
| | 150 | } IMAGE_SECTION_HEADER, *PIMAGE_SECTION_HEADER; |
| | 151 | |
| | 152 | #define IMAGE_SIZEOF_SECTION_HEADER 40 |
| | 153 | |
| | 154 | /* ----------------------------------------------------------- */ |
| | 155 | typedef struct _IMAGE_BASE_RELOCATION { |
| | 156 | DWORD VirtualAddress; |
| | 157 | DWORD SizeOfBlock; |
| | 158 | // WORD TypeOffset[1]; |
| | 159 | } IMAGE_BASE_RELOCATION; |
| | 160 | |
| | 161 | #define IMAGE_SIZEOF_BASE_RELOCATION 8 |
| | 162 | |
| | 163 | #define IMAGE_REL_BASED_ABSOLUTE 0 |
| | 164 | #define IMAGE_REL_BASED_HIGH 1 |
| | 165 | #define IMAGE_REL_BASED_LOW 2 |
| | 166 | #define IMAGE_REL_BASED_HIGHLOW 3 |
| | 167 | #define IMAGE_REL_BASED_HIGHADJ 4 |
| | 168 | #define IMAGE_REL_BASED_MIPS_JMPADDR 5 |
| | 169 | #define IMAGE_REL_BASED_SECTION 6 |
| | 170 | #define IMAGE_REL_BASED_REL32 7 |
| | 171 | |
| | 172 | /* ----------------------------------------------------------- */ |
| | 173 | |
| | 174 | /* ----------------------------------------------------------- */ |
| | 175 | IMAGE_DOS_HEADER pe_dos_hdr = { |
| | 176 | 0x5A4D, /*WORD e_magic; Magic number */ |
| | 177 | 0x0090, /*WORD e_cblp; Bytes on last page of file */ |
| | 178 | 0x0003, /*WORD e_cp; Pages in file */ |
| | 179 | 0x0000, /*WORD e_crlc; Relocations */ |
| | 180 | |
| | 181 | 0x0004, /*WORD e_cparhdr; Size of header in paragraphs */ |
| | 182 | 0x0000, /*WORD e_minalloc; Minimum extra paragraphs needed */ |
| | 183 | 0xFFFF, /*WORD e_maxalloc; Maximum extra paragraphs needed */ |
| | 184 | 0x0000, /*WORD e_ss; Initial (relative) SS value */ |
| | 185 | |
| | 186 | 0x00B8, /*WORD e_sp; Initial SP value */ |
| | 187 | 0x0000, /*WORD e_csum; Checksum */ |
| | 188 | 0x0000, /*WORD e_ip; Initial IP value */ |
| | 189 | 0x0000, /*WORD e_cs; Initial (relative) CS value */ |
| | 190 | 0x0040, /*WORD e_lfarlc; File address of relocation table */ |
| | 191 | 0x0000, /*WORD e_ovno; Overlay number */ |
| | 192 | {0, 0, 0, 0}, /*WORD e_res[4]; Reserved words */ |
| | 193 | 0x0000, /*WORD e_oemid; OEM identifier (for e_oeminfo) */ |
| | 194 | 0x0000, /*WORD e_oeminfo; OEM information; e_oemid specific */ |
| | 195 | {0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, /*WORD e_res2[10]; Reserved words */ |
| | 196 | 0x00000080, /*DWORD e_lfanew; File address of new exe header */ |
| | 197 | { /* 14 code bytes + "This program cannot be run in DOS mode.\r\r\n$" + 6 * 0x00 */ |
| | 198 | /*0040 */ 0x0e, 0x1f, 0xba, 0x0e, 0x00, 0xb4, 0x09, 0xcd, 0x21, 0xb8, |
| | 199 | 0x01, 0x4c, 0xcd, 0x21, 0x54, 0x68, |
| | 200 | /*0050 */ 0x69, 0x73, 0x20, 0x70, 0x72, 0x6f, 0x67, 0x72, 0x61, 0x6d, |
| | 201 | 0x20, 0x63, 0x61, 0x6e, 0x6e, 0x6f, |
| | 202 | /*0060 */ 0x74, 0x20, 0x62, 0x65, 0x20, 0x72, 0x75, 0x6e, 0x20, 0x69, |
| | 203 | 0x6e, 0x20, 0x44, 0x4f, 0x53, 0x20, |
| | 204 | /*0070 */ 0x6d, 0x6f, 0x64, 0x65, 0x2e, 0x0d, 0x0d, 0x0a, 0x24, 0x00, |
| | 205 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
| | 206 | /*0080 */ |
| | 207 | } |
| | 208 | }; |
| | 209 | |
| | 210 | DWORD pe_magic = IMAGE_NT_SIGNATURE; |
| | 211 | |
| | 212 | IMAGE_FILE_HEADER pe_file_hdr = { |
| | 213 | 0x014C, /*WORD Machine; */ |
| | 214 | 0x0003, /*WORD NumberOfSections; */ |
| | 215 | 0x00000000, /*DWORD TimeDateStamp; */ |
| | 216 | 0x00000000, /*DWORD PointerToSymbolTable; */ |
| | 217 | 0x00000000, /*DWORD NumberOfSymbols; */ |
| | 218 | 0x00E0, /*WORD SizeOfOptionalHeader; */ |
| | 219 | 0x030F /*WORD Characteristics; */ |
| | 220 | }; |
| | 221 | |
| | 222 | IMAGE_OPTIONAL_HEADER32 pe_opt_hdr = { |
| | 223 | /* Standard fields. */ |
| | 224 | 0x010B, /*WORD Magic; */ |
| | 225 | 0x06, /*BYTE MajorLinkerVersion; */ |
| | 226 | 0x00, /*BYTE MinorLinkerVersion; */ |
| | 227 | 0x00000000, /*DWORD SizeOfCode; */ |
| | 228 | 0x00000000, /*DWORD SizeOfInitializedData; */ |
| | 229 | 0x00000000, /*DWORD SizeOfUninitializedData; */ |
| | 230 | 0x00000000, /*DWORD AddressOfEntryPoint; */ |
| | 231 | 0x00000000, /*DWORD BaseOfCode; */ |
| | 232 | 0x00000000, /*DWORD BaseOfData; */ |
| | 233 | |
| | 234 | /* NT additional fields. */ |
| | 235 | 0x00400000, /*DWORD ImageBase; */ |
| | 236 | 0x00001000, /*DWORD SectionAlignment; */ |
| | 237 | 0x00000200, /*DWORD FileAlignment; */ |
| | 238 | 0x0004, /*WORD MajorOperatingSystemVersion; */ |
| | 239 | 0x0000, /*WORD MinorOperatingSystemVersion; */ |
| | 240 | 0x0000, /*WORD MajorImageVersion; */ |
| | 241 | 0x0000, /*WORD MinorImageVersion; */ |
| | 242 | 0x0004, /*WORD MajorSubsystemVersion; */ |
| | 243 | 0x0000, /*WORD MinorSubsystemVersion; */ |
| | 244 | 0x00000000, /*DWORD Win32VersionValue; */ |
| | 245 | 0x00000000, /*DWORD SizeOfImage; */ |
| | 246 | 0x00000200, /*DWORD SizeOfHeaders; */ |
| | 247 | 0x00000000, /*DWORD CheckSum; */ |
| | 248 | 0x0002, /*WORD Subsystem; */ |
| | 249 | 0x0000, /*WORD DllCharacteristics; */ |
| | 250 | 0x00100000, /*DWORD SizeOfStackReserve; */ |
| | 251 | 0x00001000, /*DWORD SizeOfStackCommit; */ |
| | 252 | 0x00100000, /*DWORD SizeOfHeapReserve; */ |
| | 253 | 0x00001000, /*DWORD SizeOfHeapCommit; */ |
| | 254 | 0x00000000, /*DWORD LoaderFlags; */ |
| | 255 | 0x00000010, /*DWORD NumberOfRvaAndSizes; */ |
| | 256 | |
| | 257 | /* IMAGE_DATA_DIRECTORY DataDirectory[16]; */ |
| | 258 | {{0, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0}, |
| | 259 | {0, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0}} |
| | 260 | }; |
| | 261 | |
| | 262 | /*----------------------------------------------------------------------------*/ |
| | 263 | |
| | 264 | /*----------------------------------------------------------------------------*/ |
| | 265 | |
| | 266 | struct pe_import_header { |
| | 267 | DWORD first_entry; |
| | 268 | DWORD time_date; |
| | 269 | DWORD forwarder; |
| | 270 | DWORD lib_name_offset; |
| | 271 | DWORD first_thunk; |
| | 272 | }; |
| | 273 | |
| | 274 | struct pe_export_header { |
| | 275 | DWORD Characteristics; |
| | 276 | DWORD TimeDateStamp; |
| | 277 | DWORD Version; |
| | 278 | DWORD Name; |
| | 279 | DWORD Base; |
| | 280 | DWORD NumberOfFunctions; |
| | 281 | DWORD NumberOfNames; |
| | 282 | DWORD AddressOfFunctions; |
| | 283 | DWORD AddressOfNames; |
| | 284 | DWORD AddressOfNameOrdinals; |
| | 285 | }; |
| | 286 | |
| | 287 | struct pe_reloc_header { |
| | 288 | DWORD offset; |
| | 289 | DWORD size; |
| | 290 | }; |
| | 291 | |
| | 292 | /* ------------------------------------------------------------- */ |
| | 293 | /* internal temporary structures */ |
| | 294 | |
| | 295 | ST const char *pe_sec_names[] = { |
| | 296 | ".text", |
| | 297 | ".data", |
| | 298 | ".bss", |
| | 299 | ".rsrc", |
| | 300 | ".reloc", |
| | 301 | ".stab", |
| | 302 | ".stabstr" |
| | 303 | }; |
| | 304 | |
| | 305 | enum { |
| | 306 | sec_text = 0, |
| | 307 | sec_data, |
| | 308 | sec_bss, |
| | 309 | sec_rsrc, |
| | 310 | sec_reloc, |
| | 311 | sec_stab, |
| | 312 | sec_stabstr, |
| | 313 | pe_sec_number |
| | 314 | }; |
| | 315 | |
| | 316 | ST DWORD pe_flags[] = { |
| | 317 | 0x60000020, /* ".text", */ |
| | 318 | 0xC0000040, /* ".data", */ |
| | 319 | 0xC0000080, /* ".bss", */ |
| | 320 | 0x40000040, /* ".rsrc", */ |
| | 321 | 0x42000040, /* ".reloc", */ |
| | 322 | 0x42000802, /* ".stab", */ |
| | 323 | 0x42000802 /* ".stabstr", */ |
| | 324 | }; |
| | 325 | |
| | 326 | struct section_info { |
| | 327 | struct section_info *next; |
| | 328 | int id; |
| | 329 | DWORD sh_addr; |
| | 330 | DWORD sh_size; |
| | 331 | unsigned char *data; |
| | 332 | DWORD data_size; |
| | 333 | }; |
| | 334 | |
| | 335 | struct import_symbol { |
| | 336 | int sym_index; |
| | 337 | int offset; |
| | 338 | }; |
| | 339 | |
| | 340 | struct pe_import_info { |
| | 341 | int dll_index; |
| | 342 | int sym_count; |
| | 343 | struct import_symbol **symbols; |
| | 344 | }; |
| | 345 | |
| | 346 | struct pe_info { |
| | 347 | const char *filename; |
| | 348 | DWORD sizeofheaders; |
| | 349 | DWORD imagebase; |
| | 350 | DWORD start_addr; |
| | 351 | DWORD imp_offs; |
| | 352 | DWORD imp_size; |
| | 353 | DWORD iat_offs; |
| | 354 | DWORD iat_size; |
| | 355 | DWORD exp_offs; |
| | 356 | DWORD exp_size; |
| | 357 | struct section_info sh_info[pe_sec_number]; |
| | 358 | int sec_count; |
| | 359 | struct pe_import_info **imp_info; |
| | 360 | int imp_count; |
| | 361 | Section *reloc; |
| | 362 | Section *thunk; |
| | 363 | TCCState *s1; |
| | 364 | }; |
| | 365 | |
| | 366 | /* ------------------------------------------------------------- */ |
| | 367 | #define PE_MERGE_DATA |
| | 368 | // #define PE_PRINT_SECTIONS |
| | 369 | |
| | 370 | #ifndef MAX_PATH |
| | 371 | #define MAX_PATH 260 |
| | 372 | #endif |
| | 373 | |
| | 374 | void error_noabort(const char *, ...); |
| | 375 | |
| | 376 | ST char pe_type; |
| | 377 | |
| | 378 | #define PE_NUL 0 |
| | 379 | #define PE_DLL 1 |
| | 380 | #define PE_GUI 2 |
| | 381 | #define PE_EXE 3 |
| | 382 | |
| | 383 | #ifdef WIN32 |
| | 384 | int __stdcall GetModuleFileNameA(void *, char *, int); |
| | 385 | void *__stdcall GetProcAddress(void *, const char *); |
| | 386 | void *__stdcall GetModuleHandleA(const char *); |
| | 387 | void *__stdcall LoadLibraryA(const char *); |
| | 388 | int __stdcall FreeConsole(void); |
| | 389 | #endif |
| | 390 | |
| | 391 | ST int pe_find_import(TCCState * s1, const char *symbol, char *ret) |
| | 392 | { |
| | 393 | int sym_index = find_elf_sym(s1->dynsymtab_section, symbol); |
| | 394 | if (0 == sym_index) { |
| | 395 | /* Hm, maybe it's '_symbol' instead of 'symbol' or '__imp__symbol' */ |
| | 396 | char buffer[100]; |
| | 397 | if (0 == memcmp(symbol, "__imp__", 7)) |
| | 398 | symbol += 6; |
| | 399 | else |
| | 400 | buffer[0] = '_', strcpy(buffer + 1, symbol), symbol = buffer; |
| | 401 | sym_index = find_elf_sym(s1->dynsymtab_section, symbol); |
| | 402 | } |
| | 403 | if (ret) |
| | 404 | strcpy(ret, symbol); |
| | 405 | return sym_index; |
| | 406 | } |
| | 407 | |
| | 408 | #ifdef WIN32 |
| | 409 | ST void **pe_imp; |
| | 410 | ST int nb_pe_imp; |
| | 411 | |
| | 412 | void *resolve_sym(struct TCCState *s1, const char *symbol, int type) |
| | 413 | { |
| | 414 | char buffer[100], *p = buffer; |
| | 415 | void *a = NULL; |
| | 416 | int sym_index = pe_find_import(s1, symbol, p); |
| | 417 | if (sym_index) { |
| | 418 | int dll_index = |
| | 419 | ((Elf32_Sym *) s1->dynsymtab_section->data)[sym_index]. |
| | 420 | st_other; |
| | 421 | if (dll_index) { |
| | 422 | const char *dll_name = s1->loaded_dlls[dll_index - 1]->name; |
| | 423 | void *hm = GetModuleHandleA(dll_name); |
| | 424 | if (NULL == hm) |
| | 425 | hm = LoadLibraryA(dll_name); |
| | 426 | if (hm) { |
| | 427 | a = GetProcAddress(hm, buffer); |
| | 428 | if (a && STT_OBJECT == type) { |
| | 429 | // need to return a pointer to the address for data objects |
| | 430 | dynarray_add(&pe_imp, &nb_pe_imp, a); |
| | 431 | a = &pe_imp[nb_pe_imp - 1]; |
| | 432 | } |
| | 433 | } |
| | 434 | } |
| | 435 | } |
| | 436 | return a; |
| | 437 | } |
| | 438 | #endif |
| | 439 | |
| | 440 | #define for_sym_in_symtab(sym) \ |
| | 441 | for (sym = (Elf32_Sym *)symtab_section->data + 1; \ |
| | 442 | sym < (Elf32_Sym *)(symtab_section->data + \ |
| | 443 | symtab_section->data_offset); \ |
| | 444 | ++sym) |
| | 445 | |
| | 446 | #define pe_set_datadir(dir,addr,size) \ |
| | 447 | pe_opt_hdr.DataDirectory[dir].VirtualAddress = addr, \ |
| | 448 | pe_opt_hdr.DataDirectory[dir].Size = size |
| | 449 | |
| | 450 | /*----------------------------------------------------------------------------*/ |
| | 451 | ST void dynarray_reset(void ***pp, int *n) |
| | 452 | { |
| | 453 | int i; |
| | 454 | for (i = 0; i < *n; ++i) |
| | 455 | tcc_free((*pp)[i]); |
| | 456 | tcc_free(*pp); |
| | 457 | *pp = NULL; |
| | 458 | *n = 0; |
| | 459 | } |
| | 460 | |
| | 461 | ST int dynarray_assoc(void **pp, int n, int key) |
| | 462 | { |
| | 463 | int i; |
| | 464 | for (i = 0; i < n; ++i, ++pp) |
| | 465 | if (key == **(int **) pp) |
| | 466 | return i; |
| | 467 | return -1; |
| | 468 | } |
| | 469 | |
| | 470 | #if 0 |
| | 471 | ST DWORD umin(DWORD a, DWORD b) |
| | 472 | { |
| | 473 | return a < b ? a : b; |
| | 474 | } |
| | 475 | #endif |
| | 476 | |
| | 477 | ST DWORD umax(DWORD a, DWORD b) |
| | 478 | { |
| | 479 | return a < b ? b : a; |
| | 480 | } |
| | 481 | |
| | 482 | ST void pe_fpad(FILE * fp, DWORD new_pos) |
| | 483 | { |
| | 484 | DWORD pos = ftell(fp); |
| | 485 | while (++pos <= new_pos) |
| | 486 | fputc(0, fp); |
| | 487 | } |
| | 488 | |
| | 489 | ST DWORD pe_file_align(DWORD n) |
| | 490 | { |
| | 491 | return (n + (0x200 - 1)) & ~(0x200 - 1); |
| | 492 | } |
| | 493 | |
| | 494 | ST DWORD pe_virtual_align(DWORD n) |
| | 495 | { |
| | 496 | return (n + (0x1000 - 1)) & ~(0x1000 - 1); |
| | 497 | } |
| | 498 | |
| | 499 | ST void pe_align_section(Section * s, int a) |
| | 500 | { |
| | 501 | int i = s->data_offset & (a - 1); |
| | 502 | if (i) |
| | 503 | section_ptr_add(s, a - i); |
| | 504 | } |
| | 505 | |
| | 506 | |
| | 507 | /*----------------------------------------------------------------------------*/ |
| | 508 | ST int pe_write_pe(struct pe_info *pe) |
| | 509 | { |
| | 510 | int i; |
| | 511 | FILE *op; |
| | 512 | DWORD file_offset; |
| | 513 | IMAGE_SECTION_HEADER ish[pe_sec_number], *psh; |
| | 514 | int sec_index = 0; |
| | 515 | |
| | 516 | op = fopen(pe->filename, "wb"); |
| | 517 | if (NULL == op) { |
| | 518 | error_noabort("could not create file: %s", pe->filename); |
| | 519 | return 1; |
| | 520 | } |
| | 521 | |
| | 522 | memset(&ish, 0, sizeof ish); |
| | 523 | |
| | 524 | pe->sizeofheaders = pe_file_align(sizeof pe_dos_hdr |
| | 525 | + sizeof pe_magic |
| | 526 | + sizeof pe_file_hdr |
| | 527 | + sizeof pe_opt_hdr |
| | 528 | + |
| | 529 | pe->sec_count * |
| | 530 | sizeof(IMAGE_SECTION_HEADER) |
| | 531 | ); |
| | 532 | |
| | 533 | file_offset = pe->sizeofheaders; |
| | 534 | pe_fpad(op, file_offset); |
| | 535 | |
| | 536 | if (2 == verbose) |
| | 537 | printf("-------------------------------" |
| | 538 | "\n virt file size section" "\n"); |
| | 539 | |
| | 540 | for (i = 0; i < pe->sec_count; ++i) { |
| | 541 | struct section_info *si = pe->sh_info + i; |
| | 542 | const char *sh_name = pe_sec_names[si->id]; |
| | 543 | unsigned long addr = si->sh_addr - pe->imagebase; |
| | 544 | unsigned long size = si->sh_size; |
| | 545 | |
| | 546 | if (2 == verbose) |
| | 547 | printf("%6lx %6lx %6lx %s\n", |
| | 548 | addr, file_offset, size, sh_name); |
| | 549 | |
| | 550 | switch (si->id) { |
| | 551 | case sec_text: |
| | 552 | pe_opt_hdr.BaseOfCode = addr; |
| | 553 | pe_opt_hdr.AddressOfEntryPoint = addr + pe->start_addr; |
| | 554 | break; |
| | 555 | |
| | 556 | case sec_data: |
| | 557 | pe_opt_hdr.BaseOfData = addr; |
| | 558 | if (pe->imp_size) { |
| | 559 | pe_set_datadir(IMAGE_DIRECTORY_ENTRY_IMPORT, |
| | 560 | pe->imp_offs + addr, pe->imp_size); |
| | 561 | pe_set_datadir(IMAGE_DIRECTORY_ENTRY_IAT, |
| | 562 | pe->iat_offs + addr, pe->iat_size); |
| | 563 | } |
| | 564 | if (pe->exp_size) { |
| | 565 | pe_set_datadir(IMAGE_DIRECTORY_ENTRY_EXPORT, |
| | 566 | pe->exp_offs + addr, pe->exp_size); |
| | 567 | } |
| | 568 | break; |
| | 569 | |
| | 570 | case sec_bss: |
| | 571 | break; |
| | 572 | |
| | 573 | case sec_reloc: |
| | 574 | pe_set_datadir(IMAGE_DIRECTORY_ENTRY_BASERELOC, addr, size); |
| | 575 | break; |
| | 576 | |
| | 577 | case sec_rsrc: |
| | 578 | pe_set_datadir(IMAGE_DIRECTORY_ENTRY_RESOURCE, addr, size); |
| | 579 | break; |
| | 580 | |
| | 581 | case sec_stab: |
| | 582 | break; |
| | 583 | |
| | 584 | case sec_stabstr: |
| | 585 | break; |
| | 586 | } |
| | 587 | |
| | 588 | psh = &ish[sec_index++]; |
| | 589 | strcpy((char *) psh->Name, sh_name); |
| | 590 | |
| | 591 | psh->Characteristics = pe_flags[si->id]; |
| | 592 | psh->VirtualAddress = addr; |
| | 593 | psh->Misc.VirtualSize = size; |
| | 594 | pe_opt_hdr.SizeOfImage = |
| | 595 | umax(psh->VirtualAddress + psh->Misc.VirtualSize, |
| | 596 | pe_opt_hdr.SizeOfImage); |
| | 597 | |
| | 598 | if (si->data_size) { |
| | 599 | psh->PointerToRawData = file_offset; |
| | 600 | fwrite(si->data, 1, si->data_size, op); |
| | 601 | file_offset = pe_file_align(file_offset + si->data_size); |
| | 602 | psh->SizeOfRawData = file_offset - psh->PointerToRawData; |
| | 603 | pe_fpad(op, file_offset); |
| | 604 | } |
| | 605 | } |
| | 606 | |
| | 607 | /*----------------------------------------------------- */ |
| | 608 | |
| | 609 | pe_file_hdr.NumberOfSections = sec_index; |
| | 610 | pe_opt_hdr.SizeOfHeaders = pe->sizeofheaders; |
| | 611 | pe_opt_hdr.ImageBase = pe->imagebase; |
| | 612 | if (PE_DLL == pe_type) |
| | 613 | pe_file_hdr.Characteristics = 0x230E; |
| | 614 | else if (PE_GUI != pe_type) |
| | 615 | pe_opt_hdr.Subsystem = 3; |
| | 616 | |
| | 617 | fseek(op, SEEK_SET, 0); |
| | 618 | fwrite(&pe_dos_hdr, 1, sizeof pe_dos_hdr, op); |
| | 619 | fwrite(&pe_magic, 1, sizeof pe_magic, op); |
| | 620 | fwrite(&pe_file_hdr, 1, sizeof pe_file_hdr, op); |
| | 621 | fwrite(&pe_opt_hdr, 1, sizeof pe_opt_hdr, op); |
| | 622 | for (i = 0; i < sec_index; ++i) |
| | 623 | fwrite(&ish[i], 1, sizeof(IMAGE_SECTION_HEADER), op); |
| | 624 | fclose(op); |
| | 625 | |
| | 626 | if (2 == verbose) |
| | 627 | printf("-------------------------------\n"); |
| | 628 | if (verbose) |
| | 629 | printf("<-- %s (%lu bytes)\n", pe->filename, file_offset); |
| | 630 | |
| | 631 | return 0; |
| | 632 | } |
| | 633 | |
| | 634 | /*----------------------------------------------------------------------------*/ |
| | 635 | ST int pe_add_import(struct pe_info *pe, int sym_index, DWORD offset) |
| | 636 | { |
| | 637 | int i; |
| | 638 | int dll_index; |
| | 639 | struct pe_import_info *p; |
| | 640 | struct import_symbol *s; |
| | 641 | |
| | 642 | dll_index = |
| | 643 | ((Elf32_Sym *) pe->s1->dynsymtab_section->data)[sym_index]. |
| | 644 | st_other; |
| | 645 | if (0 == dll_index) |
| | 646 | return 0; |
| | 647 | |
| | 648 | i = dynarray_assoc((void **) pe->imp_info, pe->imp_count, dll_index); |
| | 649 | if (-1 != i) { |
| | 650 | p = pe->imp_info[i]; |
| | 651 | goto found_dll; |
| | 652 | } |
| | 653 | p = tcc_mallocz(sizeof *p); |
| | 654 | p->dll_index = dll_index; |
| | 655 | dynarray_add((void ***) &pe->imp_info, &pe->imp_count, p); |
| | 656 | |
| | 657 | found_dll: |
| | 658 | i = dynarray_assoc((void **) p->symbols, p->sym_count, sym_index); |
| | 659 | if (-1 != i) |
| | 660 | goto found_sym; |
| | 661 | s = tcc_mallocz(sizeof *s); |
| | 662 | s->sym_index = sym_index; |
| | 663 | s->offset = offset; |
| | 664 | dynarray_add((void ***) &p->symbols, &p->sym_count, s); |
| | 665 | |
| | 666 | found_sym: |
| | 667 | return 1; |
| | 668 | } |
| | 669 | |
| | 670 | /*----------------------------------------------------------------------------*/ |
| | 671 | ST void pe_build_imports(struct pe_info *pe) |
| | 672 | { |
| | 673 | int thk_ptr, ent_ptr, dll_ptr, sym_cnt, i; |
| | 674 | DWORD voffset = pe->thunk->sh_addr - pe->imagebase; |
| | 675 | int ndlls = pe->imp_count; |
| | 676 | |
| | 677 | for (sym_cnt = i = 0; i < ndlls; ++i) |
| | 678 | sym_cnt += pe->imp_info[i]->sym_count; |
| | 679 | |
| | 680 | if (0 == sym_cnt) |
| | 681 | return; |
| | 682 | |
| | 683 | pe_align_section(pe->thunk, 16); |
| | 684 | |
| | 685 | pe->imp_offs = dll_ptr = pe->thunk->data_offset; |
| | 686 | pe->imp_size = (ndlls + 1) * sizeof(struct pe_import_header); |
| | 687 | pe->iat_offs = dll_ptr + pe->imp_size; |
| | 688 | pe->iat_size = (sym_cnt + ndlls) * sizeof(DWORD); |
| | 689 | section_ptr_add(pe->thunk, pe->imp_size + 2 * pe->iat_size); |
| | 690 | |
| | 691 | thk_ptr = pe->iat_offs; |
| | 692 | ent_ptr = pe->iat_offs + pe->iat_size; |
| | 693 | for (i = 0; i < pe->imp_count; ++i) { |
| | 694 | struct pe_import_header *hdr; |
| | 695 | int k, n, v; |
| | 696 | struct pe_import_info *p = pe->imp_info[i]; |
| | 697 | const char *name = pe->s1->loaded_dlls[p->dll_index - 1]->name; |
| | 698 | |
| | 699 | /* put the dll name into the import header */ |
| | 700 | if (0 == strncmp(name, "lib", 3)) |
| | 701 | name += 3; |
| | 702 | v = put_elf_str(pe->thunk, name); |
| | 703 | |
| | 704 | hdr = (struct pe_import_header *) (pe->thunk->data + dll_ptr); |
| | 705 | hdr->first_thunk = thk_ptr + voffset; |
| | 706 | hdr->first_entry = ent_ptr + voffset; |
| | 707 | hdr->lib_name_offset = v + voffset; |
| | 708 | |
| | 709 | for (k = 0, n = p->sym_count; k <= n; ++k) { |
| | 710 | if (k < n) { |
| | 711 | DWORD offset = p->symbols[k]->offset; |
| | 712 | int sym_index = p->symbols[k]->sym_index; |
| | 713 | Elf32_Sym *sym = |
| | 714 | (Elf32_Sym *) pe->s1->dynsymtab_section->data + |
| | 715 | sym_index; |
| | 716 | const char *name = |
| | 717 | pe->s1->dynsymtab_section->link->data + sym->st_name; |
| | 718 | |
| | 719 | if (offset & 0x80000000) { /* ref to data */ |
| | 720 | Elf32_Sym *sym = |
| | 721 | &((Elf32_Sym *) symtab_section-> |
| | 722 | data)[offset & 0x7FFFFFFF]; |
| | 723 | sym->st_value = thk_ptr; |
| | 724 | sym->st_shndx = pe->thunk->sh_num; |
| | 725 | } else { /* ref to function */ |
| | 726 | |
| | 727 | char buffer[100]; |
| | 728 | sprintf(buffer, "IAT.%s", name); |
| | 729 | sym_index = |
| | 730 | put_elf_sym(symtab_section, thk_ptr, sizeof(DWORD), |
| | 731 | ELF32_ST_INFO(STB_GLOBAL, STT_OBJECT), |
| | 732 | 0, pe->thunk->sh_num, buffer); |
| | 733 | |
| | 734 | put_elf_reloc(symtab_section, text_section, offset, R_386_32, /*R_JMP_SLOT, */ |
| | 735 | sym_index); |
| | 736 | } |
| | 737 | v = pe->thunk->data_offset + voffset; |
| | 738 | section_ptr_add(pe->thunk, sizeof(WORD)); /* hint, not used */ |
| | 739 | put_elf_str(pe->thunk, name); |
| | 740 | } else { |
| | 741 | v = 0; // last entry is zero |
| | 742 | } |
| | 743 | *(DWORD *) (pe->thunk->data + thk_ptr) = |
| | 744 | *(DWORD *) (pe->thunk->data + ent_ptr) = v; |
| | 745 | thk_ptr += sizeof(DWORD); |
| | 746 | ent_ptr += sizeof(DWORD); |
| | 747 | } |
| | 748 | dll_ptr += sizeof(struct pe_import_header); |
| | 749 | dynarray_reset((void ***) &p->symbols, &p->sym_count); |
| | 750 | } |
| | 751 | dynarray_reset((void ***) &pe->imp_info, &pe->imp_count); |
| | 752 | } |
| | 753 | |
| | 754 | /* ------------------------------------------------------------- */ |
| | 755 | ST void pe_build_exports(struct pe_info *pe) |
| | 756 | { |
| | 757 | Elf32_Sym *sym; |
| | 758 | DWORD func_offset; |
| | 759 | DWORD voffset = pe->thunk->sh_addr - pe->imagebase; |
| | 760 | struct pe_export_header *hdr; |
| | 761 | int sym_count = 0, ordinal = 0; |
| | 762 | |
| | 763 | // for simplicity only functions are exported |
| | 764 | for_sym_in_symtab(sym) |
| | 765 | if (sym->st_shndx != text_section->sh_num) |
| | 766 | sym->st_other &= ~1; |
| | 767 | else if (sym->st_other & 1) |
| | 768 | ++sym_count; |
| | 769 | |
| | 770 | if (0 == sym_count) |
| | 771 | return; |
| | 772 | |
| | 773 | pe_align_section(pe->thunk, 16); |
| | 774 | |
| | 775 | pe->exp_offs = pe->thunk->data_offset; |
| | 776 | hdr = section_ptr_add(pe->thunk, |
| | 777 | sizeof(struct pe_export_header) + |
| | 778 | sym_count * (2 * sizeof(DWORD) + sizeof(WORD))); |
| | 779 | |
| | 780 | func_offset = pe->exp_offs + sizeof(struct pe_export_header); |
| | 781 | |
| | 782 | hdr->Characteristics = 0; |
| | 783 | hdr->Base = 1; |
| | 784 | hdr->NumberOfFunctions = sym_count; |
| | 785 | hdr->NumberOfNames = sym_count; |
| | 786 | hdr->AddressOfFunctions = func_offset + voffset; |
| | 787 | hdr->AddressOfNames = |
| | 788 | hdr->AddressOfFunctions + sym_count * sizeof(DWORD); |
| | 789 | hdr->AddressOfNameOrdinals = |
| | 790 | hdr->AddressOfNames + sym_count * sizeof(DWORD); |
| | 791 | hdr->Name = pe->thunk->data_offset + voffset; |
| | 792 | put_elf_str(pe->thunk, tcc_basename(pe->filename)); |
| | 793 | |
| | 794 | for_sym_in_symtab(sym) |
| | 795 | if (sym->st_other & 1) { |
| | 796 | char *name = symtab_section->link->data + sym->st_name; |
| | 797 | DWORD *p = (DWORD *) (pe->thunk->data + func_offset); |
| | 798 | DWORD *pfunc = p + ordinal; |
| | 799 | DWORD *pname = p + sym_count + ordinal; |
| | 800 | WORD *pord = (WORD *) (p + 2 * sym_count) + ordinal; |
| | 801 | *pfunc = |
| | 802 | sym->st_value + pe->s1->sections[sym->st_shndx]->sh_addr - |
| | 803 | pe->imagebase; |
| | 804 | *pname = pe->thunk->data_offset + voffset; |
| | 805 | *pord = ordinal; |
| | 806 | put_elf_str(pe->thunk, name); |
| | 807 | /* printf("export: %s\n", name); */ |
| | 808 | ++ordinal; |
| | 809 | } |
| | 810 | pe->exp_size = pe->thunk->data_offset - pe->exp_offs; |
| | 811 | } |
| | 812 | |
| | 813 | /* ------------------------------------------------------------- */ |
| | 814 | ST void pe_build_reloc(struct pe_info *pe, int *section_order, |
| | 815 | int section_count) |
| | 816 | { |
| | 817 | DWORD offset, block_ptr, addr; |
| | 818 | int count, i; |
| | 819 | Elf32_Rel *rel, *rel_end; |
| | 820 | Section *s = NULL, *sr; |
| | 821 | offset = addr = block_ptr = count = i = 0; |
| | 822 | rel = rel_end = NULL; |
| | 823 | for (;;) { |
| | 824 | if (rel < rel_end) { |
| | 825 | int type = ELF32_R_TYPE(rel->r_info); |
| | 826 | addr = rel->r_offset + s->sh_addr; |
| | 827 | ++rel; |
| | 828 | if (type != R_386_32) |
| | 829 | continue; |
| | 830 | if (count == 0) { /* new block */ |
| | 831 | block_ptr = pe->reloc->data_offset; |
| | 832 | section_ptr_add(pe->reloc, sizeof(struct pe_reloc_header)); |
| | 833 | offset = addr & 0xFFFFFFFF << 12; |
| | 834 | } |
| | 835 | if ((addr -= offset) < (1 << 12)) { /* one block spans 4k addresses */ |
| | 836 | WORD *wp = section_ptr_add(pe->reloc, sizeof(WORD)); |
| | 837 | *wp = addr | IMAGE_REL_BASED_HIGHLOW << 12; |
| | 838 | ++count; |
| | 839 | continue; |
| | 840 | } |
| | 841 | --rel; |
| | 842 | } else if (i < section_count) { |
| | 843 | sr = (s = pe->s1->sections[section_order[i++]])->reloc; |
| | 844 | if (sr) { |
| | 845 | rel = (Elf32_Rel *) sr->data; |
| | 846 | rel_end = (Elf32_Rel *) (sr->data + sr->data_offset); |
| | 847 | } |
| | 848 | continue; |
| | 849 | } |
| | 850 | |
| | 851 | if (count) { /* store the last block and ready for a new one */ |
| | 852 | struct pe_reloc_header *hdr; |
| | 853 | if (count & 1) |
| | 854 | section_ptr_add(pe->reloc, 2), ++count; |
| | 855 | hdr = (struct pe_reloc_header *) (pe->reloc->data + block_ptr); |
| | 856 | hdr->offset = offset - pe->imagebase; |
| | 857 | hdr->size = |
| | 858 | count * sizeof(WORD) + sizeof(struct pe_reloc_header); |
| | 859 | count = 0; |
| | 860 | } |
| | 861 | if (rel >= rel_end) |
| | 862 | break; |
| | 863 | } |
| | 864 | } |
| | 865 | |
| | 866 | /* ------------------------------------------------------------- */ |
| | 867 | ST int pe_assign_addresses(struct pe_info *pe) |
| | 868 | { |
| | 869 | int i, k, n; |
| | 870 | DWORD addr; |
| | 871 | int section_order[pe_sec_number]; |
| | 872 | struct section_info *si_data = NULL; |
| | 873 | |
| | 874 | pe->imagebase = PE_DLL == pe_type ? 0x10000000 : 0x00400000; |
| | 875 | addr = pe->imagebase + 1; |
| | 876 | |
| | 877 | if (PE_DLL == pe_type) |
| | 878 | pe->reloc = new_section(pe->s1, ".reloc", SHT_DYNAMIC, SHF_ALLOC); |
| | 879 | |
| | 880 | for (n = k = 0; n < pe_sec_number; ++n) { |
| | 881 | for (i = 1; i < pe->s1->nb_sections; ++i) { |
| | 882 | Section *s = pe->s1->sections[i]; |
| | 883 | if (0 == strcmp(s->name, pe_sec_names[n])) { |
| | 884 | struct section_info *si = &pe->sh_info[pe->sec_count]; |
| | 885 | #ifdef PE_MERGE_DATA |
| | 886 | if (n == sec_bss && si_data) { |
| | 887 | /* append .bss to .data */ |
| | 888 | s->sh_addr = addr = ((addr - 1) | 15) + 1; |
| | 889 | addr += s->data_offset; |
| | 890 | si_data->sh_size = addr - si_data->sh_addr; |
| | 891 | } else |
| | 892 | #endif |
| | 893 | { |
| | 894 | si->sh_addr = s->sh_addr = addr = |
| | 895 | pe_virtual_align(addr); |
| | 896 | si->id = n; |
| | 897 | |
| | 898 | if (n == sec_data) { |
| | 899 | pe->thunk = s; |
| | 900 | si_data = si; |
| | 901 | pe_build_imports(pe); |
| | 902 | pe_build_exports(pe); |
| | 903 | } else if (n == sec_reloc) { |
| | 904 | pe_build_reloc(pe, section_order, k); |
| | 905 | } |
| | 906 | |
| | 907 | if (s->data_offset) { |
| | 908 | if (n != sec_bss) { |
| | 909 | si->data = s->data; |
| | 910 | si->data_size = s->data_offset; |
| | 911 | } |
| | 912 | |
| | 913 | addr += s->data_offset; |
| | 914 | si->sh_size = s->data_offset; |
| | 915 | ++pe->sec_count; |
| | 916 | } |
| | 917 | //printf("Section %08X %04X %s\n", si->sh_addr, si->data_size, s->name); |
| | 918 | } |
| | 919 | section_order[k] = i, ++k; |
| | 920 | } |
| | 921 | } |
| | 922 | } |
| | 923 | return 0; |
| | 924 | } |
| | 925 | |
| | 926 | /*----------------------------------------------------------------------------*/ |
| | 927 | ST int pe_check_symbols(struct pe_info *pe) |
| | 928 | { |
| | 929 | Elf32_Sym *sym; |
| | 930 | int ret = 0; |
| | 931 | |
| | 932 | pe_align_section(text_section, 8); |
| | 933 | |
| | 934 | for_sym_in_symtab(sym) { |
| | 935 | if (sym->st_shndx == SHN_UNDEF) { |
| | 936 | const char *symbol = symtab_section->link->data + sym->st_name; |
| | 937 | unsigned type = ELF32_ST_TYPE(sym->st_info); |
| | 938 | int sym_index = pe_find_import(pe->s1, symbol, NULL); |
| | 939 | if (sym_index) { |
| | 940 | if (type == STT_FUNC) { |
| | 941 | unsigned long offset = text_section->data_offset; |
| | 942 | if (pe_add_import(pe, sym_index, offset + 2)) { |
| | 943 | /* add the 'jmp IAT[x]' instruction */ |
| | 944 | *(WORD *) section_ptr_add(text_section, 8) = |
| | 945 | 0x25FF; |
| | 946 | /* patch the symbol */ |
| | 947 | sym->st_shndx = text_section->sh_num; |
| | 948 | sym->st_value = offset; |
| | 949 | continue; |
| | 950 | } |
| | 951 | } else if (type == STT_OBJECT) { /* data, ptr to that should be */ |
| | 952 | if (pe_add_import(pe, sym_index, |
| | 953 | (sym - |
| | 954 | (Elf32_Sym *) symtab_section->data) | |
| | 955 | 0x80000000)) |
| | 956 | continue; |
| | 957 | } |
| | 958 | } |
| | 959 | error_noabort("undefined symbol '%s'", symbol); |
| | 960 | ret = 1; |
| | 961 | } else |
| | 962 | if (pe->s1->rdynamic |
| | 963 | && ELF32_ST_BIND(sym->st_info) != STB_LOCAL) { |
| | 964 | /* if -rdynamic option, then export all non local symbols */ |
| | 965 | sym->st_other |= 1; |
| | 966 | } |
| | 967 | } |
| | 968 | return ret; |
| | 969 | } |
| | 970 | |
| | 971 | /*----------------------------------------------------------------------------*/ |
| | 972 | #ifdef PE_PRINT_SECTIONS |
| | 973 | ST void pe_print_section(FILE * f, Section * s) |
| | 974 | { /* just if you'r curious */ |
| | 975 | BYTE *p, *e, b; |
| | 976 | int i, n, l, m; |
| | 977 | p = s->data; |
| | 978 | e = s->data + s->data_offset; |
| | 979 | l = e - p; |
| | 980 | |
| | 981 | fprintf(f, "section \"%s\"", s->name); |
| | 982 | if (s->link) |
| | 983 | fprintf(f, "\nlink \"%s\"", s->link->name); |
| | 984 | if (s->reloc) |
| | 985 | fprintf(f, "\nreloc \"%s\"", s->reloc->name); |
| | 986 | fprintf(f, "\nv_addr %08X", s->sh_addr); |
| | 987 | fprintf(f, "\ncontents %08X", l); |
| | 988 | fprintf(f, "\n\n"); |
| | 989 | |
| | 990 | if (s->sh_type == SHT_NOBITS) |
| | 991 | return; |
| | 992 | |
| | 993 | if (s->sh_type == SHT_SYMTAB) |
| | 994 | m = sizeof(Elf32_Sym); |
| | 995 | if (s->sh_type == SHT_REL) |
| | 996 | m = sizeof(Elf32_Rel); |
| | 997 | else |
| | 998 | m = 16; |
| | 999 | |
| | 1000 | for (i = 0; i < l;) { |
| | 1001 | fprintf(f, "%08X", i); |
| | 1002 | for (n = 0; n < m; ++n) { |
| | 1003 | if (n + i < l) |
| | 1004 | fprintf(f, " %02X", p[i + n]); |
| | 1005 | else |
| | 1006 | fprintf(f, " "); |
| | 1007 | } |
| | 1008 | |
| | 1009 | if (s->sh_type == SHT_SYMTAB) { |
| | 1010 | Elf32_Sym *sym = (Elf32_Sym *) (p + i); |
| | 1011 | const char *name = s->link->data + sym->st_name; |
| | 1012 | fprintf(f, |
| | 1013 | " name:%04X" |
| | 1014 | " value:%04X" |
| | 1015 | " size:%04X" |
| | 1016 | " bind:%02X" |
| | 1017 | " type:%02X" |
| | 1018 | " other:%02X" |
| | 1019 | " shndx:%04X" |
| | 1020 | " \"%s\"", |
| | 1021 | sym->st_name, |
| | 1022 | sym->st_value, |
| | 1023 | sym->st_size, |
| | 1024 | ELF32_ST_BIND(sym->st_info), |
| | 1025 | ELF32_ST_TYPE(sym->st_info), |
| | 1026 | sym->st_other, sym->st_shndx, name); |
| | 1027 | } else if (s->sh_type == SHT_REL) { |
| | 1028 | Elf32_Rel *rel = (Elf32_Rel *) (p + i); |
| | 1029 | Elf32_Sym *sym = |
| | 1030 | (Elf32_Sym *) s->link->data + ELF32_R_SYM(rel->r_info); |
| | 1031 | const char *name = s->link->link->data + sym->st_name; |
| | 1032 | fprintf(f, |
| | 1033 | " offset:%04X" |
| | 1034 | " type:%02X" |
| | 1035 | " symbol:%04X" |
| | 1036 | " \"%s\"", |
| | 1037 | rel->r_offset, |
| | 1038 | ELF32_R_TYPE(rel->r_info), |
| | 1039 | ELF32_R_SYM(rel->r_info), name); |
| | 1040 | } else { |
| | 1041 | fprintf(f, " "); |
| | 1042 | for (n = 0; n < m; ++n) { |
| | 1043 | if (n + i < l) { |
| | 1044 | b = p[i + n]; |
| | 1045 | if (b < 32 || b >= 127) |
| | 1046 | b = '.'; |
| | 1047 | fprintf(f, "%c", b); |
| | 1048 | } |
| | 1049 | } |
| | 1050 | } |
| | 1051 | i += m; |
| | 1052 | fprintf(f, "\n"); |
| | 1053 | } |
| | 1054 | fprintf(f, "\n\n"); |
| | 1055 | } |
| | 1056 | #endif |
| | 1057 | |
| | 1058 | static int pe_test_cmd(const char **pp, const char *cmd) |
| | 1059 | { |
| | 1060 | const char *p; |
| | 1061 | char *q, buf[16]; |
| | 1062 | int ret; |
| | 1063 | |
| | 1064 | p = *pp; |
| | 1065 | q = buf; |
| | 1066 | while (*p != '\0' && !is_space(*p)) { |
| | 1067 | if ((q - buf) < sizeof(buf) - 1) |
| | 1068 | *q++ = toup(*p); |
| | 1069 | p++; |
| | 1070 | } |
| | 1071 | *q = '\0'; |
| | 1072 | ret = !strcmp(buf, cmd); |
| | 1073 | *pp = p; |
| | 1074 | return ret; |
| | 1075 | } |
| | 1076 | |
| | 1077 | /* ------------------------------------------------------------- */ |
| | 1078 | int pe_load_def_file(TCCState * s1, FILE * fp) |
| | 1079 | { |
| | 1080 | DLLReference *dllref; |
| | 1081 | int f = 0, sym_index; |
| | 1082 | char *p, *p_other, line[120], dllname[40]; |
| | 1083 | while (fgets(line, sizeof line, fp)) { |
| | 1084 | p = strchr(line, 0); |
| | 1085 | while (p > line && p[-1] <= ' ') |
| | 1086 | --p; |
| | 1087 | *p = 0; |
| | 1088 | p = line; |
| | 1089 | while (*p && *p <= ' ') |
| | 1090 | ++p; |
| | 1091 | |
| | 1092 | if (*p && ';' != *p) |
| | 1093 | switch (f) { |
| | 1094 | case 0: |
| | 1095 | if (!pe_test_cmd((const char **)&p, "LIBRARY")) |
| | 1096 | return -1; |
| | 1097 | while (is_space(*p)) |
| | 1098 | p++; |
| | 1099 | pstrcpy(dllname, sizeof(dllname), p); |
| | 1100 | ++f; |
| | 1101 | continue; |
| | 1102 | |
| | 1103 | case 1: |
| | 1104 | if (!pe_test_cmd((const char **)&p, "EXPORTS")) |
| | 1105 | return -1; |
| | 1106 | ++f; |
| | 1107 | continue; |
| | 1108 | |
| | 1109 | case 2: |
| | 1110 | dllref = |
| | 1111 | tcc_malloc(sizeof(DLLReference) + strlen(dllname)); |
| | 1112 | strcpy(dllref->name, dllname); |
| | 1113 | dllref->level = 0; |
| | 1114 | dynarray_add((void ***) &s1->loaded_dlls, |
| | 1115 | &s1->nb_loaded_dlls, dllref); |
| | 1116 | ++f; |
| | 1117 | |
| | 1118 | default: |
| | 1119 | sym_index = add_elf_sym(s1->dynsymtab_section, |
| | 1120 | 0, 0, ELF32_ST_INFO(STB_GLOBAL, |
| | 1121 | STT_FUNC), |
| | 1122 | text_section->sh_num, p); |
| | 1123 | /*gr: tccpe needs to know from what dll it should import the sym */ |
| | 1124 | p_other = |
| | 1125 | &((Elf32_Sym *) s1->dynsymtab_section-> |
| | 1126 | data)[sym_index].st_other; |
| | 1127 | if (0 == *p_other) |
| | 1128 | *p_other = s1->nb_loaded_dlls; |
| | 1129 | continue; |
| | 1130 | } |
| | 1131 | } |
| | 1132 | return 0; |
| | 1133 | } |
| | 1134 | |
| | 1135 | /* ------------------------------------------------------------- */ |
| | 1136 | unsigned long pe_add_runtime(TCCState * s1) |
| | 1137 | { |
| | 1138 | const char *start_symbol; |
| | 1139 | unsigned long addr; |
| | 1140 | |
| | 1141 | if (find_elf_sym(symtab_section, "WinMain")) |
| | 1142 | pe_type = PE_GUI; |
| | 1143 | |
| | 1144 | start_symbol = |
| | 1145 | TCC_OUTPUT_MEMORY == s1->output_type |
| | 1146 | ? PE_GUI == pe_type ? "_runwinmain" : NULL |
| | 1147 | : PE_DLL == pe_type ? "_dllstart" |
| | 1148 | : PE_GUI == pe_type ? "_winstart" : "_start"; |
| | 1149 | |
| | 1150 | /* grab the startup code from libtcc1 */ |
| | 1151 | if (start_symbol) |
| | 1152 | add_elf_sym(symtab_section, |
| | 1153 | 0, 0, |
| | 1154 | ELF32_ST_INFO(STB_GLOBAL, STT_NOTYPE), |
| | 1155 | SHN_UNDEF, start_symbol); |
| | 1156 | |
| | 1157 | if (0 == s1->nostdlib) { |
| | 1158 | tcc_add_library(s1, "tcc1"); |
| | 1159 | tcc_add_library(s1, "msvcrt"); |
| | 1160 | if (PE_DLL == pe_type || PE_GUI == pe_type) { |
| | 1161 | tcc_add_library(s1, "kernel32"); |
| | 1162 | tcc_add_library(s1, "user32"); |
| | 1163 | tcc_add_library(s1, "gdi32"); |
| | 1164 | } |
| | 1165 | } |
| | 1166 | |
| | 1167 | addr = start_symbol ? |
| | 1168 | (unsigned long) tcc_get_symbol_err(s1, start_symbol) : 0; |
| | 1169 | |
| | 1170 | if (s1->output_type == TCC_OUTPUT_MEMORY && addr) { |
| | 1171 | /* for -run GUI's, put '_runwinmain' instead of 'main' */ |
| | 1172 | add_elf_sym(symtab_section, |
| | 1173 | addr, 0, |
| | 1174 | ELF32_ST_INFO(STB_GLOBAL, STT_NOTYPE), |
| | 1175 | text_section->sh_num, "main"); |
| | 1176 | |
| | 1177 | /* FreeConsole(); */ |
| | 1178 | } |
| | 1179 | return addr; |
| | 1180 | } |
| | 1181 | |
| | 1182 | int tcc_output_pe(TCCState * s1, const char *filename) |
| | 1183 | { |
| | 1184 | int ret; |
| | 1185 | struct pe_info pe; |
| | 1186 | int i; |
| | 1187 | memset(&pe, 0, sizeof pe); |
| | 1188 | pe.filename = filename; |
| | 1189 | pe.s1 = s1; |
| | 1190 | pe.start_addr = pe_add_runtime(s1); |
| | 1191 | |
| | 1192 | relocate_common_syms(); /* assign bss adresses */ |
| | 1193 | ret = pe_check_symbols(&pe); |
| | 1194 | if (0 == ret) { |
| | 1195 | pe_assign_addresses(&pe); |
| | 1196 | relocate_syms(s1, 0); |
| | 1197 | for (i = 1; i < s1->nb_sections; ++i) { |
| | 1198 | Section *s = s1->sections[i]; |
| | 1199 | if (s->reloc) |
| | 1200 | relocate_section(s1, s); |
| | 1201 | } |
| | 1202 | ret = pe_write_pe(&pe); |
| | 1203 | } |
| | 1204 | #ifdef PE_PRINT_SECTIONS |
| | 1205 | { |
| | 1206 | Section *s; |
| | 1207 | FILE *f; |
| | 1208 | f = fopen("tccpe.log", "wb"); |
| | 1209 | for (i = 1; i < s1->nb_sections; ++i) { |
| | 1210 | s = s1->sections[i]; |
| | 1211 | pe_print_section(f, s); |
| | 1212 | } |
| | 1213 | pe_print_section(f, s1->dynsymtab_section); |
| | 1214 | fclose(f); |
| | 1215 | } |
| | 1216 | #endif |
| | 1217 | return ret; |
| | 1218 | } |
| | 1219 | |
| | 1220 | /*----------------------------------------------------------------------------*/ |