1 /* dlltool.c -- tool to generate stuff for PE style DLLs 2 Copyright (C) 1995-2016 Free Software Foundation, Inc. 3 4 This file is part of GNU Binutils. 5 6 This program is free software; you can redistribute it and/or modify 7 it under the terms of the GNU General Public License as published by 8 the Free Software Foundation; either version 3 of the License, or 9 (at your option) any later version. 10 11 This program 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 14 GNU General Public License for more details. 15 16 You should have received a copy of the GNU General Public License 17 along with this program; if not, write to the Free Software 18 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 19 02110-1301, USA. */ 20 21 22 /* This program allows you to build the files necessary to create 23 DLLs to run on a system which understands PE format image files. 24 (eg, Windows NT) 25 26 See "Peering Inside the PE: A Tour of the Win32 Portable Executable 27 File Format", MSJ 1994, Volume 9 for more information. 28 Also see "Microsoft Portable Executable and Common Object File Format, 29 Specification 4.1" for more information. 30 31 A DLL contains an export table which contains the information 32 which the runtime loader needs to tie up references from a 33 referencing program. 34 35 The export table is generated by this program by reading 36 in a .DEF file or scanning the .a and .o files which will be in the 37 DLL. A .o file can contain information in special ".drectve" sections 38 with export information. 39 40 A DEF file contains any number of the following commands: 41 42 43 NAME <name> [ , <base> ] 44 The result is going to be <name>.EXE 45 46 LIBRARY <name> [ , <base> ] 47 The result is going to be <name>.DLL 48 49 EXPORTS ( ( ( <name1> [ = <name2> ] ) 50 | ( <name1> = <module-name> . <external-name>)) 51 [ @ <integer> ] [ NONAME ] [CONSTANT] [DATA] [PRIVATE] ) * 52 Declares name1 as an exported symbol from the 53 DLL, with optional ordinal number <integer>. 54 Or declares name1 as an alias (forward) of the function <external-name> 55 in the DLL <module-name>. 56 57 IMPORTS ( ( <internal-name> = <module-name> . <integer> ) 58 | ( [ <internal-name> = ] <module-name> . <external-name> )) * 59 Declares that <external-name> or the exported function whose ordinal number 60 is <integer> is to be imported from the file <module-name>. If 61 <internal-name> is specified then this is the name that the imported 62 function will be refereed to in the body of the DLL. 63 64 DESCRIPTION <string> 65 Puts <string> into output .exp file in the .rdata section 66 67 [STACKSIZE|HEAPSIZE] <number-reserve> [ , <number-commit> ] 68 Generates --stack|--heap <number-reserve>,<number-commit> 69 in the output .drectve section. The linker will 70 see this and act upon it. 71 72 [CODE|DATA] <attr>+ 73 SECTIONS ( <sectionname> <attr>+ )* 74 <attr> = READ | WRITE | EXECUTE | SHARED 75 Generates --attr <sectionname> <attr> in the output 76 .drectve section. The linker will see this and act 77 upon it. 78 79 80 A -export:<name> in a .drectve section in an input .o or .a 81 file to this program is equivalent to a EXPORTS <name> 82 in a .DEF file. 83 84 85 86 The program generates output files with the prefix supplied 87 on the command line, or in the def file, or taken from the first 88 supplied argument. 89 90 The .exp.s file contains the information necessary to export 91 the routines in the DLL. The .lib.s file contains the information 92 necessary to use the DLL's routines from a referencing program. 93 94 95 96 Example: 97 98 file1.c: 99 asm (".section .drectve"); 100 asm (".ascii \"-export:adef\""); 101 102 void adef (char * s) 103 { 104 printf ("hello from the dll %s\n", s); 105 } 106 107 void bdef (char * s) 108 { 109 printf ("hello from the dll and the other entry point %s\n", s); 110 } 111 112 file2.c: 113 asm (".section .drectve"); 114 asm (".ascii \"-export:cdef\""); 115 asm (".ascii \"-export:ddef\""); 116 117 void cdef (char * s) 118 { 119 printf ("hello from the dll %s\n", s); 120 } 121 122 void ddef (char * s) 123 { 124 printf ("hello from the dll and the other entry point %s\n", s); 125 } 126 127 int printf (void) 128 { 129 return 9; 130 } 131 132 themain.c: 133 int main (void) 134 { 135 cdef (); 136 return 0; 137 } 138 139 thedll.def 140 141 LIBRARY thedll 142 HEAPSIZE 0x40000, 0x2000 143 EXPORTS bdef @ 20 144 cdef @ 30 NONAME 145 146 SECTIONS donkey READ WRITE 147 aardvark EXECUTE 148 149 # Compile up the parts of the dll and the program 150 151 gcc -c file1.c file2.c themain.c 152 153 # Optional: put the dll objects into a library 154 # (you don't have to, you could name all the object 155 # files on the dlltool line) 156 157 ar qcv thedll.in file1.o file2.o 158 ranlib thedll.in 159 160 # Run this tool over the DLL's .def file and generate an exports 161 # file (thedll.o) and an imports file (thedll.a). 162 # (You may have to use -S to tell dlltool where to find the assembler). 163 164 dlltool --def thedll.def --output-exp thedll.o --output-lib thedll.a 165 166 # Build the dll with the library and the export table 167 168 ld -o thedll.dll thedll.o thedll.in 169 170 # Link the executable with the import library 171 172 gcc -o themain.exe themain.o thedll.a 173 174 This example can be extended if relocations are needed in the DLL: 175 176 # Compile up the parts of the dll and the program 177 178 gcc -c file1.c file2.c themain.c 179 180 # Run this tool over the DLL's .def file and generate an imports file. 181 182 dlltool --def thedll.def --output-lib thedll.lib 183 184 # Link the executable with the import library and generate a base file 185 # at the same time 186 187 gcc -o themain.exe themain.o thedll.lib -Wl,--base-file -Wl,themain.base 188 189 # Run this tool over the DLL's .def file and generate an exports file 190 # which includes the relocations from the base file. 191 192 dlltool --def thedll.def --base-file themain.base --output-exp thedll.exp 193 194 # Build the dll with file1.o, file2.o and the export table 195 196 ld -o thedll.dll thedll.exp file1.o file2.o */ 197 198 /* .idata section description 199 200 The .idata section is the import table. It is a collection of several 201 subsections used to keep the pieces for each dll together: .idata$[234567]. 202 IE: Each dll's .idata$2's are catenated together, each .idata$3's, etc. 203 204 .idata$2 = Import Directory Table 205 = array of IMAGE_IMPORT_DESCRIPTOR's. 206 207 DWORD Import Lookup Table; - pointer to .idata$4 208 DWORD TimeDateStamp; - currently always 0 209 DWORD ForwarderChain; - currently always 0 210 DWORD Name; - pointer to dll's name 211 PIMAGE_THUNK_DATA FirstThunk; - pointer to .idata$5 212 213 .idata$3 = null terminating entry for .idata$2. 214 215 .idata$4 = Import Lookup Table 216 = array of array of pointers to hint name table. 217 There is one for each dll being imported from, and each dll's set is 218 terminated by a trailing NULL. 219 220 .idata$5 = Import Address Table 221 = array of array of pointers to hint name table. 222 There is one for each dll being imported from, and each dll's set is 223 terminated by a trailing NULL. 224 Initially, this table is identical to the Import Lookup Table. However, 225 at load time, the loader overwrites the entries with the address of the 226 function. 227 228 .idata$6 = Hint Name Table 229 = Array of { short, asciz } entries, one for each imported function. 230 The `short' is the function's ordinal number. 231 232 .idata$7 = dll name (eg: "kernel32.dll"). (.idata$6 for ppc). */ 233 234 #include "sysdep.h" 235 #include "bfd.h" 236 #include "libiberty.h" 237 #include "getopt.h" 238 #include "demangle.h" 239 #include "dyn-string.h" 240 #include "bucomm.h" 241 #include "dlltool.h" 242 #include "safe-ctype.h" 243 244 #include <time.h> 245 #include <assert.h> 246 247 #ifdef DLLTOOL_ARM 248 #include "coff/arm.h" 249 #include "coff/internal.h" 250 #endif 251 #ifdef DLLTOOL_DEFAULT_MX86_64 252 #include "coff/x86_64.h" 253 #endif 254 #ifdef DLLTOOL_DEFAULT_I386 255 #include "coff/i386.h" 256 #endif 257 258 #ifndef COFF_PAGE_SIZE 259 #define COFF_PAGE_SIZE ((bfd_vma) 4096) 260 #endif 261 262 #ifndef PAGE_MASK 263 #define PAGE_MASK ((bfd_vma) (- COFF_PAGE_SIZE)) 264 #endif 265 266 /* Get current BFD error message. */ 267 #define bfd_get_errmsg() (bfd_errmsg (bfd_get_error ())) 268 269 /* Forward references. */ 270 static char *look_for_prog (const char *, const char *, int); 271 static char *deduce_name (const char *); 272 273 #ifdef DLLTOOL_MCORE_ELF 274 static void mcore_elf_cache_filename (const char *); 275 static void mcore_elf_gen_out_file (void); 276 #endif 277 278 #ifdef HAVE_SYS_WAIT_H 279 #include <sys/wait.h> 280 #else /* ! HAVE_SYS_WAIT_H */ 281 #if ! defined (_WIN32) || defined (__CYGWIN32__) 282 #ifndef WIFEXITED 283 #define WIFEXITED(w) (((w) & 0377) == 0) 284 #endif 285 #ifndef WIFSIGNALED 286 #define WIFSIGNALED(w) (((w) & 0377) != 0177 && ((w) & ~0377) == 0) 287 #endif 288 #ifndef WTERMSIG 289 #define WTERMSIG(w) ((w) & 0177) 290 #endif 291 #ifndef WEXITSTATUS 292 #define WEXITSTATUS(w) (((w) >> 8) & 0377) 293 #endif 294 #else /* defined (_WIN32) && ! defined (__CYGWIN32__) */ 295 #ifndef WIFEXITED 296 #define WIFEXITED(w) (((w) & 0xff) == 0) 297 #endif 298 #ifndef WIFSIGNALED 299 #define WIFSIGNALED(w) (((w) & 0xff) != 0 && ((w) & 0xff) != 0x7f) 300 #endif 301 #ifndef WTERMSIG 302 #define WTERMSIG(w) ((w) & 0x7f) 303 #endif 304 #ifndef WEXITSTATUS 305 #define WEXITSTATUS(w) (((w) & 0xff00) >> 8) 306 #endif 307 #endif /* defined (_WIN32) && ! defined (__CYGWIN32__) */ 308 #endif /* ! HAVE_SYS_WAIT_H */ 309 310 #define show_allnames 0 311 312 /* ifunc and ihead data structures: ttk (at) cygnus.com 1997 313 314 When IMPORT declarations are encountered in a .def file the 315 function import information is stored in a structure referenced by 316 the global variable IMPORT_LIST. The structure is a linked list 317 containing the names of the dll files each function is imported 318 from and a linked list of functions being imported from that dll 319 file. This roughly parallels the structure of the .idata section 320 in the PE object file. 321 322 The contents of .def file are interpreted from within the 323 process_def_file function. Every time an IMPORT declaration is 324 encountered, it is broken up into its component parts and passed to 325 def_import. IMPORT_LIST is initialized to NULL in function main. */ 326 327 typedef struct ifunct 328 { 329 char * name; /* Name of function being imported. */ 330 char * its_name; /* Optional import table symbol name. */ 331 int ord; /* Two-byte ordinal value associated with function. */ 332 struct ifunct *next; 333 } ifunctype; 334 335 typedef struct iheadt 336 { 337 char * dllname; /* Name of dll file imported from. */ 338 long nfuncs; /* Number of functions in list. */ 339 struct ifunct *funchead; /* First function in list. */ 340 struct ifunct *functail; /* Last function in list. */ 341 struct iheadt *next; /* Next dll file in list. */ 342 } iheadtype; 343 344 /* Structure containing all import information as defined in .def file 345 (qv "ihead structure"). */ 346 347 static iheadtype *import_list = NULL; 348 static char *as_name = NULL; 349 static char * as_flags = ""; 350 static char *tmp_prefix; 351 static int no_idata4; 352 static int no_idata5; 353 static char *exp_name; 354 static char *imp_name; 355 static char *delayimp_name; 356 static char *identify_imp_name; 357 static bfd_boolean identify_strict; 358 359 /* Types used to implement a linked list of dllnames associated 360 with the specified import lib. Used by the identify_* code. 361 The head entry is acts as a sentinal node and is always empty 362 (head->dllname is NULL). */ 363 typedef struct dll_name_list_node_t 364 { 365 char * dllname; 366 struct dll_name_list_node_t * next; 367 } dll_name_list_node_type; 368 369 typedef struct dll_name_list_t 370 { 371 dll_name_list_node_type * head; 372 dll_name_list_node_type * tail; 373 } dll_name_list_type; 374 375 /* Types used to pass data to iterator functions. */ 376 typedef struct symname_search_data_t 377 { 378 const char * symname; 379 bfd_boolean found; 380 } symname_search_data_type; 381 382 typedef struct identify_data_t 383 { 384 dll_name_list_type * list; 385 bfd_boolean ms_style_implib; 386 } identify_data_type; 387 388 389 static char *head_label; 390 static char *imp_name_lab; 391 static char *dll_name; 392 static int dll_name_set_by_exp_name; 393 static int add_indirect = 0; 394 static int add_underscore = 0; 395 static int add_stdcall_underscore = 0; 396 /* This variable can hold three different values. The value 397 -1 (default) means that default underscoring should be used, 398 zero means that no underscoring should be done, and one 399 indicates that underscoring should be done. */ 400 static int leading_underscore = -1; 401 static int dontdeltemps = 0; 402 403 /* TRUE if we should export all symbols. Otherwise, we only export 404 symbols listed in .drectve sections or in the def file. */ 405 static bfd_boolean export_all_symbols; 406 407 /* TRUE if we should exclude the symbols in DEFAULT_EXCLUDES when 408 exporting all symbols. */ 409 static bfd_boolean do_default_excludes = TRUE; 410 411 static bfd_boolean use_nul_prefixed_import_tables = FALSE; 412 413 /* Default symbols to exclude when exporting all the symbols. */ 414 static const char *default_excludes = "DllMain@12,DllEntryPoint@0,impure_ptr"; 415 416 /* TRUE if we should add __imp_<SYMBOL> to import libraries for backward 417 compatibility to old Cygwin releases. */ 418 static bfd_boolean create_compat_implib; 419 420 /* TRUE if we have to write PE+ import libraries. */ 421 static bfd_boolean create_for_pep; 422 423 static char *def_file; 424 425 extern char * program_name; 426 427 static int machine; 428 static int killat; 429 static int add_stdcall_alias; 430 static const char *ext_prefix_alias; 431 static int verbose; 432 static FILE *output_def; 433 static FILE *base_file; 434 435 #ifdef DLLTOOL_DEFAULT_ARM 436 static const char *mname = "arm"; 437 #endif 438 439 #ifdef DLLTOOL_DEFAULT_ARM_EPOC 440 static const char *mname = "arm-epoc"; 441 #endif 442 443 #ifdef DLLTOOL_DEFAULT_ARM_WINCE 444 static const char *mname = "arm-wince"; 445 #endif 446 447 #ifdef DLLTOOL_DEFAULT_I386 448 static const char *mname = "i386"; 449 #endif 450 451 #ifdef DLLTOOL_DEFAULT_MX86_64 452 static const char *mname = "i386:x86-64"; 453 #endif 454 455 #ifdef DLLTOOL_DEFAULT_PPC 456 static const char *mname = "ppc"; 457 #endif 458 459 #ifdef DLLTOOL_DEFAULT_SH 460 static const char *mname = "sh"; 461 #endif 462 463 #ifdef DLLTOOL_DEFAULT_MIPS 464 static const char *mname = "mips"; 465 #endif 466 467 #ifdef DLLTOOL_DEFAULT_MCORE 468 static const char * mname = "mcore-le"; 469 #endif 470 471 #ifdef DLLTOOL_DEFAULT_MCORE_ELF 472 static const char * mname = "mcore-elf"; 473 static char * mcore_elf_out_file = NULL; 474 static char * mcore_elf_linker = NULL; 475 static char * mcore_elf_linker_flags = NULL; 476 477 #define DRECTVE_SECTION_NAME ((machine == MMCORE_ELF || machine == MMCORE_ELF_LE) ? ".exports" : ".drectve") 478 #endif 479 480 #ifndef DRECTVE_SECTION_NAME 481 #define DRECTVE_SECTION_NAME ".drectve" 482 #endif 483 484 /* What's the right name for this ? */ 485 #define PATHMAX 250 486 487 /* External name alias numbering starts here. */ 488 #define PREFIX_ALIAS_BASE 20000 489 490 char *tmp_asm_buf; 491 char *tmp_head_s_buf; 492 char *tmp_head_o_buf; 493 char *tmp_tail_s_buf; 494 char *tmp_tail_o_buf; 495 char *tmp_stub_buf; 496 497 #define TMP_ASM dlltmp (&tmp_asm_buf, "%sc.s") 498 #define TMP_HEAD_S dlltmp (&tmp_head_s_buf, "%sh.s") 499 #define TMP_HEAD_O dlltmp (&tmp_head_o_buf, "%sh.o") 500 #define TMP_TAIL_S dlltmp (&tmp_tail_s_buf, "%st.s") 501 #define TMP_TAIL_O dlltmp (&tmp_tail_o_buf, "%st.o") 502 #define TMP_STUB dlltmp (&tmp_stub_buf, "%ss") 503 504 /* This bit of assembly does jmp * .... */ 505 static const unsigned char i386_jtab[] = 506 { 507 0xff, 0x25, 0x00, 0x00, 0x00, 0x00, 0x90, 0x90 508 }; 509 510 static const unsigned char i386_dljtab[] = 511 { 512 0xFF, 0x25, 0x00, 0x00, 0x00, 0x00, /* jmp __imp__function */ 513 0xB8, 0x00, 0x00, 0x00, 0x00, /* mov eax, offset __imp__function */ 514 0xE9, 0x00, 0x00, 0x00, 0x00 /* jmp __tailMerge__dllname */ 515 }; 516 517 static const unsigned char i386_x64_dljtab[] = 518 { 519 0xFF, 0x25, 0x00, 0x00, 0x00, 0x00, /* jmp __imp__function */ 520 0x48, 0x8d, 0x05, /* leaq rax, (__imp__function) */ 521 0x00, 0x00, 0x00, 0x00, 522 0xE9, 0x00, 0x00, 0x00, 0x00 /* jmp __tailMerge__dllname */ 523 }; 524 525 static const unsigned char arm_jtab[] = 526 { 527 0x00, 0xc0, 0x9f, 0xe5, /* ldr ip, [pc] */ 528 0x00, 0xf0, 0x9c, 0xe5, /* ldr pc, [ip] */ 529 0, 0, 0, 0 530 }; 531 532 static const unsigned char arm_interwork_jtab[] = 533 { 534 0x04, 0xc0, 0x9f, 0xe5, /* ldr ip, [pc] */ 535 0x00, 0xc0, 0x9c, 0xe5, /* ldr ip, [ip] */ 536 0x1c, 0xff, 0x2f, 0xe1, /* bx ip */ 537 0, 0, 0, 0 538 }; 539 540 static const unsigned char thumb_jtab[] = 541 { 542 0x40, 0xb4, /* push {r6} */ 543 0x02, 0x4e, /* ldr r6, [pc, #8] */ 544 0x36, 0x68, /* ldr r6, [r6] */ 545 0xb4, 0x46, /* mov ip, r6 */ 546 0x40, 0xbc, /* pop {r6} */ 547 0x60, 0x47, /* bx ip */ 548 0, 0, 0, 0 549 }; 550 551 static const unsigned char mcore_be_jtab[] = 552 { 553 0x71, 0x02, /* lrw r1,2 */ 554 0x81, 0x01, /* ld.w r1,(r1,0) */ 555 0x00, 0xC1, /* jmp r1 */ 556 0x12, 0x00, /* nop */ 557 0x00, 0x00, 0x00, 0x00 /* <address> */ 558 }; 559 560 static const unsigned char mcore_le_jtab[] = 561 { 562 0x02, 0x71, /* lrw r1,2 */ 563 0x01, 0x81, /* ld.w r1,(r1,0) */ 564 0xC1, 0x00, /* jmp r1 */ 565 0x00, 0x12, /* nop */ 566 0x00, 0x00, 0x00, 0x00 /* <address> */ 567 }; 568 569 /* This is the glue sequence for PowerPC PE. There is a 570 tocrel16-tocdefn reloc against the first instruction. 571 We also need a IMGLUE reloc against the glue function 572 to restore the toc saved by the third instruction in 573 the glue. */ 574 static const unsigned char ppc_jtab[] = 575 { 576 0x00, 0x00, 0x62, 0x81, /* lwz r11,0(r2) */ 577 /* Reloc TOCREL16 __imp_xxx */ 578 0x00, 0x00, 0x8B, 0x81, /* lwz r12,0(r11) */ 579 0x04, 0x00, 0x41, 0x90, /* stw r2,4(r1) */ 580 0xA6, 0x03, 0x89, 0x7D, /* mtctr r12 */ 581 0x04, 0x00, 0x4B, 0x80, /* lwz r2,4(r11) */ 582 0x20, 0x04, 0x80, 0x4E /* bctr */ 583 }; 584 585 #ifdef DLLTOOL_PPC 586 /* The glue instruction, picks up the toc from the stw in 587 the above code: "lwz r2,4(r1)". */ 588 static bfd_vma ppc_glue_insn = 0x80410004; 589 #endif 590 591 static const char i386_trampoline[] = 592 "\tpushl %%ecx\n" 593 "\tpushl %%edx\n" 594 "\tpushl %%eax\n" 595 "\tpushl $__DELAY_IMPORT_DESCRIPTOR_%s\n" 596 "\tcall ___delayLoadHelper2@8\n" 597 "\tpopl %%edx\n" 598 "\tpopl %%ecx\n" 599 "\tjmp *%%eax\n"; 600 601 static const char i386_x64_trampoline[] = 602 "\tpushq %%rcx\n" 603 "\tpushq %%rdx\n" 604 "\tpushq %%r8\n" 605 "\tpushq %%r9\n" 606 "\tsubq $40, %%rsp\n" 607 "\tmovq %%rax, %%rdx\n" 608 "\tleaq __DELAY_IMPORT_DESCRIPTOR_%s(%%rip), %%rcx\n" 609 "\tcall __delayLoadHelper2\n" 610 "\taddq $40, %%rsp\n" 611 "\tpopq %%r9\n" 612 "\tpopq %%r8\n" 613 "\tpopq %%rdx\n" 614 "\tpopq %%rcx\n" 615 "\tjmp *%%rax\n"; 616 617 struct mac 618 { 619 const char *type; 620 const char *how_byte; 621 const char *how_short; 622 const char *how_long; 623 const char *how_asciz; 624 const char *how_comment; 625 const char *how_jump; 626 const char *how_global; 627 const char *how_space; 628 const char *how_align_short; 629 const char *how_align_long; 630 const char *how_default_as_switches; 631 const char *how_bfd_target; 632 enum bfd_architecture how_bfd_arch; 633 const unsigned char *how_jtab; 634 int how_jtab_size; /* Size of the jtab entry. */ 635 int how_jtab_roff; /* Offset into it for the ind 32 reloc into idata 5. */ 636 const unsigned char *how_dljtab; 637 int how_dljtab_size; /* Size of the dljtab entry. */ 638 int how_dljtab_roff1; /* Offset for the ind 32 reloc into idata 5. */ 639 int how_dljtab_roff2; /* Offset for the ind 32 reloc into idata 5. */ 640 int how_dljtab_roff3; /* Offset for the ind 32 reloc into idata 5. */ 641 const char *trampoline; 642 }; 643 644 static const struct mac 645 mtable[] = 646 { 647 { 648 #define MARM 0 649 "arm", ".byte", ".short", ".long", ".asciz", "@", 650 "ldr\tip,[pc]\n\tldr\tpc,[ip]\n\t.long", 651 ".global", ".space", ".align\t2",".align\t4", "-mapcs-32", 652 "pe-arm-little", bfd_arch_arm, 653 arm_jtab, sizeof (arm_jtab), 8, 654 0, 0, 0, 0, 0, 0 655 } 656 , 657 { 658 #define M386 1 659 "i386", ".byte", ".short", ".long", ".asciz", "#", 660 "jmp *", ".global", ".space", ".align\t2",".align\t4", "", 661 "pe-i386",bfd_arch_i386, 662 i386_jtab, sizeof (i386_jtab), 2, 663 i386_dljtab, sizeof (i386_dljtab), 2, 7, 12, i386_trampoline 664 } 665 , 666 { 667 #define MPPC 2 668 "ppc", ".byte", ".short", ".long", ".asciz", "#", 669 "jmp *", ".global", ".space", ".align\t2",".align\t4", "", 670 "pe-powerpcle",bfd_arch_powerpc, 671 ppc_jtab, sizeof (ppc_jtab), 0, 672 0, 0, 0, 0, 0, 0 673 } 674 , 675 { 676 #define MTHUMB 3 677 "thumb", ".byte", ".short", ".long", ".asciz", "@", 678 "push\t{r6}\n\tldr\tr6, [pc, #8]\n\tldr\tr6, [r6]\n\tmov\tip, r6\n\tpop\t{r6}\n\tbx\tip", 679 ".global", ".space", ".align\t2",".align\t4", "-mthumb-interwork", 680 "pe-arm-little", bfd_arch_arm, 681 thumb_jtab, sizeof (thumb_jtab), 12, 682 0, 0, 0, 0, 0, 0 683 } 684 , 685 #define MARM_INTERWORK 4 686 { 687 "arm_interwork", ".byte", ".short", ".long", ".asciz", "@", 688 "ldr\tip,[pc]\n\tldr\tip,[ip]\n\tbx\tip\n\t.long", 689 ".global", ".space", ".align\t2",".align\t4", "-mthumb-interwork", 690 "pe-arm-little", bfd_arch_arm, 691 arm_interwork_jtab, sizeof (arm_interwork_jtab), 12, 692 0, 0, 0, 0, 0, 0 693 } 694 , 695 { 696 #define MMCORE_BE 5 697 "mcore-be", ".byte", ".short", ".long", ".asciz", "//", 698 "lrw r1,[1f]\n\tld.w r1,(r1,0)\n\tjmp r1\n\tnop\n1:.long", 699 ".global", ".space", ".align\t2",".align\t4", "", 700 "pe-mcore-big", bfd_arch_mcore, 701 mcore_be_jtab, sizeof (mcore_be_jtab), 8, 702 0, 0, 0, 0, 0, 0 703 } 704 , 705 { 706 #define MMCORE_LE 6 707 "mcore-le", ".byte", ".short", ".long", ".asciz", "//", 708 "lrw r1,[1f]\n\tld.w r1,(r1,0)\n\tjmp r1\n\tnop\n1:.long", 709 ".global", ".space", ".align\t2",".align\t4", "-EL", 710 "pe-mcore-little", bfd_arch_mcore, 711 mcore_le_jtab, sizeof (mcore_le_jtab), 8, 712 0, 0, 0, 0, 0, 0 713 } 714 , 715 { 716 #define MMCORE_ELF 7 717 "mcore-elf-be", ".byte", ".short", ".long", ".asciz", "//", 718 "lrw r1,[1f]\n\tld.w r1,(r1,0)\n\tjmp r1\n\tnop\n1:.long", 719 ".global", ".space", ".align\t2",".align\t4", "", 720 "elf32-mcore-big", bfd_arch_mcore, 721 mcore_be_jtab, sizeof (mcore_be_jtab), 8, 722 0, 0, 0, 0, 0, 0 723 } 724 , 725 { 726 #define MMCORE_ELF_LE 8 727 "mcore-elf-le", ".byte", ".short", ".long", ".asciz", "//", 728 "lrw r1,[1f]\n\tld.w r1,(r1,0)\n\tjmp r1\n\tnop\n1:.long", 729 ".global", ".space", ".align\t2",".align\t4", "-EL", 730 "elf32-mcore-little", bfd_arch_mcore, 731 mcore_le_jtab, sizeof (mcore_le_jtab), 8, 732 0, 0, 0, 0, 0, 0 733 } 734 , 735 { 736 #define MARM_EPOC 9 737 "arm-epoc", ".byte", ".short", ".long", ".asciz", "@", 738 "ldr\tip,[pc]\n\tldr\tpc,[ip]\n\t.long", 739 ".global", ".space", ".align\t2",".align\t4", "", 740 "epoc-pe-arm-little", bfd_arch_arm, 741 arm_jtab, sizeof (arm_jtab), 8, 742 0, 0, 0, 0, 0, 0 743 } 744 , 745 { 746 #define MARM_WINCE 10 747 "arm-wince", ".byte", ".short", ".long", ".asciz", "@", 748 "ldr\tip,[pc]\n\tldr\tpc,[ip]\n\t.long", 749 ".global", ".space", ".align\t2",".align\t4", "-mapcs-32", 750 "pe-arm-wince-little", bfd_arch_arm, 751 arm_jtab, sizeof (arm_jtab), 8, 752 0, 0, 0, 0, 0, 0 753 } 754 , 755 { 756 #define MX86 11 757 "i386:x86-64", ".byte", ".short", ".long", ".asciz", "#", 758 "jmp *", ".global", ".space", ".align\t2",".align\t4", "", 759 "pe-x86-64",bfd_arch_i386, 760 i386_jtab, sizeof (i386_jtab), 2, 761 i386_x64_dljtab, sizeof (i386_x64_dljtab), 2, 9, 14, i386_x64_trampoline 762 } 763 , 764 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } 765 }; 766 767 typedef struct dlist 768 { 769 char *text; 770 struct dlist *next; 771 } 772 dlist_type; 773 774 typedef struct export 775 { 776 const char *name; 777 const char *internal_name; 778 const char *import_name; 779 const char *its_name; 780 int ordinal; 781 int constant; 782 int noname; /* Don't put name in image file. */ 783 int private; /* Don't put reference in import lib. */ 784 int data; 785 int hint; 786 int forward; /* Number of forward label, 0 means no forward. */ 787 struct export *next; 788 } 789 export_type; 790 791 /* A list of symbols which we should not export. */ 792 793 struct string_list 794 { 795 struct string_list *next; 796 char *string; 797 }; 798 799 static struct string_list *excludes; 800 801 static const char *rvaafter (int); 802 static const char *rvabefore (int); 803 static const char *asm_prefix (int, const char *); 804 static void process_def_file (const char *); 805 static void new_directive (char *); 806 static void append_import (const char *, const char *, int, const char *); 807 static void run (const char *, char *); 808 static void scan_drectve_symbols (bfd *); 809 static void scan_filtered_symbols (bfd *, void *, long, unsigned int); 810 static void add_excludes (const char *); 811 static bfd_boolean match_exclude (const char *); 812 static void set_default_excludes (void); 813 static long filter_symbols (bfd *, void *, long, unsigned int); 814 static void scan_all_symbols (bfd *); 815 static void scan_open_obj_file (bfd *); 816 static void scan_obj_file (const char *); 817 static void dump_def_info (FILE *); 818 static int sfunc (const void *, const void *); 819 static void flush_page (FILE *, bfd_vma *, bfd_vma, int); 820 static void gen_def_file (void); 821 static void generate_idata_ofile (FILE *); 822 static void assemble_file (const char *, const char *); 823 static void gen_exp_file (void); 824 static const char *xlate (const char *); 825 static char *make_label (const char *, const char *); 826 static char *make_imp_label (const char *, const char *); 827 static bfd *make_one_lib_file (export_type *, int, int); 828 static bfd *make_head (void); 829 static bfd *make_tail (void); 830 static bfd *make_delay_head (void); 831 static void gen_lib_file (int); 832 static void dll_name_list_append (dll_name_list_type *, bfd_byte *); 833 static int dll_name_list_count (dll_name_list_type *); 834 static void dll_name_list_print (dll_name_list_type *); 835 static void dll_name_list_free_contents (dll_name_list_node_type *); 836 static void dll_name_list_free (dll_name_list_type *); 837 static dll_name_list_type * dll_name_list_create (void); 838 static void identify_dll_for_implib (void); 839 static void identify_search_archive 840 (bfd *, void (*) (bfd *, bfd *, void *), void *); 841 static void identify_search_member (bfd *, bfd *, void *); 842 static bfd_boolean identify_process_section_p (asection *, bfd_boolean); 843 static void identify_search_section (bfd *, asection *, void *); 844 static void identify_member_contains_symname (bfd *, bfd *, void *); 845 846 static int pfunc (const void *, const void *); 847 static int nfunc (const void *, const void *); 848 static void remove_null_names (export_type **); 849 static void process_duplicates (export_type **); 850 static void fill_ordinals (export_type **); 851 static void mangle_defs (void); 852 static void usage (FILE *, int); 853 static void inform (const char *, ...) ATTRIBUTE_PRINTF_1; 854 static void set_dll_name_from_def (const char *name, char is_dll); 855 856 static char * 857 prefix_encode (char *start, unsigned code) 858 { 859 static char alpha[26] = "abcdefghijklmnopqrstuvwxyz"; 860 static char buf[32]; 861 char *p; 862 strcpy (buf, start); 863 p = strchr (buf, '\0'); 864 do 865 *p++ = alpha[code % sizeof (alpha)]; 866 while ((code /= sizeof (alpha)) != 0); 867 *p = '\0'; 868 return buf; 869 } 870 871 static char * 872 dlltmp (char **buf, const char *fmt) 873 { 874 if (!*buf) 875 { 876 *buf = malloc (strlen (tmp_prefix) + 64); 877 sprintf (*buf, fmt, tmp_prefix); 878 } 879 return *buf; 880 } 881 882 static void 883 inform (const char * message, ...) 884 { 885 va_list args; 886 887 va_start (args, message); 888 889 if (!verbose) 890 return; 891 892 report (message, args); 893 894 va_end (args); 895 } 896 897 static const char * 898 rvaafter (int mach) 899 { 900 switch (mach) 901 { 902 case MARM: 903 case M386: 904 case MX86: 905 case MPPC: 906 case MTHUMB: 907 case MARM_INTERWORK: 908 case MMCORE_BE: 909 case MMCORE_LE: 910 case MMCORE_ELF: 911 case MMCORE_ELF_LE: 912 case MARM_EPOC: 913 case MARM_WINCE: 914 break; 915 default: 916 /* xgettext:c-format */ 917 fatal (_("Internal error: Unknown machine type: %d"), mach); 918 break; 919 } 920 return ""; 921 } 922 923 static const char * 924 rvabefore (int mach) 925 { 926 switch (mach) 927 { 928 case MARM: 929 case M386: 930 case MX86: 931 case MPPC: 932 case MTHUMB: 933 case MARM_INTERWORK: 934 case MMCORE_BE: 935 case MMCORE_LE: 936 case MMCORE_ELF: 937 case MMCORE_ELF_LE: 938 case MARM_EPOC: 939 case MARM_WINCE: 940 return ".rva\t"; 941 default: 942 /* xgettext:c-format */ 943 fatal (_("Internal error: Unknown machine type: %d"), mach); 944 break; 945 } 946 return ""; 947 } 948 949 static const char * 950 asm_prefix (int mach, const char *name) 951 { 952 switch (mach) 953 { 954 case MARM: 955 case MPPC: 956 case MTHUMB: 957 case MARM_INTERWORK: 958 case MMCORE_BE: 959 case MMCORE_LE: 960 case MMCORE_ELF: 961 case MMCORE_ELF_LE: 962 case MARM_EPOC: 963 case MARM_WINCE: 964 break; 965 case M386: 966 case MX86: 967 /* Symbol names starting with ? do not have a leading underscore. */ 968 if ((name && *name == '?') || leading_underscore == 0) 969 break; 970 else 971 return "_"; 972 default: 973 /* xgettext:c-format */ 974 fatal (_("Internal error: Unknown machine type: %d"), mach); 975 break; 976 } 977 return ""; 978 } 979 980 #define ASM_BYTE mtable[machine].how_byte 981 #define ASM_SHORT mtable[machine].how_short 982 #define ASM_LONG mtable[machine].how_long 983 #define ASM_TEXT mtable[machine].how_asciz 984 #define ASM_C mtable[machine].how_comment 985 #define ASM_JUMP mtable[machine].how_jump 986 #define ASM_GLOBAL mtable[machine].how_global 987 #define ASM_SPACE mtable[machine].how_space 988 #define ASM_ALIGN_SHORT mtable[machine].how_align_short 989 #define ASM_RVA_BEFORE rvabefore (machine) 990 #define ASM_RVA_AFTER rvaafter (machine) 991 #define ASM_PREFIX(NAME) asm_prefix (machine, (NAME)) 992 #define ASM_ALIGN_LONG mtable[machine].how_align_long 993 #define HOW_BFD_READ_TARGET 0 /* Always default. */ 994 #define HOW_BFD_WRITE_TARGET mtable[machine].how_bfd_target 995 #define HOW_BFD_ARCH mtable[machine].how_bfd_arch 996 #define HOW_JTAB (delay ? mtable[machine].how_dljtab \ 997 : mtable[machine].how_jtab) 998 #define HOW_JTAB_SIZE (delay ? mtable[machine].how_dljtab_size \ 999 : mtable[machine].how_jtab_size) 1000 #define HOW_JTAB_ROFF (delay ? mtable[machine].how_dljtab_roff1 \ 1001 : mtable[machine].how_jtab_roff) 1002 #define HOW_JTAB_ROFF2 (delay ? mtable[machine].how_dljtab_roff2 : 0) 1003 #define HOW_JTAB_ROFF3 (delay ? mtable[machine].how_dljtab_roff3 : 0) 1004 #define ASM_SWITCHES mtable[machine].how_default_as_switches 1005 1006 static char **oav; 1007 1008 static void 1009 process_def_file (const char *name) 1010 { 1011 FILE *f = fopen (name, FOPEN_RT); 1012 1013 if (!f) 1014 /* xgettext:c-format */ 1015 fatal (_("Can't open def file: %s"), name); 1016 1017 yyin = f; 1018 1019 /* xgettext:c-format */ 1020 inform (_("Processing def file: %s"), name); 1021 1022 yyparse (); 1023 1024 inform (_("Processed def file")); 1025 } 1026 1027 /**********************************************************************/ 1028 1029 /* Communications with the parser. */ 1030 1031 static int d_nfuncs; /* Number of functions exported. */ 1032 static int d_named_nfuncs; /* Number of named functions exported. */ 1033 static int d_low_ord; /* Lowest ordinal index. */ 1034 static int d_high_ord; /* Highest ordinal index. */ 1035 static export_type *d_exports; /* List of exported functions. */ 1036 static export_type **d_exports_lexically; /* Vector of exported functions in alpha order. */ 1037 static dlist_type *d_list; /* Descriptions. */ 1038 static dlist_type *a_list; /* Stuff to go in directives. */ 1039 static int d_nforwards = 0; /* Number of forwarded exports. */ 1040 1041 static int d_is_dll; 1042 static int d_is_exe; 1043 1044 int 1045 yyerror (const char * err ATTRIBUTE_UNUSED) 1046 { 1047 /* xgettext:c-format */ 1048 non_fatal (_("Syntax error in def file %s:%d"), def_file, linenumber); 1049 1050 return 0; 1051 } 1052 1053 void 1054 def_exports (const char *name, const char *internal_name, int ordinal, 1055 int noname, int constant, int data, int private, 1056 const char *its_name) 1057 { 1058 struct export *p = (struct export *) xmalloc (sizeof (*p)); 1059 1060 p->name = name; 1061 p->internal_name = internal_name ? internal_name : name; 1062 p->its_name = its_name; 1063 p->import_name = name; 1064 p->ordinal = ordinal; 1065 p->constant = constant; 1066 p->noname = noname; 1067 p->private = private; 1068 p->data = data; 1069 p->next = d_exports; 1070 d_exports = p; 1071 d_nfuncs++; 1072 1073 if ((internal_name != NULL) 1074 && (strchr (internal_name, '.') != NULL)) 1075 p->forward = ++d_nforwards; 1076 else 1077 p->forward = 0; /* no forward */ 1078 } 1079 1080 static void 1081 set_dll_name_from_def (const char *name, char is_dll) 1082 { 1083 const char *image_basename = lbasename (name); 1084 if (image_basename != name) 1085 non_fatal (_("%s: Path components stripped from image name, '%s'."), 1086 def_file, name); 1087 /* Append the default suffix, if none specified. */ 1088 if (strchr (image_basename, '.') == 0) 1089 { 1090 const char * suffix = is_dll ? ".dll" : ".exe"; 1091 1092 dll_name = xmalloc (strlen (image_basename) + strlen (suffix) + 1); 1093 sprintf (dll_name, "%s%s", image_basename, suffix); 1094 } 1095 else 1096 dll_name = xstrdup (image_basename); 1097 } 1098 1099 void 1100 def_name (const char *name, int base) 1101 { 1102 /* xgettext:c-format */ 1103 inform (_("NAME: %s base: %x"), name, base); 1104 1105 if (d_is_dll) 1106 non_fatal (_("Can't have LIBRARY and NAME")); 1107 1108 if (dll_name_set_by_exp_name && name && *name != 0) 1109 { 1110 dll_name = NULL; 1111 dll_name_set_by_exp_name = 0; 1112 } 1113 /* If --dllname not provided, use the one in the DEF file. 1114 FIXME: Is this appropriate for executables? */ 1115 if (!dll_name) 1116 set_dll_name_from_def (name, 0); 1117 d_is_exe = 1; 1118 } 1119 1120 void 1121 def_library (const char *name, int base) 1122 { 1123 /* xgettext:c-format */ 1124 inform (_("LIBRARY: %s base: %x"), name, base); 1125 1126 if (d_is_exe) 1127 non_fatal (_("Can't have LIBRARY and NAME")); 1128 1129 if (dll_name_set_by_exp_name && name && *name != 0) 1130 { 1131 dll_name = NULL; 1132 dll_name_set_by_exp_name = 0; 1133 } 1134 1135 /* If --dllname not provided, use the one in the DEF file. */ 1136 if (!dll_name) 1137 set_dll_name_from_def (name, 1); 1138 d_is_dll = 1; 1139 } 1140 1141 void 1142 def_description (const char *desc) 1143 { 1144 dlist_type *d = (dlist_type *) xmalloc (sizeof (dlist_type)); 1145 d->text = xstrdup (desc); 1146 d->next = d_list; 1147 d_list = d; 1148 } 1149 1150 static void 1151 new_directive (char *dir) 1152 { 1153 dlist_type *d = (dlist_type *) xmalloc (sizeof (dlist_type)); 1154 d->text = xstrdup (dir); 1155 d->next = a_list; 1156 a_list = d; 1157 } 1158 1159 void 1160 def_heapsize (int reserve, int commit) 1161 { 1162 char b[200]; 1163 if (commit > 0) 1164 sprintf (b, "-heap 0x%x,0x%x ", reserve, commit); 1165 else 1166 sprintf (b, "-heap 0x%x ", reserve); 1167 new_directive (xstrdup (b)); 1168 } 1169 1170 void 1171 def_stacksize (int reserve, int commit) 1172 { 1173 char b[200]; 1174 if (commit > 0) 1175 sprintf (b, "-stack 0x%x,0x%x ", reserve, commit); 1176 else 1177 sprintf (b, "-stack 0x%x ", reserve); 1178 new_directive (xstrdup (b)); 1179 } 1180 1181 /* append_import simply adds the given import definition to the global 1182 import_list. It is used by def_import. */ 1183 1184 static void 1185 append_import (const char *symbol_name, const char *dllname, int func_ordinal, 1186 const char *its_name) 1187 { 1188 iheadtype **pq; 1189 iheadtype *q; 1190 1191 for (pq = &import_list; *pq != NULL; pq = &(*pq)->next) 1192 { 1193 if (strcmp ((*pq)->dllname, dllname) == 0) 1194 { 1195 q = *pq; 1196 q->functail->next = xmalloc (sizeof (ifunctype)); 1197 q->functail = q->functail->next; 1198 q->functail->ord = func_ordinal; 1199 q->functail->name = xstrdup (symbol_name); 1200 q->functail->its_name = (its_name ? xstrdup (its_name) : NULL); 1201 q->functail->next = NULL; 1202 q->nfuncs++; 1203 return; 1204 } 1205 } 1206 1207 q = xmalloc (sizeof (iheadtype)); 1208 q->dllname = xstrdup (dllname); 1209 q->nfuncs = 1; 1210 q->funchead = xmalloc (sizeof (ifunctype)); 1211 q->functail = q->funchead; 1212 q->next = NULL; 1213 q->functail->name = xstrdup (symbol_name); 1214 q->functail->its_name = (its_name ? xstrdup (its_name) : NULL); 1215 q->functail->ord = func_ordinal; 1216 q->functail->next = NULL; 1217 1218 *pq = q; 1219 } 1220 1221 /* def_import is called from within defparse.y when an IMPORT 1222 declaration is encountered. Depending on the form of the 1223 declaration, the module name may or may not need ".dll" to be 1224 appended to it, the name of the function may be stored in internal 1225 or entry, and there may or may not be an ordinal value associated 1226 with it. */ 1227 1228 /* A note regarding the parse modes: 1229 In defparse.y we have to accept import declarations which follow 1230 any one of the following forms: 1231 <func_name_in_app> = <dll_name>.<func_name_in_dll> 1232 <func_name_in_app> = <dll_name>.<number> 1233 <dll_name>.<func_name_in_dll> 1234 <dll_name>.<number> 1235 Furthermore, the dll's name may or may not end with ".dll", which 1236 complicates the parsing a little. Normally the dll's name is 1237 passed to def_import() in the "module" parameter, but when it ends 1238 with ".dll" it gets passed in "module" sans ".dll" and that needs 1239 to be reappended. 1240 1241 def_import gets five parameters: 1242 APP_NAME - the name of the function in the application, if 1243 present, or NULL if not present. 1244 MODULE - the name of the dll, possibly sans extension (ie, '.dll'). 1245 DLLEXT - the extension of the dll, if present, NULL if not present. 1246 ENTRY - the name of the function in the dll, if present, or NULL. 1247 ORD_VAL - the numerical tag of the function in the dll, if present, 1248 or NULL. Exactly one of <entry> or <ord_val> must be 1249 present (i.e., not NULL). */ 1250 1251 void 1252 def_import (const char *app_name, const char *module, const char *dllext, 1253 const char *entry, int ord_val, const char *its_name) 1254 { 1255 const char *application_name; 1256 char *buf = NULL; 1257 1258 if (entry != NULL) 1259 application_name = entry; 1260 else 1261 { 1262 if (app_name != NULL) 1263 application_name = app_name; 1264 else 1265 application_name = ""; 1266 } 1267 1268 if (dllext != NULL) 1269 module = buf = concat (module, ".", dllext, NULL); 1270 1271 append_import (application_name, module, ord_val, its_name); 1272 1273 if (buf) 1274 free (buf); 1275 } 1276 1277 void 1278 def_version (int major, int minor) 1279 { 1280 printf (_("VERSION %d.%d\n"), major, minor); 1281 } 1282 1283 void 1284 def_section (const char *name, int attr) 1285 { 1286 char buf[200]; 1287 char atts[5]; 1288 char *d = atts; 1289 if (attr & 1) 1290 *d++ = 'R'; 1291 1292 if (attr & 2) 1293 *d++ = 'W'; 1294 if (attr & 4) 1295 *d++ = 'X'; 1296 if (attr & 8) 1297 *d++ = 'S'; 1298 *d++ = 0; 1299 sprintf (buf, "-attr %s %s", name, atts); 1300 new_directive (xstrdup (buf)); 1301 } 1302 1303 void 1304 def_code (int attr) 1305 { 1306 1307 def_section ("CODE", attr); 1308 } 1309 1310 void 1311 def_data (int attr) 1312 { 1313 def_section ("DATA", attr); 1314 } 1315 1316 /**********************************************************************/ 1317 1318 static void 1319 run (const char *what, char *args) 1320 { 1321 char *s; 1322 int pid, wait_status; 1323 int i; 1324 const char **argv; 1325 char *errmsg_fmt, *errmsg_arg; 1326 char *temp_base = choose_temp_base (); 1327 1328 inform (_("run: %s %s"), what, args); 1329 1330 /* Count the args */ 1331 i = 0; 1332 for (s = args; *s; s++) 1333 if (*s == ' ') 1334 i++; 1335 i++; 1336 argv = xmalloc (sizeof (char *) * (i + 3)); 1337 i = 0; 1338 argv[i++] = what; 1339 s = args; 1340 while (1) 1341 { 1342 while (*s == ' ') 1343 ++s; 1344 argv[i++] = s; 1345 while (*s != ' ' && *s != 0) 1346 s++; 1347 if (*s == 0) 1348 break; 1349 *s++ = 0; 1350 } 1351 argv[i++] = NULL; 1352 1353 pid = pexecute (argv[0], (char * const *) argv, program_name, temp_base, 1354 &errmsg_fmt, &errmsg_arg, PEXECUTE_ONE | PEXECUTE_SEARCH); 1355 free(argv); 1356 1357 if (pid == -1) 1358 { 1359 inform ("%s", strerror (errno)); 1360 1361 fatal (errmsg_fmt, errmsg_arg); 1362 } 1363 1364 pid = pwait (pid, & wait_status, 0); 1365 1366 if (pid == -1) 1367 { 1368 /* xgettext:c-format */ 1369 fatal (_("wait: %s"), strerror (errno)); 1370 } 1371 else if (WIFSIGNALED (wait_status)) 1372 { 1373 /* xgettext:c-format */ 1374 fatal (_("subprocess got fatal signal %d"), WTERMSIG (wait_status)); 1375 } 1376 else if (WIFEXITED (wait_status)) 1377 { 1378 if (WEXITSTATUS (wait_status) != 0) 1379 /* xgettext:c-format */ 1380 non_fatal (_("%s exited with status %d"), 1381 what, WEXITSTATUS (wait_status)); 1382 } 1383 else 1384 abort (); 1385 } 1386 1387 /* Look for a list of symbols to export in the .drectve section of 1388 ABFD. Pass each one to def_exports. */ 1389 1390 static void 1391 scan_drectve_symbols (bfd *abfd) 1392 { 1393 asection * s; 1394 int size; 1395 char * buf; 1396 char * p; 1397 char * e; 1398 1399 /* Look for .drectve's */ 1400 s = bfd_get_section_by_name (abfd, DRECTVE_SECTION_NAME); 1401 1402 if (s == NULL) 1403 return; 1404 1405 size = bfd_get_section_size (s); 1406 buf = xmalloc (size); 1407 1408 bfd_get_section_contents (abfd, s, buf, 0, size); 1409 1410 /* xgettext:c-format */ 1411 inform (_("Sucking in info from %s section in %s"), 1412 DRECTVE_SECTION_NAME, bfd_get_filename (abfd)); 1413 1414 /* Search for -export: strings. The exported symbols can optionally 1415 have type tags (eg., -export:foo,data), so handle those as well. 1416 Currently only data tag is supported. */ 1417 p = buf; 1418 e = buf + size; 1419 while (p < e) 1420 { 1421 if (p[0] == '-' 1422 && CONST_STRNEQ (p, "-export:")) 1423 { 1424 char * name; 1425 char * c; 1426 flagword flags = BSF_FUNCTION; 1427 1428 p += 8; 1429 /* Do we have a quoted export? */ 1430 if (*p == '"') 1431 { 1432 p++; 1433 name = p; 1434 while (p < e && *p != '"') 1435 ++p; 1436 } 1437 else 1438 { 1439 name = p; 1440 while (p < e && *p != ',' && *p != ' ' && *p != '-') 1441 p++; 1442 } 1443 c = xmalloc (p - name + 1); 1444 memcpy (c, name, p - name); 1445 c[p - name] = 0; 1446 /* Advance over trailing quote. */ 1447 if (p < e && *p == '"') 1448 ++p; 1449 if (p < e && *p == ',') /* found type tag. */ 1450 { 1451 char *tag_start = ++p; 1452 while (p < e && *p != ' ' && *p != '-') 1453 p++; 1454 if (CONST_STRNEQ (tag_start, "data")) 1455 flags &= ~BSF_FUNCTION; 1456 } 1457 1458 /* FIXME: The 5th arg is for the `constant' field. 1459 What should it be? Not that it matters since it's not 1460 currently useful. */ 1461 def_exports (c, 0, -1, 0, 0, ! (flags & BSF_FUNCTION), 0, NULL); 1462 1463 if (add_stdcall_alias && strchr (c, '@')) 1464 { 1465 int lead_at = (*c == '@') ; 1466 char *exported_name = xstrdup (c + lead_at); 1467 char *atsym = strchr (exported_name, '@'); 1468 *atsym = '\0'; 1469 /* Note: stdcall alias symbols can never be data. */ 1470 def_exports (exported_name, xstrdup (c), -1, 0, 0, 0, 0, NULL); 1471 } 1472 } 1473 else 1474 p++; 1475 } 1476 free (buf); 1477 } 1478 1479 /* Look through the symbols in MINISYMS, and add each one to list of 1480 symbols to export. */ 1481 1482 static void 1483 scan_filtered_symbols (bfd *abfd, void *minisyms, long symcount, 1484 unsigned int size) 1485 { 1486 asymbol *store; 1487 bfd_byte *from, *fromend; 1488 1489 store = bfd_make_empty_symbol (abfd); 1490 if (store == NULL) 1491 bfd_fatal (bfd_get_filename (abfd)); 1492 1493 from = (bfd_byte *) minisyms; 1494 fromend = from + symcount * size; 1495 for (; from < fromend; from += size) 1496 { 1497 asymbol *sym; 1498 const char *symbol_name; 1499 1500 sym = bfd_minisymbol_to_symbol (abfd, FALSE, from, store); 1501 if (sym == NULL) 1502 bfd_fatal (bfd_get_filename (abfd)); 1503 1504 symbol_name = bfd_asymbol_name (sym); 1505 if (bfd_get_symbol_leading_char (abfd) == symbol_name[0]) 1506 ++symbol_name; 1507 1508 def_exports (xstrdup (symbol_name) , 0, -1, 0, 0, 1509 ! (sym->flags & BSF_FUNCTION), 0, NULL); 1510 1511 if (add_stdcall_alias && strchr (symbol_name, '@')) 1512 { 1513 int lead_at = (*symbol_name == '@'); 1514 char *exported_name = xstrdup (symbol_name + lead_at); 1515 char *atsym = strchr (exported_name, '@'); 1516 *atsym = '\0'; 1517 /* Note: stdcall alias symbols can never be data. */ 1518 def_exports (exported_name, xstrdup (symbol_name), -1, 0, 0, 0, 0, NULL); 1519 } 1520 } 1521 } 1522 1523 /* Add a list of symbols to exclude. */ 1524 1525 static void 1526 add_excludes (const char *new_excludes) 1527 { 1528 char *local_copy; 1529 char *exclude_string; 1530 1531 local_copy = xstrdup (new_excludes); 1532 1533 exclude_string = strtok (local_copy, ",:"); 1534 for (; exclude_string; exclude_string = strtok (NULL, ",:")) 1535 { 1536 struct string_list *new_exclude; 1537 1538 new_exclude = ((struct string_list *) 1539 xmalloc (sizeof (struct string_list))); 1540 new_exclude->string = (char *) xmalloc (strlen (exclude_string) + 2); 1541 /* Don't add a leading underscore for fastcall symbols. */ 1542 if (*exclude_string == '@') 1543 sprintf (new_exclude->string, "%s", exclude_string); 1544 else 1545 sprintf (new_exclude->string, "%s%s", (!leading_underscore ? "" : "_"), 1546 exclude_string); 1547 new_exclude->next = excludes; 1548 excludes = new_exclude; 1549 1550 /* xgettext:c-format */ 1551 inform (_("Excluding symbol: %s"), exclude_string); 1552 } 1553 1554 free (local_copy); 1555 } 1556 1557 /* See if STRING is on the list of symbols to exclude. */ 1558 1559 static bfd_boolean 1560 match_exclude (const char *string) 1561 { 1562 struct string_list *excl_item; 1563 1564 for (excl_item = excludes; excl_item; excl_item = excl_item->next) 1565 if (strcmp (string, excl_item->string) == 0) 1566 return TRUE; 1567 return FALSE; 1568 } 1569 1570 /* Add the default list of symbols to exclude. */ 1571 1572 static void 1573 set_default_excludes (void) 1574 { 1575 add_excludes (default_excludes); 1576 } 1577 1578 /* Choose which symbols to export. */ 1579 1580 static long 1581 filter_symbols (bfd *abfd, void *minisyms, long symcount, unsigned int size) 1582 { 1583 bfd_byte *from, *fromend, *to; 1584 asymbol *store; 1585 1586 store = bfd_make_empty_symbol (abfd); 1587 if (store == NULL) 1588 bfd_fatal (bfd_get_filename (abfd)); 1589 1590 from = (bfd_byte *) minisyms; 1591 fromend = from + symcount * size; 1592 to = (bfd_byte *) minisyms; 1593 1594 for (; from < fromend; from += size) 1595 { 1596 int keep = 0; 1597 asymbol *sym; 1598 1599 sym = bfd_minisymbol_to_symbol (abfd, FALSE, (const void *) from, store); 1600 if (sym == NULL) 1601 bfd_fatal (bfd_get_filename (abfd)); 1602 1603 /* Check for external and defined only symbols. */ 1604 keep = (((sym->flags & BSF_GLOBAL) != 0 1605 || (sym->flags & BSF_WEAK) != 0 1606 || bfd_is_com_section (sym->section)) 1607 && ! bfd_is_und_section (sym->section)); 1608 1609 keep = keep && ! match_exclude (sym->name); 1610 1611 if (keep) 1612 { 1613 memcpy (to, from, size); 1614 to += size; 1615 } 1616 } 1617 1618 return (to - (bfd_byte *) minisyms) / size; 1619 } 1620 1621 /* Export all symbols in ABFD, except for ones we were told not to 1622 export. */ 1623 1624 static void 1625 scan_all_symbols (bfd *abfd) 1626 { 1627 long symcount; 1628 void *minisyms; 1629 unsigned int size; 1630 1631 /* Ignore bfds with an import descriptor table. We assume that any 1632 such BFD contains symbols which are exported from another DLL, 1633 and we don't want to reexport them from here. */ 1634 if (bfd_get_section_by_name (abfd, ".idata$4")) 1635 return; 1636 1637 if (! (bfd_get_file_flags (abfd) & HAS_SYMS)) 1638 { 1639 /* xgettext:c-format */ 1640 non_fatal (_("%s: no symbols"), bfd_get_filename (abfd)); 1641 return; 1642 } 1643 1644 symcount = bfd_read_minisymbols (abfd, FALSE, &minisyms, &size); 1645 if (symcount < 0) 1646 bfd_fatal (bfd_get_filename (abfd)); 1647 1648 if (symcount == 0) 1649 { 1650 /* xgettext:c-format */ 1651 non_fatal (_("%s: no symbols"), bfd_get_filename (abfd)); 1652 return; 1653 } 1654 1655 /* Discard the symbols we don't want to export. It's OK to do this 1656 in place; we'll free the storage anyway. */ 1657 1658 symcount = filter_symbols (abfd, minisyms, symcount, size); 1659 scan_filtered_symbols (abfd, minisyms, symcount, size); 1660 1661 free (minisyms); 1662 } 1663 1664 /* Look at the object file to decide which symbols to export. */ 1665 1666 static void 1667 scan_open_obj_file (bfd *abfd) 1668 { 1669 if (export_all_symbols) 1670 scan_all_symbols (abfd); 1671 else 1672 scan_drectve_symbols (abfd); 1673 1674 /* FIXME: we ought to read in and block out the base relocations. */ 1675 1676 /* xgettext:c-format */ 1677 inform (_("Done reading %s"), bfd_get_filename (abfd)); 1678 } 1679 1680 static void 1681 scan_obj_file (const char *filename) 1682 { 1683 bfd * f = bfd_openr (filename, 0); 1684 1685 if (!f) 1686 /* xgettext:c-format */ 1687 fatal (_("Unable to open object file: %s: %s"), filename, bfd_get_errmsg ()); 1688 1689 /* xgettext:c-format */ 1690 inform (_("Scanning object file %s"), filename); 1691 1692 if (bfd_check_format (f, bfd_archive)) 1693 { 1694 bfd *arfile = bfd_openr_next_archived_file (f, 0); 1695 while (arfile) 1696 { 1697 bfd *next; 1698 if (bfd_check_format (arfile, bfd_object)) 1699 scan_open_obj_file (arfile); 1700 next = bfd_openr_next_archived_file (f, arfile); 1701 bfd_close (arfile); 1702 /* PR 17512: file: 58715298. */ 1703 if (next == arfile) 1704 break; 1705 arfile = next; 1706 } 1707 1708 #ifdef DLLTOOL_MCORE_ELF 1709 if (mcore_elf_out_file) 1710 inform (_("Cannot produce mcore-elf dll from archive file: %s"), filename); 1711 #endif 1712 } 1713 else if (bfd_check_format (f, bfd_object)) 1714 { 1715 scan_open_obj_file (f); 1716 1717 #ifdef DLLTOOL_MCORE_ELF 1718 if (mcore_elf_out_file) 1719 mcore_elf_cache_filename (filename); 1720 #endif 1721 } 1722 1723 bfd_close (f); 1724 } 1725 1726 1727 1729 static void 1730 dump_def_info (FILE *f) 1731 { 1732 int i; 1733 export_type *exp; 1734 fprintf (f, "%s ", ASM_C); 1735 for (i = 0; oav[i]; i++) 1736 fprintf (f, "%s ", oav[i]); 1737 fprintf (f, "\n"); 1738 for (i = 0, exp = d_exports; exp; i++, exp = exp->next) 1739 { 1740 fprintf (f, "%s %d = %s %s @ %d %s%s%s%s%s%s\n", 1741 ASM_C, 1742 i, 1743 exp->name, 1744 exp->internal_name, 1745 exp->ordinal, 1746 exp->noname ? "NONAME " : "", 1747 exp->private ? "PRIVATE " : "", 1748 exp->constant ? "CONSTANT" : "", 1749 exp->data ? "DATA" : "", 1750 exp->its_name ? " ==" : "", 1751 exp->its_name ? exp->its_name : ""); 1752 } 1753 } 1754 1755 /* Generate the .exp file. */ 1756 1757 static int 1758 sfunc (const void *a, const void *b) 1759 { 1760 if (*(const bfd_vma *) a == *(const bfd_vma *) b) 1761 return 0; 1762 1763 return ((*(const bfd_vma *) a > *(const bfd_vma *) b) ? 1 : -1); 1764 } 1765 1766 static void 1767 flush_page (FILE *f, bfd_vma *need, bfd_vma page_addr, int on_page) 1768 { 1769 int i; 1770 1771 /* Flush this page. */ 1772 fprintf (f, "\t%s\t0x%08x\t%s Starting RVA for chunk\n", 1773 ASM_LONG, 1774 (int) page_addr, 1775 ASM_C); 1776 fprintf (f, "\t%s\t0x%x\t%s Size of block\n", 1777 ASM_LONG, 1778 (on_page * 2) + (on_page & 1) * 2 + 8, 1779 ASM_C); 1780 1781 for (i = 0; i < on_page; i++) 1782 { 1783 bfd_vma needed = need[i]; 1784 1785 if (needed) 1786 { 1787 if (!create_for_pep) 1788 { 1789 /* Relocation via HIGHLOW. */ 1790 needed = ((needed - page_addr) | 0x3000) & 0xffff; 1791 } 1792 else 1793 { 1794 /* Relocation via DIR64. */ 1795 needed = ((needed - page_addr) | 0xa000) & 0xffff; 1796 } 1797 } 1798 1799 fprintf (f, "\t%s\t0x%lx\n", ASM_SHORT, (long) needed); 1800 } 1801 1802 /* And padding */ 1803 if (on_page & 1) 1804 fprintf (f, "\t%s\t0x%x\n", ASM_SHORT, 0 | 0x0000); 1805 } 1806 1807 static void 1808 gen_def_file (void) 1809 { 1810 int i; 1811 export_type *exp; 1812 1813 inform (_("Adding exports to output file")); 1814 1815 fprintf (output_def, ";"); 1816 for (i = 0; oav[i]; i++) 1817 fprintf (output_def, " %s", oav[i]); 1818 1819 fprintf (output_def, "\nEXPORTS\n"); 1820 1821 for (i = 0, exp = d_exports; exp; i++, exp = exp->next) 1822 { 1823 char *quote = strchr (exp->name, '.') ? "\"" : ""; 1824 char *res = cplus_demangle (exp->internal_name, DMGL_ANSI | DMGL_PARAMS); 1825 1826 if (res) 1827 { 1828 fprintf (output_def,";\t%s\n", res); 1829 free (res); 1830 } 1831 1832 if (strcmp (exp->name, exp->internal_name) == 0) 1833 { 1834 fprintf (output_def, "\t%s%s%s @ %d%s%s%s%s%s\n", 1835 quote, 1836 exp->name, 1837 quote, 1838 exp->ordinal, 1839 exp->noname ? " NONAME" : "", 1840 exp->private ? "PRIVATE " : "", 1841 exp->data ? " DATA" : "", 1842 exp->its_name ? " ==" : "", 1843 exp->its_name ? exp->its_name : ""); 1844 } 1845 else 1846 { 1847 char * quote1 = strchr (exp->internal_name, '.') ? "\"" : ""; 1848 /* char *alias = */ 1849 fprintf (output_def, "\t%s%s%s = %s%s%s @ %d%s%s%s%s%s\n", 1850 quote, 1851 exp->name, 1852 quote, 1853 quote1, 1854 exp->internal_name, 1855 quote1, 1856 exp->ordinal, 1857 exp->noname ? " NONAME" : "", 1858 exp->private ? "PRIVATE " : "", 1859 exp->data ? " DATA" : "", 1860 exp->its_name ? " ==" : "", 1861 exp->its_name ? exp->its_name : ""); 1862 } 1863 } 1864 1865 inform (_("Added exports to output file")); 1866 } 1867 1868 /* generate_idata_ofile generates the portable assembly source code 1869 for the idata sections. It appends the source code to the end of 1870 the file. */ 1871 1872 static void 1873 generate_idata_ofile (FILE *filvar) 1874 { 1875 iheadtype *headptr; 1876 ifunctype *funcptr; 1877 int headindex; 1878 int funcindex; 1879 int nheads; 1880 1881 if (import_list == NULL) 1882 return; 1883 1884 fprintf (filvar, "%s Import data sections\n", ASM_C); 1885 fprintf (filvar, "\n\t.section\t.idata$2\n"); 1886 fprintf (filvar, "\t%s\tdoi_idata\n", ASM_GLOBAL); 1887 fprintf (filvar, "doi_idata:\n"); 1888 1889 nheads = 0; 1890 for (headptr = import_list; headptr != NULL; headptr = headptr->next) 1891 { 1892 fprintf (filvar, "\t%slistone%d%s\t%s %s\n", 1893 ASM_RVA_BEFORE, nheads, ASM_RVA_AFTER, 1894 ASM_C, headptr->dllname); 1895 fprintf (filvar, "\t%s\t0\n", ASM_LONG); 1896 fprintf (filvar, "\t%s\t0\n", ASM_LONG); 1897 fprintf (filvar, "\t%sdllname%d%s\n", 1898 ASM_RVA_BEFORE, nheads, ASM_RVA_AFTER); 1899 fprintf (filvar, "\t%slisttwo%d%s\n\n", 1900 ASM_RVA_BEFORE, nheads, ASM_RVA_AFTER); 1901 nheads++; 1902 } 1903 1904 fprintf (filvar, "\t%s\t0\n", ASM_LONG); /* NULL record at */ 1905 fprintf (filvar, "\t%s\t0\n", ASM_LONG); /* end of idata$2 */ 1906 fprintf (filvar, "\t%s\t0\n", ASM_LONG); /* section */ 1907 fprintf (filvar, "\t%s\t0\n", ASM_LONG); 1908 fprintf (filvar, "\t%s\t0\n", ASM_LONG); 1909 1910 fprintf (filvar, "\n\t.section\t.idata$4\n"); 1911 headindex = 0; 1912 for (headptr = import_list; headptr != NULL; headptr = headptr->next) 1913 { 1914 fprintf (filvar, "listone%d:\n", headindex); 1915 for (funcindex = 0; funcindex < headptr->nfuncs; funcindex++) 1916 { 1917 if (create_for_pep) 1918 fprintf (filvar, "\t%sfuncptr%d_%d%s\n%s\t0\n", 1919 ASM_RVA_BEFORE, headindex, funcindex, ASM_RVA_AFTER, 1920 ASM_LONG); 1921 else 1922 fprintf (filvar, "\t%sfuncptr%d_%d%s\n", 1923 ASM_RVA_BEFORE, headindex, funcindex, ASM_RVA_AFTER); 1924 } 1925 if (create_for_pep) 1926 fprintf (filvar, "\t%s\t0\n\t%s\t0\n", ASM_LONG, ASM_LONG); 1927 else 1928 fprintf (filvar, "\t%s\t0\n", ASM_LONG); /* NULL terminating list. */ 1929 headindex++; 1930 } 1931 1932 fprintf (filvar, "\n\t.section\t.idata$5\n"); 1933 headindex = 0; 1934 for (headptr = import_list; headptr != NULL; headptr = headptr->next) 1935 { 1936 fprintf (filvar, "listtwo%d:\n", headindex); 1937 for (funcindex = 0; funcindex < headptr->nfuncs; funcindex++) 1938 { 1939 if (create_for_pep) 1940 fprintf (filvar, "\t%sfuncptr%d_%d%s\n%s\t0\n", 1941 ASM_RVA_BEFORE, headindex, funcindex, ASM_RVA_AFTER, 1942 ASM_LONG); 1943 else 1944 fprintf (filvar, "\t%sfuncptr%d_%d%s\n", 1945 ASM_RVA_BEFORE, headindex, funcindex, ASM_RVA_AFTER); 1946 } 1947 if (create_for_pep) 1948 fprintf (filvar, "\t%s\t0\n\t%s\t0\n", ASM_LONG, ASM_LONG); 1949 else 1950 fprintf (filvar, "\t%s\t0\n", ASM_LONG); /* NULL terminating list. */ 1951 headindex++; 1952 } 1953 1954 fprintf (filvar, "\n\t.section\t.idata$6\n"); 1955 headindex = 0; 1956 for (headptr = import_list; headptr != NULL; headptr = headptr->next) 1957 { 1958 funcindex = 0; 1959 for (funcptr = headptr->funchead; funcptr != NULL; 1960 funcptr = funcptr->next) 1961 { 1962 fprintf (filvar,"funcptr%d_%d:\n", headindex, funcindex); 1963 fprintf (filvar,"\t%s\t%d\n", ASM_SHORT, 1964 ((funcptr->ord) & 0xFFFF)); 1965 fprintf (filvar,"\t%s\t\"%s\"\n", ASM_TEXT, 1966 (funcptr->its_name ? funcptr->its_name : funcptr->name)); 1967 fprintf (filvar,"\t%s\t0\n", ASM_BYTE); 1968 funcindex++; 1969 } 1970 headindex++; 1971 } 1972 1973 fprintf (filvar, "\n\t.section\t.idata$7\n"); 1974 headindex = 0; 1975 for (headptr = import_list; headptr != NULL; headptr = headptr->next) 1976 { 1977 fprintf (filvar,"dllname%d:\n", headindex); 1978 fprintf (filvar,"\t%s\t\"%s\"\n", ASM_TEXT, headptr->dllname); 1979 fprintf (filvar,"\t%s\t0\n", ASM_BYTE); 1980 headindex++; 1981 } 1982 } 1983 1984 /* Assemble the specified file. */ 1985 static void 1986 assemble_file (const char * source, const char * dest) 1987 { 1988 char * cmd; 1989 1990 cmd = xmalloc (strlen (ASM_SWITCHES) + strlen (as_flags) 1991 + strlen (source) + strlen (dest) + 50); 1992 1993 sprintf (cmd, "%s %s -o %s %s", ASM_SWITCHES, as_flags, dest, source); 1994 1995 run (as_name, cmd); 1996 free (cmd); 1997 } 1998 1999 static const char * temp_file_to_remove[5]; 2000 #define TEMP_EXPORT_FILE 0 2001 #define TEMP_HEAD_FILE 1 2002 #define TEMP_TAIL_FILE 2 2003 #define TEMP_HEAD_O_FILE 3 2004 #define TEMP_TAIL_O_FILE 4 2005 2006 static void 2007 unlink_temp_files (void) 2008 { 2009 unsigned i; 2010 2011 if (dontdeltemps > 0) 2012 return; 2013 2014 for (i = 0; i < ARRAY_SIZE (temp_file_to_remove); i++) 2015 { 2016 if (temp_file_to_remove[i]) 2017 { 2018 unlink (temp_file_to_remove[i]); 2019 temp_file_to_remove[i] = NULL; 2020 } 2021 } 2022 } 2023 2024 static void 2025 gen_exp_file (void) 2026 { 2027 FILE *f; 2028 int i; 2029 export_type *exp; 2030 dlist_type *dl; 2031 2032 /* xgettext:c-format */ 2033 inform (_("Generating export file: %s"), exp_name); 2034 2035 f = fopen (TMP_ASM, FOPEN_WT); 2036 if (!f) 2037 /* xgettext:c-format */ 2038 fatal (_("Unable to open temporary assembler file: %s"), TMP_ASM); 2039 2040 temp_file_to_remove[TEMP_EXPORT_FILE] = TMP_ASM; 2041 2042 /* xgettext:c-format */ 2043 inform (_("Opened temporary file: %s"), TMP_ASM); 2044 2045 dump_def_info (f); 2046 2047 if (d_exports) 2048 { 2049 fprintf (f, "\t.section .edata\n\n"); 2050 fprintf (f, "\t%s 0 %s Allways 0\n", ASM_LONG, ASM_C); 2051 fprintf (f, "\t%s 0x%lx %s Time and date\n", ASM_LONG, 2052 (unsigned long) time(0), ASM_C); 2053 fprintf (f, "\t%s 0 %s Major and Minor version\n", ASM_LONG, ASM_C); 2054 fprintf (f, "\t%sname%s %s Ptr to name of dll\n", ASM_RVA_BEFORE, ASM_RVA_AFTER, ASM_C); 2055 fprintf (f, "\t%s %d %s Starting ordinal of exports\n", ASM_LONG, d_low_ord, ASM_C); 2056 2057 2058 fprintf (f, "\t%s %d %s Number of functions\n", ASM_LONG, d_high_ord - d_low_ord + 1, ASM_C); 2059 fprintf(f,"\t%s named funcs %d, low ord %d, high ord %d\n", 2060 ASM_C, 2061 d_named_nfuncs, d_low_ord, d_high_ord); 2062 fprintf (f, "\t%s %d %s Number of names\n", ASM_LONG, 2063 show_allnames ? d_high_ord - d_low_ord + 1 : d_named_nfuncs, ASM_C); 2064 fprintf (f, "\t%safuncs%s %s Address of functions\n", ASM_RVA_BEFORE, ASM_RVA_AFTER, ASM_C); 2065 2066 fprintf (f, "\t%sanames%s %s Address of Name Pointer Table\n", 2067 ASM_RVA_BEFORE, ASM_RVA_AFTER, ASM_C); 2068 2069 fprintf (f, "\t%sanords%s %s Address of ordinals\n", ASM_RVA_BEFORE, ASM_RVA_AFTER, ASM_C); 2070 2071 fprintf (f, "name: %s \"%s\"\n", ASM_TEXT, dll_name); 2072 2073 2074 fprintf(f,"%s Export address Table\n", ASM_C); 2075 fprintf(f,"\t%s\n", ASM_ALIGN_LONG); 2076 fprintf (f, "afuncs:\n"); 2077 i = d_low_ord; 2078 2079 for (exp = d_exports; exp; exp = exp->next) 2080 { 2081 if (exp->ordinal != i) 2082 { 2083 while (i < exp->ordinal) 2084 { 2085 fprintf(f,"\t%s\t0\n", ASM_LONG); 2086 i++; 2087 } 2088 } 2089 2090 if (exp->forward == 0) 2091 { 2092 if (exp->internal_name[0] == '@') 2093 fprintf (f, "\t%s%s%s\t%s %d\n", ASM_RVA_BEFORE, 2094 exp->internal_name, ASM_RVA_AFTER, ASM_C, exp->ordinal); 2095 else 2096 fprintf (f, "\t%s%s%s%s\t%s %d\n", ASM_RVA_BEFORE, 2097 ASM_PREFIX (exp->internal_name), 2098 exp->internal_name, ASM_RVA_AFTER, ASM_C, exp->ordinal); 2099 } 2100 else 2101 fprintf (f, "\t%sf%d%s\t%s %d\n", ASM_RVA_BEFORE, 2102 exp->forward, ASM_RVA_AFTER, ASM_C, exp->ordinal); 2103 i++; 2104 } 2105 2106 fprintf (f,"%s Export Name Pointer Table\n", ASM_C); 2107 fprintf (f, "anames:\n"); 2108 2109 for (i = 0; (exp = d_exports_lexically[i]); i++) 2110 { 2111 if (!exp->noname || show_allnames) 2112 fprintf (f, "\t%sn%d%s\n", 2113 ASM_RVA_BEFORE, exp->ordinal, ASM_RVA_AFTER); 2114 } 2115 2116 fprintf (f,"%s Export Ordinal Table\n", ASM_C); 2117 fprintf (f, "anords:\n"); 2118 for (i = 0; (exp = d_exports_lexically[i]); i++) 2119 { 2120 if (!exp->noname || show_allnames) 2121 fprintf (f, "\t%s %d\n", ASM_SHORT, exp->ordinal - d_low_ord); 2122 } 2123 2124 fprintf(f,"%s Export Name Table\n", ASM_C); 2125 for (i = 0; (exp = d_exports_lexically[i]); i++) 2126 { 2127 if (!exp->noname || show_allnames) 2128 fprintf (f, "n%d: %s \"%s\"\n", 2129 exp->ordinal, ASM_TEXT, 2130 (exp->its_name ? exp->its_name : xlate (exp->name))); 2131 if (exp->forward != 0) 2132 fprintf (f, "f%d: %s \"%s\"\n", 2133 exp->forward, ASM_TEXT, exp->internal_name); 2134 } 2135 2136 if (a_list) 2137 { 2138 fprintf (f, "\t.section %s\n", DRECTVE_SECTION_NAME); 2139 for (dl = a_list; dl; dl = dl->next) 2140 { 2141 fprintf (f, "\t%s\t\"%s\"\n", ASM_TEXT, dl->text); 2142 } 2143 } 2144 2145 if (d_list) 2146 { 2147 fprintf (f, "\t.section .rdata\n"); 2148 for (dl = d_list; dl; dl = dl->next) 2149 { 2150 char *p; 2151 int l; 2152 2153 /* We don't output as ascii because there can 2154 be quote characters in the string. */ 2155 l = 0; 2156 for (p = dl->text; *p; p++) 2157 { 2158 if (l == 0) 2159 fprintf (f, "\t%s\t", ASM_BYTE); 2160 else 2161 fprintf (f, ","); 2162 fprintf (f, "%d", *p); 2163 if (p[1] == 0) 2164 { 2165 fprintf (f, ",0\n"); 2166 break; 2167 } 2168 if (++l == 10) 2169 { 2170 fprintf (f, "\n"); 2171 l = 0; 2172 } 2173 } 2174 } 2175 } 2176 } 2177 2178 /* Add to the output file a way of getting to the exported names 2179 without using the import library. */ 2180 if (add_indirect) 2181 { 2182 fprintf (f, "\t.section\t.rdata\n"); 2183 for (i = 0, exp = d_exports; exp; i++, exp = exp->next) 2184 if (!exp->noname || show_allnames) 2185 { 2186 /* We use a single underscore for MS compatibility, and a 2187 double underscore for backward compatibility with old 2188 cygwin releases. */ 2189 if (create_compat_implib) 2190 fprintf (f, "\t%s\t__imp_%s\n", ASM_GLOBAL, exp->name); 2191 fprintf (f, "\t%s\t_imp_%s%s\n", ASM_GLOBAL, 2192 (!leading_underscore ? "" : "_"), exp->name); 2193 if (create_compat_implib) 2194 fprintf (f, "__imp_%s:\n", exp->name); 2195 fprintf (f, "_imp_%s%s:\n", (!leading_underscore ? "" : "_"), exp->name); 2196 fprintf (f, "\t%s\t%s\n", ASM_LONG, exp->name); 2197 } 2198 } 2199 2200 /* Dump the reloc section if a base file is provided. */ 2201 if (base_file) 2202 { 2203 bfd_vma addr; 2204 bfd_vma need[COFF_PAGE_SIZE]; 2205 bfd_vma page_addr; 2206 bfd_size_type numbytes; 2207 int num_entries; 2208 bfd_vma *copy; 2209 int j; 2210 int on_page; 2211 fprintf (f, "\t.section\t.init\n"); 2212 fprintf (f, "lab:\n"); 2213 2214 fseek (base_file, 0, SEEK_END); 2215 numbytes = ftell (base_file); 2216 fseek (base_file, 0, SEEK_SET); 2217 copy = xmalloc (numbytes); 2218 if (fread (copy, 1, numbytes, base_file) < numbytes) 2219 fatal (_("failed to read the number of entries from base file")); 2220 num_entries = numbytes / sizeof (bfd_vma); 2221 2222 2223 fprintf (f, "\t.section\t.reloc\n"); 2224 if (num_entries) 2225 { 2226 int src; 2227 int dst = 0; 2228 bfd_vma last = (bfd_vma) -1; 2229 qsort (copy, num_entries, sizeof (bfd_vma), sfunc); 2230 /* Delete duplicates */ 2231 for (src = 0; src < num_entries; src++) 2232 { 2233 if (last != copy[src]) 2234 last = copy[dst++] = copy[src]; 2235 } 2236 num_entries = dst; 2237 addr = copy[0]; 2238 page_addr = addr & PAGE_MASK; /* work out the page addr */ 2239 on_page = 0; 2240 for (j = 0; j < num_entries; j++) 2241 { 2242 addr = copy[j]; 2243 if ((addr & PAGE_MASK) != page_addr) 2244 { 2245 flush_page (f, need, page_addr, on_page); 2246 on_page = 0; 2247 page_addr = addr & PAGE_MASK; 2248 } 2249 need[on_page++] = addr; 2250 } 2251 flush_page (f, need, page_addr, on_page); 2252 2253 /* fprintf (f, "\t%s\t0,0\t%s End\n", ASM_LONG, ASM_C);*/ 2254 } 2255 } 2256 2257 generate_idata_ofile (f); 2258 2259 fclose (f); 2260 2261 /* Assemble the file. */ 2262 assemble_file (TMP_ASM, exp_name); 2263 2264 if (dontdeltemps == 0) 2265 { 2266 temp_file_to_remove[TEMP_EXPORT_FILE] = NULL; 2267 unlink (TMP_ASM); 2268 } 2269 2270 inform (_("Generated exports file")); 2271 } 2272 2273 static const char * 2274 xlate (const char *name) 2275 { 2276 int lead_at = (*name == '@'); 2277 int is_stdcall = (!lead_at && strchr (name, '@') != NULL); 2278 2279 if (!lead_at && (add_underscore 2280 || (add_stdcall_underscore && is_stdcall))) 2281 { 2282 char *copy = xmalloc (strlen (name) + 2); 2283 2284 copy[0] = '_'; 2285 strcpy (copy + 1, name); 2286 name = copy; 2287 } 2288 2289 if (killat) 2290 { 2291 char *p; 2292 2293 name += lead_at; 2294 /* PR 9766: Look for the last @ sign in the name. */ 2295 p = strrchr (name, '@'); 2296 if (p && ISDIGIT (p[1])) 2297 *p = 0; 2298 } 2299 return name; 2300 } 2301 2302 typedef struct 2303 { 2304 int id; 2305 const char *name; 2306 int flags; 2307 int align; 2308 asection *sec; 2309 asymbol *sym; 2310 asymbol **sympp; 2311 int size; 2312 unsigned char *data; 2313 } sinfo; 2314 2315 #define INIT_SEC_DATA(id, name, flags, align) \ 2316 { id, name, flags, align, NULL, NULL, NULL, 0, NULL } 2317 2318 #ifndef DLLTOOL_PPC 2319 2320 #define TEXT 0 2321 #define DATA 1 2322 #define BSS 2 2323 #define IDATA7 3 2324 #define IDATA5 4 2325 #define IDATA4 5 2326 #define IDATA6 6 2327 2328 #define NSECS 7 2329 2330 #define TEXT_SEC_FLAGS \ 2331 (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY | SEC_HAS_CONTENTS) 2332 #define DATA_SEC_FLAGS (SEC_ALLOC | SEC_LOAD | SEC_DATA) 2333 #define BSS_SEC_FLAGS SEC_ALLOC 2334 2335 static sinfo secdata[NSECS] = 2336 { 2337 INIT_SEC_DATA (TEXT, ".text", TEXT_SEC_FLAGS, 2), 2338 INIT_SEC_DATA (DATA, ".data", DATA_SEC_FLAGS, 2), 2339 INIT_SEC_DATA (BSS, ".bss", BSS_SEC_FLAGS, 2), 2340 INIT_SEC_DATA (IDATA7, ".idata$7", SEC_HAS_CONTENTS, 2), 2341 INIT_SEC_DATA (IDATA5, ".idata$5", SEC_HAS_CONTENTS, 2), 2342 INIT_SEC_DATA (IDATA4, ".idata$4", SEC_HAS_CONTENTS, 2), 2343 INIT_SEC_DATA (IDATA6, ".idata$6", SEC_HAS_CONTENTS, 1) 2344 }; 2345 2346 #else 2347 2348 /* Sections numbered to make the order the same as other PowerPC NT 2349 compilers. This also keeps funny alignment thingies from happening. */ 2350 #define TEXT 0 2351 #define PDATA 1 2352 #define RDATA 2 2353 #define IDATA5 3 2354 #define IDATA4 4 2355 #define IDATA6 5 2356 #define IDATA7 6 2357 #define DATA 7 2358 #define BSS 8 2359 2360 #define NSECS 9 2361 2362 static sinfo secdata[NSECS] = 2363 { 2364 INIT_SEC_DATA (TEXT, ".text", SEC_CODE | SEC_HAS_CONTENTS, 3), 2365 INIT_SEC_DATA (PDATA, ".pdata", SEC_HAS_CONTENTS, 2), 2366 INIT_SEC_DATA (RDATA, ".reldata", SEC_HAS_CONTENTS, 2), 2367 INIT_SEC_DATA (IDATA5, ".idata$5", SEC_HAS_CONTENTS, 2), 2368 INIT_SEC_DATA (IDATA4, ".idata$4", SEC_HAS_CONTENTS, 2), 2369 INIT_SEC_DATA (IDATA6, ".idata$6", SEC_HAS_CONTENTS, 1), 2370 INIT_SEC_DATA (IDATA7, ".idata$7", SEC_HAS_CONTENTS, 2), 2371 INIT_SEC_DATA (DATA, ".data", SEC_DATA, 2), 2372 INIT_SEC_DATA (BSS, ".bss", 0, 2) 2373 }; 2374 2375 #endif 2376 2377 /* This is what we're trying to make. We generate the imp symbols with 2378 both single and double underscores, for compatibility. 2379 2380 .text 2381 .global _GetFileVersionInfoSizeW@8 2382 .global __imp_GetFileVersionInfoSizeW@8 2383 _GetFileVersionInfoSizeW@8: 2384 jmp * __imp_GetFileVersionInfoSizeW@8 2385 .section .idata$7 # To force loading of head 2386 .long __version_a_head 2387 # Import Address Table 2388 .section .idata$5 2389 __imp_GetFileVersionInfoSizeW@8: 2390 .rva ID2 2391 2392 # Import Lookup Table 2393 .section .idata$4 2394 .rva ID2 2395 # Hint/Name table 2396 .section .idata$6 2397 ID2: .short 2 2398 .asciz "GetFileVersionInfoSizeW" 2399 2400 2401 For the PowerPC, here's the variation on the above scheme: 2402 2403 # Rather than a simple "jmp *", the code to get to the dll function 2404 # looks like: 2405 .text 2406 lwz r11,[tocv]__imp_function_name(r2) 2407 # RELOC: 00000000 TOCREL16,TOCDEFN __imp_function_name 2408 lwz r12,0(r11) 2409 stw r2,4(r1) 2410 mtctr r12 2411 lwz r2,4(r11) 2412 bctr */ 2413 2414 static char * 2415 make_label (const char *prefix, const char *name) 2416 { 2417 int len = strlen (ASM_PREFIX (name)) + strlen (prefix) + strlen (name); 2418 char *copy = xmalloc (len + 1); 2419 2420 strcpy (copy, ASM_PREFIX (name)); 2421 strcat (copy, prefix); 2422 strcat (copy, name); 2423 return copy; 2424 } 2425 2426 static char * 2427 make_imp_label (const char *prefix, const char *name) 2428 { 2429 int len; 2430 char *copy; 2431 2432 if (name[0] == '@') 2433 { 2434 len = strlen (prefix) + strlen (name); 2435 copy = xmalloc (len + 1); 2436 strcpy (copy, prefix); 2437 strcat (copy, name); 2438 } 2439 else 2440 { 2441 len = strlen (ASM_PREFIX (name)) + strlen (prefix) + strlen (name); 2442 copy = xmalloc (len + 1); 2443 strcpy (copy, prefix); 2444 strcat (copy, ASM_PREFIX (name)); 2445 strcat (copy, name); 2446 } 2447 return copy; 2448 } 2449 2450 static bfd * 2451 make_one_lib_file (export_type *exp, int i, int delay) 2452 { 2453 bfd * abfd; 2454 asymbol * exp_label; 2455 asymbol * iname = 0; 2456 asymbol * iname2; 2457 asymbol * iname_lab; 2458 asymbol ** iname_lab_pp; 2459 asymbol ** iname_pp; 2460 #ifdef DLLTOOL_PPC 2461 asymbol ** fn_pp; 2462 asymbol ** toc_pp; 2463 #define EXTRA 2 2464 #endif 2465 #ifndef EXTRA 2466 #define EXTRA 0 2467 #endif 2468 asymbol * ptrs[NSECS + 4 + EXTRA + 1]; 2469 flagword applicable; 2470 char * outname = xmalloc (strlen (TMP_STUB) + 10); 2471 int oidx = 0; 2472 2473 2474 sprintf (outname, "%s%05d.o", TMP_STUB, i); 2475 2476 abfd = bfd_openw (outname, HOW_BFD_WRITE_TARGET); 2477 2478 if (!abfd) 2479 /* xgettext:c-format */ 2480 fatal (_("bfd_open failed open stub file: %s: %s"), 2481 outname, bfd_get_errmsg ()); 2482 2483 /* xgettext:c-format */ 2484 inform (_("Creating stub file: %s"), outname); 2485 2486 bfd_set_format (abfd, bfd_object); 2487 bfd_set_arch_mach (abfd, HOW_BFD_ARCH, 0); 2488 2489 #ifdef DLLTOOL_ARM 2490 if (machine == MARM_INTERWORK || machine == MTHUMB) 2491 bfd_set_private_flags (abfd, F_INTERWORK); 2492 #endif 2493 2494 applicable = bfd_applicable_section_flags (abfd); 2495 2496 /* First make symbols for the sections. */ 2497 for (i = 0; i < NSECS; i++) 2498 { 2499 sinfo *si = secdata + i; 2500 2501 if (si->id != i) 2502 abort (); 2503 si->sec = bfd_make_section_old_way (abfd, si->name); 2504 bfd_set_section_flags (abfd, 2505 si->sec, 2506 si->flags & applicable); 2507 2508 bfd_set_section_alignment(abfd, si->sec, si->align); 2509 si->sec->output_section = si->sec; 2510 si->sym = bfd_make_empty_symbol(abfd); 2511 si->sym->name = si->sec->name; 2512 si->sym->section = si->sec; 2513 si->sym->flags = BSF_LOCAL; 2514 si->sym->value = 0; 2515 ptrs[oidx] = si->sym; 2516 si->sympp = ptrs + oidx; 2517 si->size = 0; 2518 si->data = NULL; 2519 2520 oidx++; 2521 } 2522 2523 if (! exp->data) 2524 { 2525 exp_label = bfd_make_empty_symbol (abfd); 2526 exp_label->name = make_imp_label ("", exp->name); 2527 2528 /* On PowerPC, the function name points to a descriptor in 2529 the rdata section, the first element of which is a 2530 pointer to the code (..function_name), and the second 2531 points to the .toc. */ 2532 #ifdef DLLTOOL_PPC 2533 if (machine == MPPC) 2534 exp_label->section = secdata[RDATA].sec; 2535 else 2536 #endif 2537 exp_label->section = secdata[TEXT].sec; 2538 2539 exp_label->flags = BSF_GLOBAL; 2540 exp_label->value = 0; 2541 2542 #ifdef DLLTOOL_ARM 2543 if (machine == MTHUMB) 2544 bfd_coff_set_symbol_class (abfd, exp_label, C_THUMBEXTFUNC); 2545 #endif 2546 ptrs[oidx++] = exp_label; 2547 } 2548 2549 /* Generate imp symbols with one underscore for Microsoft 2550 compatibility, and with two underscores for backward 2551 compatibility with old versions of cygwin. */ 2552 if (create_compat_implib) 2553 { 2554 iname = bfd_make_empty_symbol (abfd); 2555 iname->name = make_imp_label ("___imp", exp->name); 2556 iname->section = secdata[IDATA5].sec; 2557 iname->flags = BSF_GLOBAL; 2558 iname->value = 0; 2559 } 2560 2561 iname2 = bfd_make_empty_symbol (abfd); 2562 iname2->name = make_imp_label ("__imp_", exp->name); 2563 iname2->section = secdata[IDATA5].sec; 2564 iname2->flags = BSF_GLOBAL; 2565 iname2->value = 0; 2566 2567 iname_lab = bfd_make_empty_symbol (abfd); 2568 2569 iname_lab->name = head_label; 2570 iname_lab->section = bfd_und_section_ptr; 2571 iname_lab->flags = 0; 2572 iname_lab->value = 0; 2573 2574 iname_pp = ptrs + oidx; 2575 if (create_compat_implib) 2576 ptrs[oidx++] = iname; 2577 ptrs[oidx++] = iname2; 2578 2579 iname_lab_pp = ptrs + oidx; 2580 ptrs[oidx++] = iname_lab; 2581 2582 #ifdef DLLTOOL_PPC 2583 /* The symbol referring to the code (.text). */ 2584 { 2585 asymbol *function_name; 2586 2587 function_name = bfd_make_empty_symbol(abfd); 2588 function_name->name = make_label ("..", exp->name); 2589 function_name->section = secdata[TEXT].sec; 2590 function_name->flags = BSF_GLOBAL; 2591 function_name->value = 0; 2592 2593 fn_pp = ptrs + oidx; 2594 ptrs[oidx++] = function_name; 2595 } 2596 2597 /* The .toc symbol. */ 2598 { 2599 asymbol *toc_symbol; 2600 2601 toc_symbol = bfd_make_empty_symbol (abfd); 2602 toc_symbol->name = make_label (".", "toc"); 2603 toc_symbol->section = bfd_und_section_ptr; 2604 toc_symbol->flags = BSF_GLOBAL; 2605 toc_symbol->value = 0; 2606 2607 toc_pp = ptrs + oidx; 2608 ptrs[oidx++] = toc_symbol; 2609 } 2610 #endif 2611 2612 ptrs[oidx] = 0; 2613 2614 for (i = 0; i < NSECS; i++) 2615 { 2616 sinfo *si = secdata + i; 2617 asection *sec = si->sec; 2618 arelent *rel, *rel2 = 0, *rel3 = 0; 2619 arelent **rpp; 2620 2621 switch (i) 2622 { 2623 case TEXT: 2624 if (! exp->data) 2625 { 2626 si->size = HOW_JTAB_SIZE; 2627 si->data = xmalloc (HOW_JTAB_SIZE); 2628 memcpy (si->data, HOW_JTAB, HOW_JTAB_SIZE); 2629 2630 /* Add the reloc into idata$5. */ 2631 rel = xmalloc (sizeof (arelent)); 2632 2633 rpp = xmalloc (sizeof (arelent *) * (delay ? 4 : 2)); 2634 rpp[0] = rel; 2635 rpp[1] = 0; 2636 2637 rel->address = HOW_JTAB_ROFF; 2638 rel->addend = 0; 2639 2640 if (delay) 2641 { 2642 rel2 = xmalloc (sizeof (arelent)); 2643 rpp[1] = rel2; 2644 rel2->address = HOW_JTAB_ROFF2; 2645 rel2->addend = 0; 2646 rel3 = xmalloc (sizeof (arelent)); 2647 rpp[2] = rel3; 2648 rel3->address = HOW_JTAB_ROFF3; 2649 rel3->addend = 0; 2650 rpp[3] = 0; 2651 } 2652 2653 if (machine == MPPC) 2654 { 2655 rel->howto = bfd_reloc_type_lookup (abfd, 2656 BFD_RELOC_16_GOTOFF); 2657 rel->sym_ptr_ptr = iname_pp; 2658 } 2659 else if (machine == MX86) 2660 { 2661 rel->howto = bfd_reloc_type_lookup (abfd, 2662 BFD_RELOC_32_PCREL); 2663 rel->sym_ptr_ptr = iname_pp; 2664 } 2665 else 2666 { 2667 rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_32); 2668 rel->sym_ptr_ptr = secdata[IDATA5].sympp; 2669 } 2670 2671 if (delay) 2672 { 2673 if (machine == MX86) 2674 rel2->howto = bfd_reloc_type_lookup (abfd, 2675 BFD_RELOC_32_PCREL); 2676 else 2677 rel2->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_32); 2678 rel2->sym_ptr_ptr = rel->sym_ptr_ptr; 2679 rel3->howto = bfd_reloc_type_lookup (abfd, 2680 BFD_RELOC_32_PCREL); 2681 rel3->sym_ptr_ptr = iname_lab_pp; 2682 } 2683 2684 sec->orelocation = rpp; 2685 sec->reloc_count = delay ? 3 : 1; 2686 } 2687 break; 2688 2689 case IDATA5: 2690 if (delay) 2691 { 2692 si->size = create_for_pep ? 8 : 4; 2693 si->data = xmalloc (si->size); 2694 sec->reloc_count = 1; 2695 memset (si->data, 0, si->size); 2696 /* Point after jmp [__imp_...] instruction. */ 2697 si->data[0] = 6; 2698 rel = xmalloc (sizeof (arelent)); 2699 rpp = xmalloc (sizeof (arelent *) * 2); 2700 rpp[0] = rel; 2701 rpp[1] = 0; 2702 rel->address = 0; 2703 rel->addend = 0; 2704 if (create_for_pep) 2705 rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_64); 2706 else 2707 rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_32); 2708 rel->sym_ptr_ptr = secdata[TEXT].sympp; 2709 sec->orelocation = rpp; 2710 break; 2711 } 2712 /* else fall through */ 2713 case IDATA4: 2714 /* An idata$4 or idata$5 is one word long, and has an 2715 rva to idata$6. */ 2716 2717 if (create_for_pep) 2718 { 2719 si->data = xmalloc (8); 2720 si->size = 8; 2721 if (exp->noname) 2722 { 2723 si->data[0] = exp->ordinal ; 2724 si->data[1] = exp->ordinal >> 8; 2725 si->data[2] = exp->ordinal >> 16; 2726 si->data[3] = exp->ordinal >> 24; 2727 si->data[4] = 0; 2728 si->data[5] = 0; 2729 si->data[6] = 0; 2730 si->data[7] = 0x80; 2731 } 2732 else 2733 { 2734 sec->reloc_count = 1; 2735 memset (si->data, 0, si->size); 2736 rel = xmalloc (sizeof (arelent)); 2737 rpp = xmalloc (sizeof (arelent *) * 2); 2738 rpp[0] = rel; 2739 rpp[1] = 0; 2740 rel->address = 0; 2741 rel->addend = 0; 2742 rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_RVA); 2743 rel->sym_ptr_ptr = secdata[IDATA6].sympp; 2744 sec->orelocation = rpp; 2745 } 2746 } 2747 else 2748 { 2749 si->data = xmalloc (4); 2750 si->size = 4; 2751 2752 if (exp->noname) 2753 { 2754 si->data[0] = exp->ordinal ; 2755 si->data[1] = exp->ordinal >> 8; 2756 si->data[2] = exp->ordinal >> 16; 2757 si->data[3] = 0x80; 2758 } 2759 else 2760 { 2761 sec->reloc_count = 1; 2762 memset (si->data, 0, si->size); 2763 rel = xmalloc (sizeof (arelent)); 2764 rpp = xmalloc (sizeof (arelent *) * 2); 2765 rpp[0] = rel; 2766 rpp[1] = 0; 2767 rel->address = 0; 2768 rel->addend = 0; 2769 rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_RVA); 2770 rel->sym_ptr_ptr = secdata[IDATA6].sympp; 2771 sec->orelocation = rpp; 2772 } 2773 } 2774 break; 2775 2776 case IDATA6: 2777 if (!exp->noname) 2778 { 2779 /* This used to add 1 to exp->hint. I don't know 2780 why it did that, and it does not match what I see 2781 in programs compiled with the MS tools. */ 2782 int idx = exp->hint; 2783 if (exp->its_name) 2784 si->size = strlen (exp->its_name) + 3; 2785 else 2786 si->size = strlen (xlate (exp->import_name)) + 3; 2787 si->data = xmalloc (si->size); 2788 memset (si->data, 0, si->size); 2789 si->data[0] = idx & 0xff; 2790 si->data[1] = idx >> 8; 2791 if (exp->its_name) 2792 strcpy ((char *) si->data + 2, exp->its_name); 2793 else 2794 strcpy ((char *) si->data + 2, xlate (exp->import_name)); 2795 } 2796 break; 2797 case IDATA7: 2798 if (delay) 2799 break; 2800 si->size = 4; 2801 si->data = xmalloc (4); 2802 memset (si->data, 0, si->size); 2803 rel = xmalloc (sizeof (arelent)); 2804 rpp = xmalloc (sizeof (arelent *) * 2); 2805 rpp[0] = rel; 2806 rel->address = 0; 2807 rel->addend = 0; 2808 rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_RVA); 2809 rel->sym_ptr_ptr = iname_lab_pp; 2810 sec->orelocation = rpp; 2811 sec->reloc_count = 1; 2812 break; 2813 2814 #ifdef DLLTOOL_PPC 2815 case PDATA: 2816 { 2817 /* The .pdata section is 5 words long. 2818 Think of it as: 2819 struct 2820 { 2821 bfd_vma BeginAddress, [0x00] 2822 EndAddress, [0x04] 2823 ExceptionHandler, [0x08] 2824 HandlerData, [0x0c] 2825 PrologEndAddress; [0x10] 2826 }; */ 2827 2828 /* So this pdata section setups up this as a glue linkage to 2829 a dll routine. There are a number of house keeping things 2830 we need to do: 2831 2832 1. In the name of glue trickery, the ADDR32 relocs for 0, 2833 4, and 0x10 are set to point to the same place: 2834 "..function_name". 2835 2. There is one more reloc needed in the pdata section. 2836 The actual glue instruction to restore the toc on 2837 return is saved as the offset in an IMGLUE reloc. 2838 So we need a total of four relocs for this section. 2839 2840 3. Lastly, the HandlerData field is set to 0x03, to indicate 2841 that this is a glue routine. */ 2842 arelent *imglue, *ba_rel, *ea_rel, *pea_rel; 2843 2844 /* Alignment must be set to 2**2 or you get extra stuff. */ 2845 bfd_set_section_alignment(abfd, sec, 2); 2846 2847 si->size = 4 * 5; 2848 si->data = xmalloc (si->size); 2849 memset (si->data, 0, si->size); 2850 rpp = xmalloc (sizeof (arelent *) * 5); 2851 rpp[0] = imglue = xmalloc (sizeof (arelent)); 2852 rpp[1] = ba_rel = xmalloc (sizeof (arelent)); 2853 rpp[2] = ea_rel = xmalloc (sizeof (arelent)); 2854 rpp[3] = pea_rel = xmalloc (sizeof (arelent)); 2855 rpp[4] = 0; 2856 2857 /* Stick the toc reload instruction in the glue reloc. */ 2858 bfd_put_32(abfd, ppc_glue_insn, (char *) &imglue->address); 2859 2860 imglue->addend = 0; 2861 imglue->howto = bfd_reloc_type_lookup (abfd, 2862 BFD_RELOC_32_GOTOFF); 2863 imglue->sym_ptr_ptr = fn_pp; 2864 2865 ba_rel->address = 0; 2866 ba_rel->addend = 0; 2867 ba_rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_32); 2868 ba_rel->sym_ptr_ptr = fn_pp; 2869 2870 bfd_put_32 (abfd, 0x18, si->data + 0x04); 2871 ea_rel->address = 4; 2872 ea_rel->addend = 0; 2873 ea_rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_32); 2874 ea_rel->sym_ptr_ptr = fn_pp; 2875 2876 /* Mark it as glue. */ 2877 bfd_put_32 (abfd, 0x03, si->data + 0x0c); 2878 2879 /* Mark the prolog end address. */ 2880 bfd_put_32 (abfd, 0x0D, si->data + 0x10); 2881 pea_rel->address = 0x10; 2882 pea_rel->addend = 0; 2883 pea_rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_32); 2884 pea_rel->sym_ptr_ptr = fn_pp; 2885 2886 sec->orelocation = rpp; 2887 sec->reloc_count = 4; 2888 break; 2889 } 2890 case RDATA: 2891 /* Each external function in a PowerPC PE file has a two word 2892 descriptor consisting of: 2893 1. The address of the code. 2894 2. The address of the appropriate .toc 2895 We use relocs to build this. */ 2896 si->size = 8; 2897 si->data = xmalloc (8); 2898 memset (si->data, 0, si->size); 2899 2900 rpp = xmalloc (sizeof (arelent *) * 3); 2901 rpp[0] = rel = xmalloc (sizeof (arelent)); 2902 rpp[1] = xmalloc (sizeof (arelent)); 2903 rpp[2] = 0; 2904 2905 rel->address = 0; 2906 rel->addend = 0; 2907 rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_32); 2908 rel->sym_ptr_ptr = fn_pp; 2909 2910 rel = rpp[1]; 2911 2912 rel->address = 4; 2913 rel->addend = 0; 2914 rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_32); 2915 rel->sym_ptr_ptr = toc_pp; 2916 2917 sec->orelocation = rpp; 2918 sec->reloc_count = 2; 2919 break; 2920 #endif /* DLLTOOL_PPC */ 2921 } 2922 } 2923 2924 { 2925 bfd_vma vma = 0; 2926 /* Size up all the sections. */ 2927 for (i = 0; i < NSECS; i++) 2928 { 2929 sinfo *si = secdata + i; 2930 2931 bfd_set_section_size (abfd, si->sec, si->size); 2932 bfd_set_section_vma (abfd, si->sec, vma); 2933 } 2934 } 2935 /* Write them out. */ 2936 for (i = 0; i < NSECS; i++) 2937 { 2938 sinfo *si = secdata + i; 2939 2940 if (i == IDATA5 && no_idata5) 2941 continue; 2942 2943 if (i == IDATA4 && no_idata4) 2944 continue; 2945 2946 bfd_set_section_contents (abfd, si->sec, 2947 si->data, 0, 2948 si->size); 2949 } 2950 2951 bfd_set_symtab (abfd, ptrs, oidx); 2952 bfd_close (abfd); 2953 abfd = bfd_openr (outname, HOW_BFD_READ_TARGET); 2954 if (!abfd) 2955 /* xgettext:c-format */ 2956 fatal (_("bfd_open failed reopen stub file: %s: %s"), 2957 outname, bfd_get_errmsg ()); 2958 2959 return abfd; 2960 } 2961 2962 static bfd * 2963 make_head (void) 2964 { 2965 FILE *f = fopen (TMP_HEAD_S, FOPEN_WT); 2966 bfd *abfd; 2967 2968 if (f == NULL) 2969 { 2970 fatal (_("failed to open temporary head file: %s"), TMP_HEAD_S); 2971 return NULL; 2972 } 2973 2974 temp_file_to_remove[TEMP_HEAD_FILE] = TMP_HEAD_S; 2975 2976 fprintf (f, "%s IMAGE_IMPORT_DESCRIPTOR\n", ASM_C); 2977 fprintf (f, "\t.section\t.idata$2\n"); 2978 2979 fprintf (f,"\t%s\t%s\n", ASM_GLOBAL, head_label); 2980 2981 fprintf (f, "%s:\n", head_label); 2982 2983 fprintf (f, "\t%shname%s\t%sPtr to image import by name list\n", 2984 ASM_RVA_BEFORE, ASM_RVA_AFTER, ASM_C); 2985 2986 fprintf (f, "\t%sthis should be the timestamp, but NT sometimes\n", ASM_C); 2987 fprintf (f, "\t%sdoesn't load DLLs when this is set.\n", ASM_C); 2988 fprintf (f, "\t%s\t0\t%s loaded time\n", ASM_LONG, ASM_C); 2989 fprintf (f, "\t%s\t0\t%s Forwarder chain\n", ASM_LONG, ASM_C); 2990 fprintf (f, "\t%s__%s_iname%s\t%s imported dll's name\n", 2991 ASM_RVA_BEFORE, 2992 imp_name_lab, 2993 ASM_RVA_AFTER, 2994 ASM_C); 2995 fprintf (f, "\t%sfthunk%s\t%s pointer to firstthunk\n", 2996 ASM_RVA_BEFORE, 2997 ASM_RVA_AFTER, ASM_C); 2998 2999 fprintf (f, "%sStuff for compatibility\n", ASM_C); 3000 3001 if (!no_idata5) 3002 { 3003 fprintf (f, "\t.section\t.idata$5\n"); 3004 if (use_nul_prefixed_import_tables) 3005 { 3006 if (create_for_pep) 3007 fprintf (f,"\t%s\t0\n\t%s\t0\n", ASM_LONG, ASM_LONG); 3008 else 3009 fprintf (f,"\t%s\t0\n", ASM_LONG); 3010 } 3011 fprintf (f, "fthunk:\n"); 3012 } 3013 3014 if (!no_idata4) 3015 { 3016 fprintf (f, "\t.section\t.idata$4\n"); 3017 if (use_nul_prefixed_import_tables) 3018 { 3019 if (create_for_pep) 3020 fprintf (f,"\t%s\t0\n\t%s\t0\n", ASM_LONG, ASM_LONG); 3021 else 3022 fprintf (f,"\t%s\t0\n", ASM_LONG); 3023 } 3024 fprintf (f, "hname:\n"); 3025 } 3026 3027 fclose (f); 3028 3029 assemble_file (TMP_HEAD_S, TMP_HEAD_O); 3030 3031 abfd = bfd_openr (TMP_HEAD_O, HOW_BFD_READ_TARGET); 3032 if (abfd == NULL) 3033 /* xgettext:c-format */ 3034 fatal (_("failed to open temporary head file: %s: %s"), 3035 TMP_HEAD_O, bfd_get_errmsg ()); 3036 3037 temp_file_to_remove[TEMP_HEAD_O_FILE] = TMP_HEAD_O; 3038 return abfd; 3039 } 3040 3041 bfd * 3042 make_delay_head (void) 3043 { 3044 FILE *f = fopen (TMP_HEAD_S, FOPEN_WT); 3045 bfd *abfd; 3046 3047 if (f == NULL) 3048 { 3049 fatal (_("failed to open temporary head file: %s"), TMP_HEAD_S); 3050 return NULL; 3051 } 3052 3053 temp_file_to_remove[TEMP_HEAD_FILE] = TMP_HEAD_S; 3054 3055 /* Output the __tailMerge__xxx function */ 3056 fprintf (f, "%s Import trampoline\n", ASM_C); 3057 fprintf (f, "\t.section\t.text\n"); 3058 fprintf(f,"\t%s\t%s\n", ASM_GLOBAL, head_label); 3059 fprintf (f, "%s:\n", head_label); 3060 fprintf (f, mtable[machine].trampoline, imp_name_lab); 3061 3062 /* Output the delay import descriptor */ 3063 fprintf (f, "\n%s DELAY_IMPORT_DESCRIPTOR\n", ASM_C); 3064 fprintf (f, ".section\t.text$2\n"); 3065 fprintf (f,"%s __DELAY_IMPORT_DESCRIPTOR_%s\n", ASM_GLOBAL,imp_name_lab); 3066 fprintf (f, "__DELAY_IMPORT_DESCRIPTOR_%s:\n", imp_name_lab); 3067 fprintf (f, "\t%s 1\t%s grAttrs\n", ASM_LONG, ASM_C); 3068 fprintf (f, "\t%s__%s_iname%s\t%s rvaDLLName\n", 3069 ASM_RVA_BEFORE, imp_name_lab, ASM_RVA_AFTER, ASM_C); 3070 fprintf (f, "\t%s__DLL_HANDLE_%s%s\t%s rvaHmod\n", 3071 ASM_RVA_BEFORE, imp_name_lab, ASM_RVA_AFTER, ASM_C); 3072 fprintf (f, "\t%s__IAT_%s%s\t%s rvaIAT\n", 3073 ASM_RVA_BEFORE, imp_name_lab, ASM_RVA_AFTER, ASM_C); 3074 fprintf (f, "\t%s__INT_%s%s\t%s rvaINT\n", 3075 ASM_RVA_BEFORE, imp_name_lab, ASM_RVA_AFTER, ASM_C); 3076 fprintf (f, "\t%s\t0\t%s rvaBoundIAT\n", ASM_LONG, ASM_C); 3077 fprintf (f, "\t%s\t0\t%s rvaUnloadIAT\n", ASM_LONG, ASM_C); 3078 fprintf (f, "\t%s\t0\t%s dwTimeStamp\n", ASM_LONG, ASM_C); 3079 3080 /* Output the dll_handle */ 3081 fprintf (f, "\n.section .data\n"); 3082 fprintf (f, "__DLL_HANDLE_%s:\n", imp_name_lab); 3083 fprintf (f, "\t%s\t0\t%s Handle\n", ASM_LONG, ASM_C); 3084 if (create_for_pep) 3085 fprintf (f, "\t%s\t0\n", ASM_LONG); 3086 fprintf (f, "\n"); 3087 3088 fprintf (f, "%sStuff for compatibility\n", ASM_C); 3089 3090 if (!no_idata5) 3091 { 3092 fprintf (f, "\t.section\t.idata$5\n"); 3093 /* NULL terminating list. */ 3094 if (create_for_pep) 3095 fprintf (f,"\t%s\t0\n\t%s\t0\n", ASM_LONG, ASM_LONG); 3096 else 3097 fprintf (f,"\t%s\t0\n", ASM_LONG); 3098 fprintf (f, "__IAT_%s:\n", imp_name_lab); 3099 } 3100 3101 if (!no_idata4) 3102 { 3103 fprintf (f, "\t.section\t.idata$4\n"); 3104 fprintf (f, "\t%s\t0\n", ASM_LONG); 3105 if (create_for_pep) 3106 fprintf (f, "\t%s\t0\n", ASM_LONG); 3107 fprintf (f, "\t.section\t.idata$4\n"); 3108 fprintf (f, "__INT_%s:\n", imp_name_lab); 3109 } 3110 3111 fprintf (f, "\t.section\t.idata$2\n"); 3112 3113 fclose (f); 3114 3115 assemble_file (TMP_HEAD_S, TMP_HEAD_O); 3116 3117 abfd = bfd_openr (TMP_HEAD_O, HOW_BFD_READ_TARGET); 3118 if (abfd == NULL) 3119 /* xgettext:c-format */ 3120 fatal (_("failed to open temporary head file: %s: %s"), 3121 TMP_HEAD_O, bfd_get_errmsg ()); 3122 3123 temp_file_to_remove[TEMP_HEAD_O_FILE] = TMP_HEAD_O; 3124 return abfd; 3125 } 3126 3127 static bfd * 3128 make_tail (void) 3129 { 3130 FILE *f = fopen (TMP_TAIL_S, FOPEN_WT); 3131 bfd *abfd; 3132 3133 if (f == NULL) 3134 { 3135 fatal (_("failed to open temporary tail file: %s"), TMP_TAIL_S); 3136 return NULL; 3137 } 3138 3139 temp_file_to_remove[TEMP_TAIL_FILE] = TMP_TAIL_S; 3140 3141 if (!no_idata4) 3142 { 3143 fprintf (f, "\t.section\t.idata$4\n"); 3144 if (create_for_pep) 3145 fprintf (f,"\t%s\t0\n\t%s\t0\n", ASM_LONG, ASM_LONG); 3146 else 3147 fprintf (f,"\t%s\t0\n", ASM_LONG); /* NULL terminating list. */ 3148 } 3149 3150 if (!no_idata5) 3151 { 3152 fprintf (f, "\t.section\t.idata$5\n"); 3153 if (create_for_pep) 3154 fprintf (f,"\t%s\t0\n\t%s\t0\n", ASM_LONG, ASM_LONG); 3155 else 3156 fprintf (f,"\t%s\t0\n", ASM_LONG); /* NULL terminating list. */ 3157 } 3158 3159 #ifdef DLLTOOL_PPC 3160 /* Normally, we need to see a null descriptor built in idata$3 to 3161 act as the terminator for the list. The ideal way, I suppose, 3162 would be to mark this section as a comdat type 2 section, so 3163 only one would appear in the final .exe (if our linker supported 3164 comdat, that is) or cause it to be inserted by something else (say 3165 crt0). */ 3166 3167 fprintf (f, "\t.section\t.idata$3\n"); 3168 fprintf (f, "\t%s\t0\n", ASM_LONG); 3169 fprintf (f, "\t%s\t0\n", ASM_LONG); 3170 fprintf (f, "\t%s\t0\n", ASM_LONG); 3171 fprintf (f, "\t%s\t0\n", ASM_LONG); 3172 fprintf (f, "\t%s\t0\n", ASM_LONG); 3173 #endif 3174 3175 #ifdef DLLTOOL_PPC 3176 /* Other PowerPC NT compilers use idata$6 for the dllname, so I 3177 do too. Original, huh? */ 3178 fprintf (f, "\t.section\t.idata$6\n"); 3179 #else 3180 fprintf (f, "\t.section\t.idata$7\n"); 3181 #endif 3182 3183 fprintf (f, "\t%s\t__%s_iname\n", ASM_GLOBAL, imp_name_lab); 3184 fprintf (f, "__%s_iname:\t%s\t\"%s\"\n", 3185 imp_name_lab, ASM_TEXT, dll_name); 3186 3187 fclose (f); 3188 3189 assemble_file (TMP_TAIL_S, TMP_TAIL_O); 3190 3191 abfd = bfd_openr (TMP_TAIL_O, HOW_BFD_READ_TARGET); 3192 if (abfd == NULL) 3193 /* xgettext:c-format */ 3194 fatal (_("failed to open temporary tail file: %s: %s"), 3195 TMP_TAIL_O, bfd_get_errmsg ()); 3196 3197 temp_file_to_remove[TEMP_TAIL_O_FILE] = TMP_TAIL_O; 3198 return abfd; 3199 } 3200 3201 static void 3202 gen_lib_file (int delay) 3203 { 3204 int i; 3205 export_type *exp; 3206 bfd *ar_head; 3207 bfd *ar_tail; 3208 bfd *outarch; 3209 bfd * head = 0; 3210 3211 unlink (imp_name); 3212 3213 outarch = bfd_openw (imp_name, HOW_BFD_WRITE_TARGET); 3214 3215 if (!outarch) 3216 /* xgettext:c-format */ 3217 fatal (_("Can't create .lib file: %s: %s"), 3218 imp_name, bfd_get_errmsg ()); 3219 3220 /* xgettext:c-format */ 3221 inform (_("Creating library file: %s"), imp_name); 3222 3223 xatexit (unlink_temp_files); 3224 3225 bfd_set_format (outarch, bfd_archive); 3226 outarch->has_armap = 1; 3227 outarch->is_thin_archive = 0; 3228 3229 /* Work out a reasonable size of things to put onto one line. */ 3230 if (delay) 3231 { 3232 ar_head = make_delay_head (); 3233 } 3234 else 3235 { 3236 ar_head = make_head (); 3237 } 3238 ar_tail = make_tail(); 3239 3240 if (ar_head == NULL || ar_tail == NULL) 3241 return; 3242 3243 for (i = 0; (exp = d_exports_lexically[i]); i++) 3244 { 3245 bfd *n; 3246 /* Don't add PRIVATE entries to import lib. */ 3247 if (exp->private) 3248 continue; 3249 n = make_one_lib_file (exp, i, delay); 3250 n->archive_next = head; 3251 head = n; 3252 if (ext_prefix_alias) 3253 { 3254 export_type alias_exp; 3255 3256 assert (i < PREFIX_ALIAS_BASE); 3257 alias_exp.name = make_imp_label (ext_prefix_alias, exp->name); 3258 alias_exp.internal_name = exp->internal_name; 3259 alias_exp.its_name = exp->its_name; 3260 alias_exp.import_name = exp->name; 3261 alias_exp.ordinal = exp->ordinal; 3262 alias_exp.constant = exp->constant; 3263 alias_exp.noname = exp->noname; 3264 alias_exp.private = exp->private; 3265 alias_exp.data = exp->data; 3266 alias_exp.hint = exp->hint; 3267 alias_exp.forward = exp->forward; 3268 alias_exp.next = exp->next; 3269 n = make_one_lib_file (&alias_exp, i + PREFIX_ALIAS_BASE, delay); 3270 n->archive_next = head; 3271 head = n; 3272 } 3273 } 3274 3275 /* Now stick them all into the archive. */ 3276 ar_head->archive_next = head; 3277 ar_tail->archive_next = ar_head; 3278 head = ar_tail; 3279 3280 if (! bfd_set_archive_head (outarch, head)) 3281 bfd_fatal ("bfd_set_archive_head"); 3282 3283 if (! bfd_close (outarch)) 3284 bfd_fatal (imp_name); 3285 3286 while (head != NULL) 3287 { 3288 bfd *n = head->archive_next; 3289 bfd_close (head); 3290 head = n; 3291 } 3292 3293 /* Delete all the temp files. */ 3294 unlink_temp_files (); 3295 3296 if (dontdeltemps < 2) 3297 { 3298 char *name; 3299 3300 name = xmalloc (strlen (TMP_STUB) + 10); 3301 for (i = 0; (exp = d_exports_lexically[i]); i++) 3302 { 3303 /* Don't delete non-existent stubs for PRIVATE entries. */ 3304 if (exp->private) 3305 continue; 3306 sprintf (name, "%s%05d.o", TMP_STUB, i); 3307 if (unlink (name) < 0) 3308 /* xgettext:c-format */ 3309 non_fatal (_("cannot delete %s: %s"), name, strerror (errno)); 3310 if (ext_prefix_alias) 3311 { 3312 sprintf (name, "%s%05d.o", TMP_STUB, i + PREFIX_ALIAS_BASE); 3313 if (unlink (name) < 0) 3314 /* xgettext:c-format */ 3315 non_fatal (_("cannot delete %s: %s"), name, strerror (errno)); 3316 } 3317 } 3318 free (name); 3319 } 3320 3321 inform (_("Created lib file")); 3322 } 3323 3324 /* Append a copy of data (cast to char *) to list. */ 3325 3326 static void 3327 dll_name_list_append (dll_name_list_type * list, bfd_byte * data) 3328 { 3329 dll_name_list_node_type * entry; 3330 3331 /* Error checking. */ 3332 if (! list || ! list->tail) 3333 return; 3334 3335 /* Allocate new node. */ 3336 entry = ((dll_name_list_node_type *) 3337 xmalloc (sizeof (dll_name_list_node_type))); 3338 3339 /* Initialize its values. */ 3340 entry->dllname = xstrdup ((char *) data); 3341 entry->next = NULL; 3342 3343 /* Add to tail, and move tail. */ 3344 list->tail->next = entry; 3345 list->tail = entry; 3346 } 3347 3348 /* Count the number of entries in list. */ 3349 3350 static int 3351 dll_name_list_count (dll_name_list_type * list) 3352 { 3353 dll_name_list_node_type * p; 3354 int count = 0; 3355 3356 /* Error checking. */ 3357 if (! list || ! list->head) 3358 return 0; 3359 3360 p = list->head; 3361 3362 while (p && p->next) 3363 { 3364 count++; 3365 p = p->next; 3366 } 3367 return count; 3368 } 3369 3370 /* Print each entry in list to stdout. */ 3371 3372 static void 3373 dll_name_list_print (dll_name_list_type * list) 3374 { 3375 dll_name_list_node_type * p; 3376 3377 /* Error checking. */ 3378 if (! list || ! list->head) 3379 return; 3380 3381 p = list->head; 3382 3383 while (p && p->next && p->next->dllname && *(p->next->dllname)) 3384 { 3385 printf ("%s\n", p->next->dllname); 3386 p = p->next; 3387 } 3388 } 3389 3390 /* Free all entries in list, and list itself. */ 3391 3392 static void 3393 dll_name_list_free (dll_name_list_type * list) 3394 { 3395 if (list) 3396 { 3397 dll_name_list_free_contents (list->head); 3398 list->head = NULL; 3399 list->tail = NULL; 3400 free (list); 3401 } 3402 } 3403 3404 /* Recursive function to free all nodes entry->next->next... 3405 as well as entry itself. */ 3406 3407 static void 3408 dll_name_list_free_contents (dll_name_list_node_type * entry) 3409 { 3410 if (entry) 3411 { 3412 if (entry->next) 3413 { 3414 dll_name_list_free_contents (entry->next); 3415 entry->next = NULL; 3416 } 3417 if (entry->dllname) 3418 { 3419 free (entry->dllname); 3420 entry->dllname = NULL; 3421 } 3422 free (entry); 3423 } 3424 } 3425 3426 /* Allocate and initialize a dll_name_list_type object, 3427 including its sentinel node. Caller is responsible 3428 for calling dll_name_list_free when finished with 3429 the list. */ 3430 3431 static dll_name_list_type * 3432 dll_name_list_create (void) 3433 { 3434 /* Allocate list. */ 3435 dll_name_list_type * list = xmalloc (sizeof (dll_name_list_type)); 3436 3437 /* Allocate and initialize sentinel node. */ 3438 list->head = xmalloc (sizeof (dll_name_list_node_type)); 3439 list->head->dllname = NULL; 3440 list->head->next = NULL; 3441 3442 /* Bookkeeping for empty list. */ 3443 list->tail = list->head; 3444 3445 return list; 3446 } 3447 3448 /* Search the symbol table of the suppled BFD for a symbol whose name matches 3449 OBJ (where obj is cast to const char *). If found, set global variable 3450 identify_member_contains_symname_result TRUE. It is the caller's 3451 responsibility to set the result variable FALSE before iterating with 3452 this function. */ 3453 3454 static void 3455 identify_member_contains_symname (bfd * abfd, 3456 bfd * archive_bfd ATTRIBUTE_UNUSED, 3457 void * obj) 3458 { 3459 long storage_needed; 3460 asymbol ** symbol_table; 3461 long number_of_symbols; 3462 long i; 3463 symname_search_data_type * search_data = (symname_search_data_type *) obj; 3464 3465 /* If we already found the symbol in a different member, 3466 short circuit. */ 3467 if (search_data->found) 3468 return; 3469 3470 storage_needed = bfd_get_symtab_upper_bound (abfd); 3471 if (storage_needed <= 0) 3472 return; 3473 3474 symbol_table = xmalloc (storage_needed); 3475 number_of_symbols = bfd_canonicalize_symtab (abfd, symbol_table); 3476 if (number_of_symbols < 0) 3477 { 3478 free (symbol_table); 3479 return; 3480 } 3481 3482 for (i = 0; i < number_of_symbols; i++) 3483 { 3484 if (strncmp (symbol_table[i]->name, 3485 search_data->symname, 3486 strlen (search_data->symname)) == 0) 3487 { 3488 search_data->found = TRUE; 3489 break; 3490 } 3491 } 3492 free (symbol_table); 3493 } 3494 3495 /* This is the main implementation for the --identify option. 3496 Given the name of an import library in identify_imp_name, first determine 3497 if the import library is a GNU binutils-style one (where the DLL name is 3498 stored in an .idata$7 (.idata$6 on PPC) section, or if it is a MS-style 3499 one (where the DLL name, along with much other data, is stored in the 3500 .idata$6 section). We determine the style of import library by searching 3501 for the DLL-structure symbol inserted by MS tools: 3502 __NULL_IMPORT_DESCRIPTOR. 3503 3504 Once we know which section to search, evaluate each section for the 3505 appropriate properties that indicate it may contain the name of the 3506 associated DLL (this differs depending on the style). Add the contents 3507 of all sections which meet the criteria to a linked list of dll names. 3508 3509 Finally, print them all to stdout. (If --identify-strict, an error is 3510 reported if more than one match was found). */ 3511 3512 static void 3513 identify_dll_for_implib (void) 3514 { 3515 bfd * abfd = NULL; 3516 int count = 0; 3517 identify_data_type identify_data; 3518 symname_search_data_type search_data; 3519 3520 /* Initialize identify_data. */ 3521 identify_data.list = dll_name_list_create (); 3522 identify_data.ms_style_implib = FALSE; 3523 3524 /* Initialize search_data. */ 3525 search_data.symname = "__NULL_IMPORT_DESCRIPTOR"; 3526 search_data.found = FALSE; 3527 3528 bfd_init (); 3529 3530 abfd = bfd_openr (identify_imp_name, 0); 3531 if (abfd == NULL) 3532 /* xgettext:c-format */ 3533 fatal (_("Can't open .lib file: %s: %s"), 3534 identify_imp_name, bfd_get_errmsg ()); 3535 3536 if (! bfd_check_format (abfd, bfd_archive)) 3537 { 3538 if (! bfd_close (abfd)) 3539 bfd_fatal (identify_imp_name); 3540 3541 fatal (_("%s is not a library"), identify_imp_name); 3542 } 3543 3544 /* Detect if this a Microsoft import library. */ 3545 identify_search_archive (abfd, 3546 identify_member_contains_symname, 3547 (void *)(& search_data)); 3548 if (search_data.found) 3549 identify_data.ms_style_implib = TRUE; 3550 3551 /* Rewind the bfd. */ 3552 if (! bfd_close (abfd)) 3553 bfd_fatal (identify_imp_name); 3554 abfd = bfd_openr (identify_imp_name, 0); 3555 if (abfd == NULL) 3556 bfd_fatal (identify_imp_name); 3557 3558 if (!bfd_check_format (abfd, bfd_archive)) 3559 { 3560 if (!bfd_close (abfd)) 3561 bfd_fatal (identify_imp_name); 3562 3563 fatal (_("%s is not a library"), identify_imp_name); 3564 } 3565 3566 /* Now search for the dll name. */ 3567 identify_search_archive (abfd, 3568 identify_search_member, 3569 (void *)(& identify_data)); 3570 3571 if (! bfd_close (abfd)) 3572 bfd_fatal (identify_imp_name); 3573 3574 count = dll_name_list_count (identify_data.list); 3575 if (count > 0) 3576 { 3577 if (identify_strict && count > 1) 3578 { 3579 dll_name_list_free (identify_data.list); 3580 identify_data.list = NULL; 3581 fatal (_("Import library `%s' specifies two or more dlls"), 3582 identify_imp_name); 3583 } 3584 dll_name_list_print (identify_data.list); 3585 dll_name_list_free (identify_data.list); 3586 identify_data.list = NULL; 3587 } 3588 else 3589 { 3590 dll_name_list_free (identify_data.list); 3591 identify_data.list = NULL; 3592 fatal (_("Unable to determine dll name for `%s' (not an import library?)"), 3593 identify_imp_name); 3594 } 3595 } 3596 3597 /* Loop over all members of the archive, applying the supplied function to 3598 each member that is a bfd_object. The function will be called as if: 3599 func (member_bfd, abfd, user_storage) */ 3600 3601 static void 3602 identify_search_archive (bfd * abfd, 3603 void (* operation) (bfd *, bfd *, void *), 3604 void * user_storage) 3605 { 3606 bfd * arfile = NULL; 3607 bfd * last_arfile = NULL; 3608 char ** matching; 3609 3610 while (1) 3611 { 3612 arfile = bfd_openr_next_archived_file (abfd, arfile); 3613 3614 if (arfile == NULL) 3615 { 3616 if (bfd_get_error () != bfd_error_no_more_archived_files) 3617 bfd_fatal (bfd_get_filename (abfd)); 3618 break; 3619 } 3620 3621 if (bfd_check_format_matches (arfile, bfd_object, &matching)) 3622 (*operation) (arfile, abfd, user_storage); 3623 else 3624 { 3625 bfd_nonfatal (bfd_get_filename (arfile)); 3626 free (matching); 3627 } 3628 3629 if (last_arfile != NULL) 3630 { 3631 bfd_close (last_arfile); 3632 /* PR 17512: file: 8b2168d4. */ 3633 if (last_arfile == arfile) 3634 { 3635 last_arfile = NULL; 3636 break; 3637 } 3638 } 3639 3640 last_arfile = arfile; 3641 } 3642 3643 if (last_arfile != NULL) 3644 { 3645 bfd_close (last_arfile); 3646 } 3647 } 3648 3649 /* Call the identify_search_section() function for each section of this 3650 archive member. */ 3651 3652 static void 3653 identify_search_member (bfd *abfd, 3654 bfd *archive_bfd ATTRIBUTE_UNUSED, 3655 void *obj) 3656 { 3657 bfd_map_over_sections (abfd, identify_search_section, obj); 3658 } 3659 3660 /* This predicate returns true if section->name matches the desired value. 3661 By default, this is .idata$7 (.idata$6 on PPC, or if the import 3662 library is ms-style). */ 3663 3664 static bfd_boolean 3665 identify_process_section_p (asection * section, bfd_boolean ms_style_implib) 3666 { 3667 static const char * SECTION_NAME = 3668 #ifdef DLLTOOL_PPC 3669 /* dllname is stored in idata$6 on PPC */ 3670 ".idata$6"; 3671 #else 3672 ".idata$7"; 3673 #endif 3674 static const char * MS_SECTION_NAME = ".idata$6"; 3675 3676 const char * section_name = 3677 (ms_style_implib ? MS_SECTION_NAME : SECTION_NAME); 3678 3679 if (strcmp (section_name, section->name) == 0) 3680 return TRUE; 3681 return FALSE; 3682 } 3683 3684 /* If *section has contents and its name is .idata$7 (.data$6 on PPC or if 3685 import lib ms-generated) -- and it satisfies several other constraints 3686 -- then add the contents of the section to obj->list. */ 3687 3688 static void 3689 identify_search_section (bfd * abfd, asection * section, void * obj) 3690 { 3691 bfd_byte *data = 0; 3692 bfd_size_type datasize; 3693 identify_data_type * identify_data = (identify_data_type *)obj; 3694 bfd_boolean ms_style = identify_data->ms_style_implib; 3695 3696 if ((section->flags & SEC_HAS_CONTENTS) == 0) 3697 return; 3698 3699 if (! identify_process_section_p (section, ms_style)) 3700 return; 3701 3702 /* Binutils import libs seem distinguish the .idata$7 section that contains 3703 the DLL name from other .idata$7 sections by the absence of the 3704 SEC_RELOC flag. */ 3705 if (!ms_style && ((section->flags & SEC_RELOC) == SEC_RELOC)) 3706 return; 3707 3708 /* MS import libs seem to distinguish the .idata$6 section 3709 that contains the DLL name from other .idata$6 sections 3710 by the presence of the SEC_DATA flag. */ 3711 if (ms_style && ((section->flags & SEC_DATA) == 0)) 3712 return; 3713 3714 if ((datasize = bfd_section_size (abfd, section)) == 0) 3715 return; 3716 3717 data = (bfd_byte *) xmalloc (datasize + 1); 3718 data[0] = '\0'; 3719 3720 bfd_get_section_contents (abfd, section, data, 0, datasize); 3721 data[datasize] = '\0'; 3722 3723 /* Use a heuristic to determine if data is a dll name. 3724 Possible to defeat this if (a) the library has MANY 3725 (more than 0x302f) imports, (b) it is an ms-style 3726 import library, but (c) it is buggy, in that the SEC_DATA 3727 flag is set on the "wrong" sections. This heuristic might 3728 also fail to record a valid dll name if the dllname uses 3729 a multibyte or unicode character set (is that valid?). 3730 3731 This heuristic is based on the fact that symbols names in 3732 the chosen section -- as opposed to the dll name -- begin 3733 at offset 2 in the data. The first two bytes are a 16bit 3734 little-endian count, and start at 0x0000. However, the dll 3735 name begins at offset 0 in the data. We assume that the 3736 dll name does not contain unprintable characters. */ 3737 if (data[0] != '\0' && ISPRINT (data[0]) 3738 && ((datasize < 2) || ISPRINT (data[1]))) 3739 dll_name_list_append (identify_data->list, data); 3740 3741 free (data); 3742 } 3743 3744 /* Run through the information gathered from the .o files and the 3745 .def file and work out the best stuff. */ 3746 3747 static int 3748 pfunc (const void *a, const void *b) 3749 { 3750 export_type *ap = *(export_type **) a; 3751 export_type *bp = *(export_type **) b; 3752 3753 if (ap->ordinal == bp->ordinal) 3754 return 0; 3755 3756 /* Unset ordinals go to the bottom. */ 3757 if (ap->ordinal == -1) 3758 return 1; 3759 if (bp->ordinal == -1) 3760 return -1; 3761 return (ap->ordinal - bp->ordinal); 3762 } 3763 3764 static int 3765 nfunc (const void *a, const void *b) 3766 { 3767 export_type *ap = *(export_type **) a; 3768 export_type *bp = *(export_type **) b; 3769 const char *an = ap->name; 3770 const char *bn = bp->name; 3771 if (ap->its_name) 3772 an = ap->its_name; 3773 if (bp->its_name) 3774 an = bp->its_name; 3775 if (killat) 3776 { 3777 an = (an[0] == '@') ? an + 1 : an; 3778 bn = (bn[0] == '@') ? bn + 1 : bn; 3779 } 3780 3781 return (strcmp (an, bn)); 3782 } 3783 3784 static void 3785 remove_null_names (export_type **ptr) 3786 { 3787 int src; 3788 int dst; 3789 3790 for (dst = src = 0; src < d_nfuncs; src++) 3791 { 3792 if (ptr[src]) 3793 { 3794 ptr[dst] = ptr[src]; 3795 dst++; 3796 } 3797 } 3798 d_nfuncs = dst; 3799 } 3800 3801 static void 3802 process_duplicates (export_type **d_export_vec) 3803 { 3804 int more = 1; 3805 int i; 3806 3807 while (more) 3808 { 3809 more = 0; 3810 /* Remove duplicates. */ 3811 qsort (d_export_vec, d_nfuncs, sizeof (export_type *), nfunc); 3812 3813 for (i = 0; i < d_nfuncs - 1; i++) 3814 { 3815 if (strcmp (d_export_vec[i]->name, 3816 d_export_vec[i + 1]->name) == 0) 3817 { 3818 export_type *a = d_export_vec[i]; 3819 export_type *b = d_export_vec[i + 1]; 3820 3821 more = 1; 3822 3823 /* xgettext:c-format */ 3824 inform (_("Warning, ignoring duplicate EXPORT %s %d,%d"), 3825 a->name, a->ordinal, b->ordinal); 3826 3827 if (a->ordinal != -1 3828 && b->ordinal != -1) 3829 /* xgettext:c-format */ 3830 fatal (_("Error, duplicate EXPORT with ordinals: %s"), 3831 a->name); 3832 3833 /* Merge attributes. */ 3834 b->ordinal = a->ordinal > 0 ? a->ordinal : b->ordinal; 3835 b->constant |= a->constant; 3836 b->noname |= a->noname; 3837 b->data |= a->data; 3838 d_export_vec[i] = 0; 3839 } 3840 3841 remove_null_names (d_export_vec); 3842 } 3843 } 3844 3845 /* Count the names. */ 3846 for (i = 0; i < d_nfuncs; i++) 3847 if (!d_export_vec[i]->noname) 3848 d_named_nfuncs++; 3849 } 3850 3851 static void 3852 fill_ordinals (export_type **d_export_vec) 3853 { 3854 int lowest = -1; 3855 int i; 3856 char *ptr; 3857 int size = 65536; 3858 3859 qsort (d_export_vec, d_nfuncs, sizeof (export_type *), pfunc); 3860 3861 /* Fill in the unset ordinals with ones from our range. */ 3862 ptr = (char *) xmalloc (size); 3863 3864 memset (ptr, 0, size); 3865 3866 /* Mark in our large vector all the numbers that are taken. */ 3867 for (i = 0; i < d_nfuncs; i++) 3868 { 3869 if (d_export_vec[i]->ordinal != -1) 3870 { 3871 ptr[d_export_vec[i]->ordinal] = 1; 3872 3873 if (lowest == -1 || d_export_vec[i]->ordinal < lowest) 3874 lowest = d_export_vec[i]->ordinal; 3875 } 3876 } 3877 3878 /* Start at 1 for compatibility with MS toolchain. */ 3879 if (lowest == -1) 3880 lowest = 1; 3881 3882 /* Now fill in ordinals where the user wants us to choose. */ 3883 for (i = 0; i < d_nfuncs; i++) 3884 { 3885 if (d_export_vec[i]->ordinal == -1) 3886 { 3887 int j; 3888 3889 /* First try within or after any user supplied range. */ 3890 for (j = lowest; j < size; j++) 3891 if (ptr[j] == 0) 3892 { 3893 ptr[j] = 1; 3894 d_export_vec[i]->ordinal = j; 3895 goto done; 3896 } 3897 3898 /* Then try before the range. */ 3899 for (j = lowest; j >0; j--) 3900 if (ptr[j] == 0) 3901 { 3902 ptr[j] = 1; 3903 d_export_vec[i]->ordinal = j; 3904 goto done; 3905 } 3906 done:; 3907 } 3908 } 3909 3910 free (ptr); 3911 3912 /* And resort. */ 3913 qsort (d_export_vec, d_nfuncs, sizeof (export_type *), pfunc); 3914 3915 /* Work out the lowest and highest ordinal numbers. */ 3916 if (d_nfuncs) 3917 { 3918 if (d_export_vec[0]) 3919 d_low_ord = d_export_vec[0]->ordinal; 3920 if (d_export_vec[d_nfuncs-1]) 3921 d_high_ord = d_export_vec[d_nfuncs-1]->ordinal; 3922 } 3923 } 3924 3925 static void 3926 mangle_defs (void) 3927 { 3928 /* First work out the minimum ordinal chosen. */ 3929 export_type *exp; 3930 3931 int i; 3932 int hint = 0; 3933 export_type **d_export_vec = xmalloc (sizeof (export_type *) * d_nfuncs); 3934 3935 inform (_("Processing definitions")); 3936 3937 for (i = 0, exp = d_exports; exp; i++, exp = exp->next) 3938 d_export_vec[i] = exp; 3939 3940 process_duplicates (d_export_vec); 3941 fill_ordinals (d_export_vec); 3942 3943 /* Put back the list in the new order. */ 3944 d_exports = 0; 3945 for (i = d_nfuncs - 1; i >= 0; i--) 3946 { 3947 d_export_vec[i]->next = d_exports; 3948 d_exports = d_export_vec[i]; 3949 } 3950 3951 /* Build list in alpha order. */ 3952 d_exports_lexically = (export_type **) 3953 xmalloc (sizeof (export_type *) * (d_nfuncs + 1)); 3954 3955 for (i = 0, exp = d_exports; exp; i++, exp = exp->next) 3956 d_exports_lexically[i] = exp; 3957 3958 d_exports_lexically[i] = 0; 3959 3960 qsort (d_exports_lexically, i, sizeof (export_type *), nfunc); 3961 3962 /* Fill exp entries with their hint values. */ 3963 for (i = 0; i < d_nfuncs; i++) 3964 if (!d_exports_lexically[i]->noname || show_allnames) 3965 d_exports_lexically[i]->hint = hint++; 3966 3967 inform (_("Processed definitions")); 3968 } 3969 3970 static void 3971 usage (FILE *file, int status) 3972 { 3973 /* xgetext:c-format */ 3974 fprintf (file, _("Usage %s <option(s)> <object-file(s)>\n"), program_name); 3975 /* xgetext:c-format */ 3976 fprintf (file, _(" -m --machine <machine> Create as DLL for <machine>. [default: %s]\n"), mname); 3977 fprintf (file, _(" possible <machine>: arm[_interwork], i386, mcore[-elf]{-le|-be}, ppc, thumb\n")); 3978 fprintf (file, _(" -e --output-exp <outname> Generate an export file.\n")); 3979 fprintf (file, _(" -l --output-lib <outname> Generate an interface library.\n")); 3980 fprintf (file, _(" -y --output-delaylib <outname> Create a delay-import library.\n")); 3981 fprintf (file, _(" -a --add-indirect Add dll indirects to export file.\n")); 3982 fprintf (file, _(" -D --dllname <name> Name of input dll to put into interface lib.\n")); 3983 fprintf (file, _(" -d --input-def <deffile> Name of .def file to be read in.\n")); 3984 fprintf (file, _(" -z --output-def <deffile> Name of .def file to be created.\n")); 3985 fprintf (file, _(" --export-all-symbols Export all symbols to .def\n")); 3986 fprintf (file, _(" --no-export-all-symbols Only export listed symbols\n")); 3987 fprintf (file, _(" --exclude-symbols <list> Don't export <list>\n")); 3988 fprintf (file, _(" --no-default-excludes Clear default exclude symbols\n")); 3989 fprintf (file, _(" -b --base-file <basefile> Read linker generated base file.\n")); 3990 fprintf (file, _(" -x --no-idata4 Don't generate idata$4 section.\n")); 3991 fprintf (file, _(" -c --no-idata5 Don't generate idata$5 section.\n")); 3992 fprintf (file, _(" --use-nul-prefixed-import-tables Use zero prefixed idata$4 and idata$5.\n")); 3993 fprintf (file, _(" -U --add-underscore Add underscores to all symbols in interface library.\n")); 3994 fprintf (file, _(" --add-stdcall-underscore Add underscores to stdcall symbols in interface library.\n")); 3995 fprintf (file, _(" --no-leading-underscore All symbols shouldn't be prefixed by an underscore.\n")); 3996 fprintf (file, _(" --leading-underscore All symbols should be prefixed by an underscore.\n")); 3997 fprintf (file, _(" -k --kill-at Kill @<n> from exported names.\n")); 3998 fprintf (file, _(" -A --add-stdcall-alias Add aliases without @<n>.\n")); 3999 fprintf (file, _(" -p --ext-prefix-alias <prefix> Add aliases with <prefix>.\n")); 4000 fprintf (file, _(" -S --as <name> Use <name> for assembler.\n")); 4001 fprintf (file, _(" -f --as-flags <flags> Pass <flags> to the assembler.\n")); 4002 fprintf (file, _(" -C --compat-implib Create backward compatible import library.\n")); 4003 fprintf (file, _(" -n --no-delete Keep temp files (repeat for extra preservation).\n")); 4004 fprintf (file, _(" -t --temp-prefix <prefix> Use <prefix> to construct temp file names.\n")); 4005 fprintf (file, _(" -I --identify <implib> Report the name of the DLL associated with <implib>.\n")); 4006 fprintf (file, _(" --identify-strict Causes --identify to report error when multiple DLLs.\n")); 4007 fprintf (file, _(" -v --verbose Be verbose.\n")); 4008 fprintf (file, _(" -V --version Display the program version.\n")); 4009 fprintf (file, _(" -h --help Display this information.\n")); 4010 fprintf (file, _(" @<file> Read options from <file>.\n")); 4011 #ifdef DLLTOOL_MCORE_ELF 4012 fprintf (file, _(" -M --mcore-elf <outname> Process mcore-elf object files into <outname>.\n")); 4013 fprintf (file, _(" -L --linker <name> Use <name> as the linker.\n")); 4014 fprintf (file, _(" -F --linker-flags <flags> Pass <flags> to the linker.\n")); 4015 #endif 4016 if (REPORT_BUGS_TO[0] && status == 0) 4017 fprintf (file, _("Report bugs to %s\n"), REPORT_BUGS_TO); 4018 exit (status); 4019 } 4020 4021 #define OPTION_EXPORT_ALL_SYMS 150 4022 #define OPTION_NO_EXPORT_ALL_SYMS (OPTION_EXPORT_ALL_SYMS + 1) 4023 #define OPTION_EXCLUDE_SYMS (OPTION_NO_EXPORT_ALL_SYMS + 1) 4024 #define OPTION_NO_DEFAULT_EXCLUDES (OPTION_EXCLUDE_SYMS + 1) 4025 #define OPTION_ADD_STDCALL_UNDERSCORE (OPTION_NO_DEFAULT_EXCLUDES + 1) 4026 #define OPTION_USE_NUL_PREFIXED_IMPORT_TABLES \ 4027 (OPTION_ADD_STDCALL_UNDERSCORE + 1) 4028 #define OPTION_IDENTIFY_STRICT (OPTION_USE_NUL_PREFIXED_IMPORT_TABLES + 1) 4029 #define OPTION_NO_LEADING_UNDERSCORE (OPTION_IDENTIFY_STRICT + 1) 4030 #define OPTION_LEADING_UNDERSCORE (OPTION_NO_LEADING_UNDERSCORE + 1) 4031 4032 static const struct option long_options[] = 4033 { 4034 {"no-delete", no_argument, NULL, 'n'}, 4035 {"dllname", required_argument, NULL, 'D'}, 4036 {"no-idata4", no_argument, NULL, 'x'}, 4037 {"no-idata5", no_argument, NULL, 'c'}, 4038 {"use-nul-prefixed-import-tables", no_argument, NULL, 4039 OPTION_USE_NUL_PREFIXED_IMPORT_TABLES}, 4040 {"output-exp", required_argument, NULL, 'e'}, 4041 {"output-def", required_argument, NULL, 'z'}, 4042 {"export-all-symbols", no_argument, NULL, OPTION_EXPORT_ALL_SYMS}, 4043 {"no-export-all-symbols", no_argument, NULL, OPTION_NO_EXPORT_ALL_SYMS}, 4044 {"exclude-symbols", required_argument, NULL, OPTION_EXCLUDE_SYMS}, 4045 {"no-default-excludes", no_argument, NULL, OPTION_NO_DEFAULT_EXCLUDES}, 4046 {"output-lib", required_argument, NULL, 'l'}, 4047 {"def", required_argument, NULL, 'd'}, /* for compatibility with older versions */ 4048 {"input-def", required_argument, NULL, 'd'}, 4049 {"add-underscore", no_argument, NULL, 'U'}, 4050 {"add-stdcall-underscore", no_argument, NULL, OPTION_ADD_STDCALL_UNDERSCORE}, 4051 {"no-leading-underscore", no_argument, NULL, OPTION_NO_LEADING_UNDERSCORE}, 4052 {"leading-underscore", no_argument, NULL, OPTION_LEADING_UNDERSCORE}, 4053 {"kill-at", no_argument, NULL, 'k'}, 4054 {"add-stdcall-alias", no_argument, NULL, 'A'}, 4055 {"ext-prefix-alias", required_argument, NULL, 'p'}, 4056 {"identify", required_argument, NULL, 'I'}, 4057 {"identify-strict", no_argument, NULL, OPTION_IDENTIFY_STRICT}, 4058 {"verbose", no_argument, NULL, 'v'}, 4059 {"version", no_argument, NULL, 'V'}, 4060 {"help", no_argument, NULL, 'h'}, 4061 {"machine", required_argument, NULL, 'm'}, 4062 {"add-indirect", no_argument, NULL, 'a'}, 4063 {"base-file", required_argument, NULL, 'b'}, 4064 {"as", required_argument, NULL, 'S'}, 4065 {"as-flags", required_argument, NULL, 'f'}, 4066 {"mcore-elf", required_argument, NULL, 'M'}, 4067 {"compat-implib", no_argument, NULL, 'C'}, 4068 {"temp-prefix", required_argument, NULL, 't'}, 4069 {"output-delaylib", required_argument, NULL, 'y'}, 4070 {NULL,0,NULL,0} 4071 }; 4072 4073 int main (int, char **); 4074 4075 int 4076 main (int ac, char **av) 4077 { 4078 int c; 4079 int i; 4080 char *firstarg = 0; 4081 program_name = av[0]; 4082 oav = av; 4083 4084 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES) 4085 setlocale (LC_MESSAGES, ""); 4086 #endif 4087 #if defined (HAVE_SETLOCALE) 4088 setlocale (LC_CTYPE, ""); 4089 #endif 4090 bindtextdomain (PACKAGE, LOCALEDIR); 4091 textdomain (PACKAGE); 4092 4093 bfd_set_error_program_name (program_name); 4094 expandargv (&ac, &av); 4095 4096 while ((c = getopt_long (ac, av, 4097 #ifdef DLLTOOL_MCORE_ELF 4098 "m:e:l:aD:d:z:b:xp:cCuUkAS:t:f:nI:vVHhM:L:F:", 4099 #else 4100 "m:e:l:y:aD:d:z:b:xp:cCuUkAS:t:f:nI:vVHh", 4101 #endif 4102 long_options, 0)) 4103 != EOF) 4104 { 4105 switch (c) 4106 { 4107 case OPTION_EXPORT_ALL_SYMS: 4108 export_all_symbols = TRUE; 4109 break; 4110 case OPTION_NO_EXPORT_ALL_SYMS: 4111 export_all_symbols = FALSE; 4112 break; 4113 case OPTION_EXCLUDE_SYMS: 4114 add_excludes (optarg); 4115 break; 4116 case OPTION_NO_DEFAULT_EXCLUDES: 4117 do_default_excludes = FALSE; 4118 break; 4119 case OPTION_USE_NUL_PREFIXED_IMPORT_TABLES: 4120 use_nul_prefixed_import_tables = TRUE; 4121 break; 4122 case OPTION_ADD_STDCALL_UNDERSCORE: 4123 add_stdcall_underscore = 1; 4124 break; 4125 case OPTION_NO_LEADING_UNDERSCORE: 4126 leading_underscore = 0; 4127 break; 4128 case OPTION_LEADING_UNDERSCORE: 4129 leading_underscore = 1; 4130 break; 4131 case OPTION_IDENTIFY_STRICT: 4132 identify_strict = 1; 4133 break; 4134 case 'x': 4135 no_idata4 = 1; 4136 break; 4137 case 'c': 4138 no_idata5 = 1; 4139 break; 4140 case 'S': 4141 as_name = optarg; 4142 break; 4143 case 't': 4144 tmp_prefix = optarg; 4145 break; 4146 case 'f': 4147 as_flags = optarg; 4148 break; 4149 4150 /* Ignored for compatibility. */ 4151 case 'u': 4152 break; 4153 case 'a': 4154 add_indirect = 1; 4155 break; 4156 case 'z': 4157 output_def = fopen (optarg, FOPEN_WT); 4158 if (!output_def) 4159 /* xgettext:c-format */ 4160 fatal (_("Unable to open def-file: %s"), optarg); 4161 break; 4162 case 'D': 4163 dll_name = (char*) lbasename (optarg); 4164 if (dll_name != optarg) 4165 non_fatal (_("Path components stripped from dllname, '%s'."), 4166 optarg); 4167 break; 4168 case 'l': 4169 imp_name = optarg; 4170 break; 4171 case 'e': 4172 exp_name = optarg; 4173 break; 4174 case 'H': 4175 case 'h': 4176 usage (stdout, 0); 4177 break; 4178 case 'm': 4179 mname = optarg; 4180 break; 4181 case 'I': 4182 identify_imp_name = optarg; 4183 break; 4184 case 'v': 4185 verbose = 1; 4186 break; 4187 case 'V': 4188 print_version (program_name); 4189 break; 4190 case 'U': 4191 add_underscore = 1; 4192 break; 4193 case 'k': 4194 killat = 1; 4195 break; 4196 case 'A': 4197 add_stdcall_alias = 1; 4198 break; 4199 case 'p': 4200 ext_prefix_alias = optarg; 4201 break; 4202 case 'd': 4203 def_file = optarg; 4204 break; 4205 case 'n': 4206 dontdeltemps++; 4207 break; 4208 case 'b': 4209 base_file = fopen (optarg, FOPEN_RB); 4210 4211 if (!base_file) 4212 /* xgettext:c-format */ 4213 fatal (_("Unable to open base-file: %s"), optarg); 4214 4215 break; 4216 #ifdef DLLTOOL_MCORE_ELF 4217 case 'M': 4218 mcore_elf_out_file = optarg; 4219 break; 4220 case 'L': 4221 mcore_elf_linker = optarg; 4222 break; 4223 case 'F': 4224 mcore_elf_linker_flags = optarg; 4225 break; 4226 #endif 4227 case 'C': 4228 create_compat_implib = 1; 4229 break; 4230 case 'y': 4231 delayimp_name = optarg; 4232 break; 4233 default: 4234 usage (stderr, 1); 4235 break; 4236 } 4237 } 4238 4239 if (!tmp_prefix) 4240 tmp_prefix = prefix_encode ("d", getpid ()); 4241 4242 for (i = 0; mtable[i].type; i++) 4243 if (strcmp (mtable[i].type, mname) == 0) 4244 break; 4245 4246 if (!mtable[i].type) 4247 /* xgettext:c-format */ 4248 fatal (_("Machine '%s' not supported"), mname); 4249 4250 machine = i; 4251 4252 /* Check if we generated PE+. */ 4253 create_for_pep = strcmp (mname, "i386:x86-64") == 0; 4254 4255 { 4256 /* Check the default underscore */ 4257 int u = leading_underscore; /* Underscoring mode. -1 for use default. */ 4258 if (u == -1) 4259 bfd_get_target_info (mtable[machine].how_bfd_target, NULL, 4260 NULL, &u, NULL); 4261 if (u != -1) 4262 leading_underscore = (u != 0 ? TRUE : FALSE); 4263 } 4264 4265 if (!dll_name && exp_name) 4266 { 4267 /* If we are inferring dll_name from exp_name, 4268 strip off any path components, without emitting 4269 a warning. */ 4270 const char* exp_basename = lbasename (exp_name); 4271 const int len = strlen (exp_basename) + 5; 4272 dll_name = xmalloc (len); 4273 strcpy (dll_name, exp_basename); 4274 strcat (dll_name, ".dll"); 4275 dll_name_set_by_exp_name = 1; 4276 } 4277 4278 if (as_name == NULL) 4279 as_name = deduce_name ("as"); 4280 4281 /* Don't use the default exclude list if we're reading only the 4282 symbols in the .drectve section. The default excludes are meant 4283 to avoid exporting DLL entry point and Cygwin32 impure_ptr. */ 4284 if (! export_all_symbols) 4285 do_default_excludes = FALSE; 4286 4287 if (do_default_excludes) 4288 set_default_excludes (); 4289 4290 if (def_file) 4291 process_def_file (def_file); 4292 4293 while (optind < ac) 4294 { 4295 if (!firstarg) 4296 firstarg = av[optind]; 4297 scan_obj_file (av[optind]); 4298 optind++; 4299 } 4300 4301 mangle_defs (); 4302 4303 if (exp_name) 4304 gen_exp_file (); 4305 4306 if (imp_name) 4307 { 4308 /* Make imp_name safe for use as a label. */ 4309 char *p; 4310 4311 imp_name_lab = xstrdup (imp_name); 4312 for (p = imp_name_lab; *p; p++) 4313 { 4314 if (!ISALNUM (*p)) 4315 *p = '_'; 4316 } 4317 head_label = make_label("_head_", imp_name_lab); 4318 gen_lib_file (0); 4319 } 4320 4321 if (delayimp_name) 4322 { 4323 /* Make delayimp_name safe for use as a label. */ 4324 char *p; 4325 4326 if (mtable[machine].how_dljtab == 0) 4327 { 4328 inform (_("Warning, machine type (%d) not supported for " 4329 "delayimport."), machine); 4330 } 4331 else 4332 { 4333 killat = 1; 4334 imp_name = delayimp_name; 4335 imp_name_lab = xstrdup (imp_name); 4336 for (p = imp_name_lab; *p; p++) 4337 { 4338 if (!ISALNUM (*p)) 4339 *p = '_'; 4340 } 4341 head_label = make_label("__tailMerge_", imp_name_lab); 4342 gen_lib_file (1); 4343 } 4344 } 4345 4346 if (output_def) 4347 gen_def_file (); 4348 4349 if (identify_imp_name) 4350 { 4351 identify_dll_for_implib (); 4352 } 4353 4354 #ifdef DLLTOOL_MCORE_ELF 4355 if (mcore_elf_out_file) 4356 mcore_elf_gen_out_file (); 4357 #endif 4358 4359 return 0; 4360 } 4361 4362 /* Look for the program formed by concatenating PROG_NAME and the 4363 string running from PREFIX to END_PREFIX. If the concatenated 4364 string contains a '/', try appending EXECUTABLE_SUFFIX if it is 4365 appropriate. */ 4366 4367 static char * 4368 look_for_prog (const char *prog_name, const char *prefix, int end_prefix) 4369 { 4370 struct stat s; 4371 char *cmd; 4372 4373 cmd = xmalloc (strlen (prefix) 4374 + strlen (prog_name) 4375 #ifdef HAVE_EXECUTABLE_SUFFIX 4376 + strlen (EXECUTABLE_SUFFIX) 4377 #endif 4378 + 10); 4379 strcpy (cmd, prefix); 4380 4381 sprintf (cmd + end_prefix, "%s", prog_name); 4382 4383 if (strchr (cmd, '/') != NULL) 4384 { 4385 int found; 4386 4387 found = (stat (cmd, &s) == 0 4388 #ifdef HAVE_EXECUTABLE_SUFFIX 4389 || stat (strcat (cmd, EXECUTABLE_SUFFIX), &s) == 0 4390 #endif 4391 ); 4392 4393 if (! found) 4394 { 4395 /* xgettext:c-format */ 4396 inform (_("Tried file: %s"), cmd); 4397 free (cmd); 4398 return NULL; 4399 } 4400 } 4401 4402 /* xgettext:c-format */ 4403 inform (_("Using file: %s"), cmd); 4404 4405 return cmd; 4406 } 4407 4408 /* Deduce the name of the program we are want to invoke. 4409 PROG_NAME is the basic name of the program we want to run, 4410 eg "as" or "ld". The catch is that we might want actually 4411 run "i386-pe-as" or "ppc-pe-ld". 4412 4413 If argv[0] contains the full path, then try to find the program 4414 in the same place, with and then without a target-like prefix. 4415 4416 Given, argv[0] = /usr/local/bin/i586-cygwin32-dlltool, 4417 deduce_name("as") uses the following search order: 4418 4419 /usr/local/bin/i586-cygwin32-as 4420 /usr/local/bin/as 4421 as 4422 4423 If there's an EXECUTABLE_SUFFIX, it'll use that as well; for each 4424 name, it'll try without and then with EXECUTABLE_SUFFIX. 4425 4426 Given, argv[0] = i586-cygwin32-dlltool, it will not even try "as" 4427 as the fallback, but rather return i586-cygwin32-as. 4428 4429 Oh, and given, argv[0] = dlltool, it'll return "as". 4430 4431 Returns a dynamically allocated string. */ 4432 4433 static char * 4434 deduce_name (const char *prog_name) 4435 { 4436 char *cmd; 4437 char *dash, *slash, *cp; 4438 4439 dash = NULL; 4440 slash = NULL; 4441 for (cp = program_name; *cp != '\0'; ++cp) 4442 { 4443 if (*cp == '-') 4444 dash = cp; 4445 if ( 4446 #if defined(__DJGPP__) || defined (__CYGWIN__) || defined(__WIN32__) 4447 *cp == ':' || *cp == '\\' || 4448 #endif 4449 *cp == '/') 4450 { 4451 slash = cp; 4452 dash = NULL; 4453 } 4454 } 4455 4456 cmd = NULL; 4457 4458 if (dash != NULL) 4459 { 4460 /* First, try looking for a prefixed PROG_NAME in the 4461 PROGRAM_NAME directory, with the same prefix as PROGRAM_NAME. */ 4462 cmd = look_for_prog (prog_name, program_name, dash - program_name + 1); 4463 } 4464 4465 if (slash != NULL && cmd == NULL) 4466 { 4467 /* Next, try looking for a PROG_NAME in the same directory as 4468 that of this program. */ 4469 cmd = look_for_prog (prog_name, program_name, slash - program_name + 1); 4470 } 4471 4472 if (cmd == NULL) 4473 { 4474 /* Just return PROG_NAME as is. */ 4475 cmd = xstrdup (prog_name); 4476 } 4477 4478 return cmd; 4479 } 4480 4481 #ifdef DLLTOOL_MCORE_ELF 4482 typedef struct fname_cache 4483 { 4484 const char * filename; 4485 struct fname_cache * next; 4486 } 4487 fname_cache; 4488 4489 static fname_cache fnames; 4490 4491 static void 4492 mcore_elf_cache_filename (const char * filename) 4493 { 4494 fname_cache * ptr; 4495 4496 ptr = & fnames; 4497 4498 while (ptr->next != NULL) 4499 ptr = ptr->next; 4500 4501 ptr->filename = filename; 4502 ptr->next = (fname_cache *) malloc (sizeof (fname_cache)); 4503 if (ptr->next != NULL) 4504 ptr->next->next = NULL; 4505 } 4506 4507 #define MCORE_ELF_TMP_OBJ "mcoreelf.o" 4508 #define MCORE_ELF_TMP_EXP "mcoreelf.exp" 4509 #define MCORE_ELF_TMP_LIB "mcoreelf.lib" 4510 4511 static void 4512 mcore_elf_gen_out_file (void) 4513 { 4514 fname_cache * ptr; 4515 dyn_string_t ds; 4516 4517 /* Step one. Run 'ld -r' on the input object files in order to resolve 4518 any internal references and to generate a single .exports section. */ 4519 ptr = & fnames; 4520 4521 ds = dyn_string_new (100); 4522 dyn_string_append_cstr (ds, "-r "); 4523 4524 if (mcore_elf_linker_flags != NULL) 4525 dyn_string_append_cstr (ds, mcore_elf_linker_flags); 4526 4527 while (ptr->next != NULL) 4528 { 4529 dyn_string_append_cstr (ds, ptr->filename); 4530 dyn_string_append_cstr (ds, " "); 4531 4532 ptr = ptr->next; 4533 } 4534 4535 dyn_string_append_cstr (ds, "-o "); 4536 dyn_string_append_cstr (ds, MCORE_ELF_TMP_OBJ); 4537 4538 if (mcore_elf_linker == NULL) 4539 mcore_elf_linker = deduce_name ("ld"); 4540 4541 run (mcore_elf_linker, ds->s); 4542 4543 dyn_string_delete (ds); 4544 4545 /* Step two. Create a .exp file and a .lib file from the temporary file. 4546 Do this by recursively invoking dlltool... */ 4547 ds = dyn_string_new (100); 4548 4549 dyn_string_append_cstr (ds, "-S "); 4550 dyn_string_append_cstr (ds, as_name); 4551 4552 dyn_string_append_cstr (ds, " -e "); 4553 dyn_string_append_cstr (ds, MCORE_ELF_TMP_EXP); 4554 dyn_string_append_cstr (ds, " -l "); 4555 dyn_string_append_cstr (ds, MCORE_ELF_TMP_LIB); 4556 dyn_string_append_cstr (ds, " " ); 4557 dyn_string_append_cstr (ds, MCORE_ELF_TMP_OBJ); 4558 4559 if (verbose) 4560 dyn_string_append_cstr (ds, " -v"); 4561 4562 if (dontdeltemps) 4563 { 4564 dyn_string_append_cstr (ds, " -n"); 4565 4566 if (dontdeltemps > 1) 4567 dyn_string_append_cstr (ds, " -n"); 4568 } 4569 4570 /* XXX - FIME: ought to check/copy other command line options as well. */ 4571 run (program_name, ds->s); 4572 4573 dyn_string_delete (ds); 4574 4575 /* Step four. Feed the .exp and object files to ld -shared to create the dll. */ 4576 ds = dyn_string_new (100); 4577 4578 dyn_string_append_cstr (ds, "-shared "); 4579 4580 if (mcore_elf_linker_flags) 4581 dyn_string_append_cstr (ds, mcore_elf_linker_flags); 4582 4583 dyn_string_append_cstr (ds, " "); 4584 dyn_string_append_cstr (ds, MCORE_ELF_TMP_EXP); 4585 dyn_string_append_cstr (ds, " "); 4586 dyn_string_append_cstr (ds, MCORE_ELF_TMP_OBJ); 4587 dyn_string_append_cstr (ds, " -o "); 4588 dyn_string_append_cstr (ds, mcore_elf_out_file); 4589 4590 run (mcore_elf_linker, ds->s); 4591 4592 dyn_string_delete (ds); 4593 4594 if (dontdeltemps == 0) 4595 unlink (MCORE_ELF_TMP_EXP); 4596 4597 if (dontdeltemps < 2) 4598 unlink (MCORE_ELF_TMP_OBJ); 4599 } 4600 #endif /* DLLTOOL_MCORE_ELF */ 4601
