1 /* dlltool.c -- tool to generate stuff for PE style DLLs 2 Copyright (C) 1995-2014 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; 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 { 1270 buf = (char *) alloca (strlen (module) + strlen (dllext) + 2); 1271 sprintf (buf, "%s.%s", module, dllext); 1272 module = buf; 1273 } 1274 1275 append_import (application_name, module, ord_val, its_name); 1276 } 1277 1278 void 1279 def_version (int major, int minor) 1280 { 1281 printf (_("VERSION %d.%d\n"), major, minor); 1282 } 1283 1284 void 1285 def_section (const char *name, int attr) 1286 { 1287 char buf[200]; 1288 char atts[5]; 1289 char *d = atts; 1290 if (attr & 1) 1291 *d++ = 'R'; 1292 1293 if (attr & 2) 1294 *d++ = 'W'; 1295 if (attr & 4) 1296 *d++ = 'X'; 1297 if (attr & 8) 1298 *d++ = 'S'; 1299 *d++ = 0; 1300 sprintf (buf, "-attr %s %s", name, atts); 1301 new_directive (xstrdup (buf)); 1302 } 1303 1304 void 1305 def_code (int attr) 1306 { 1307 1308 def_section ("CODE", attr); 1309 } 1310 1311 void 1312 def_data (int attr) 1313 { 1314 def_section ("DATA", attr); 1315 } 1316 1317 /**********************************************************************/ 1318 1319 static void 1320 run (const char *what, char *args) 1321 { 1322 char *s; 1323 int pid, wait_status; 1324 int i; 1325 const char **argv; 1326 char *errmsg_fmt, *errmsg_arg; 1327 char *temp_base = choose_temp_base (); 1328 1329 inform (_("run: %s %s"), what, args); 1330 1331 /* Count the args */ 1332 i = 0; 1333 for (s = args; *s; s++) 1334 if (*s == ' ') 1335 i++; 1336 i++; 1337 argv = alloca (sizeof (char *) * (i + 3)); 1338 i = 0; 1339 argv[i++] = what; 1340 s = args; 1341 while (1) 1342 { 1343 while (*s == ' ') 1344 ++s; 1345 argv[i++] = s; 1346 while (*s != ' ' && *s != 0) 1347 s++; 1348 if (*s == 0) 1349 break; 1350 *s++ = 0; 1351 } 1352 argv[i++] = NULL; 1353 1354 pid = pexecute (argv[0], (char * const *) argv, program_name, temp_base, 1355 &errmsg_fmt, &errmsg_arg, PEXECUTE_ONE | PEXECUTE_SEARCH); 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 arfile = next; 1703 } 1704 1705 #ifdef DLLTOOL_MCORE_ELF 1706 if (mcore_elf_out_file) 1707 inform (_("Cannot produce mcore-elf dll from archive file: %s"), filename); 1708 #endif 1709 } 1710 else if (bfd_check_format (f, bfd_object)) 1711 { 1712 scan_open_obj_file (f); 1713 1714 #ifdef DLLTOOL_MCORE_ELF 1715 if (mcore_elf_out_file) 1716 mcore_elf_cache_filename (filename); 1717 #endif 1718 } 1719 1720 bfd_close (f); 1721 } 1722 1723 1724 1726 static void 1727 dump_def_info (FILE *f) 1728 { 1729 int i; 1730 export_type *exp; 1731 fprintf (f, "%s ", ASM_C); 1732 for (i = 0; oav[i]; i++) 1733 fprintf (f, "%s ", oav[i]); 1734 fprintf (f, "\n"); 1735 for (i = 0, exp = d_exports; exp; i++, exp = exp->next) 1736 { 1737 fprintf (f, "%s %d = %s %s @ %d %s%s%s%s%s%s\n", 1738 ASM_C, 1739 i, 1740 exp->name, 1741 exp->internal_name, 1742 exp->ordinal, 1743 exp->noname ? "NONAME " : "", 1744 exp->private ? "PRIVATE " : "", 1745 exp->constant ? "CONSTANT" : "", 1746 exp->data ? "DATA" : "", 1747 exp->its_name ? " ==" : "", 1748 exp->its_name ? exp->its_name : ""); 1749 } 1750 } 1751 1752 /* Generate the .exp file. */ 1753 1754 static int 1755 sfunc (const void *a, const void *b) 1756 { 1757 if (*(const bfd_vma *) a == *(const bfd_vma *) b) 1758 return 0; 1759 1760 return ((*(const bfd_vma *) a > *(const bfd_vma *) b) ? 1 : -1); 1761 } 1762 1763 static void 1764 flush_page (FILE *f, bfd_vma *need, bfd_vma page_addr, int on_page) 1765 { 1766 int i; 1767 1768 /* Flush this page. */ 1769 fprintf (f, "\t%s\t0x%08x\t%s Starting RVA for chunk\n", 1770 ASM_LONG, 1771 (int) page_addr, 1772 ASM_C); 1773 fprintf (f, "\t%s\t0x%x\t%s Size of block\n", 1774 ASM_LONG, 1775 (on_page * 2) + (on_page & 1) * 2 + 8, 1776 ASM_C); 1777 1778 for (i = 0; i < on_page; i++) 1779 { 1780 bfd_vma needed = need[i]; 1781 1782 if (needed) 1783 { 1784 if (!create_for_pep) 1785 { 1786 /* Relocation via HIGHLOW. */ 1787 needed = ((needed - page_addr) | 0x3000) & 0xffff; 1788 } 1789 else 1790 { 1791 /* Relocation via DIR64. */ 1792 needed = ((needed - page_addr) | 0xa000) & 0xffff; 1793 } 1794 } 1795 1796 fprintf (f, "\t%s\t0x%lx\n", ASM_SHORT, (long) needed); 1797 } 1798 1799 /* And padding */ 1800 if (on_page & 1) 1801 fprintf (f, "\t%s\t0x%x\n", ASM_SHORT, 0 | 0x0000); 1802 } 1803 1804 static void 1805 gen_def_file (void) 1806 { 1807 int i; 1808 export_type *exp; 1809 1810 inform (_("Adding exports to output file")); 1811 1812 fprintf (output_def, ";"); 1813 for (i = 0; oav[i]; i++) 1814 fprintf (output_def, " %s", oav[i]); 1815 1816 fprintf (output_def, "\nEXPORTS\n"); 1817 1818 for (i = 0, exp = d_exports; exp; i++, exp = exp->next) 1819 { 1820 char *quote = strchr (exp->name, '.') ? "\"" : ""; 1821 char *res = cplus_demangle (exp->internal_name, DMGL_ANSI | DMGL_PARAMS); 1822 1823 if (res) 1824 { 1825 fprintf (output_def,";\t%s\n", res); 1826 free (res); 1827 } 1828 1829 if (strcmp (exp->name, exp->internal_name) == 0) 1830 { 1831 fprintf (output_def, "\t%s%s%s @ %d%s%s%s%s%s\n", 1832 quote, 1833 exp->name, 1834 quote, 1835 exp->ordinal, 1836 exp->noname ? " NONAME" : "", 1837 exp->private ? "PRIVATE " : "", 1838 exp->data ? " DATA" : "", 1839 exp->its_name ? " ==" : "", 1840 exp->its_name ? exp->its_name : ""); 1841 } 1842 else 1843 { 1844 char * quote1 = strchr (exp->internal_name, '.') ? "\"" : ""; 1845 /* char *alias = */ 1846 fprintf (output_def, "\t%s%s%s = %s%s%s @ %d%s%s%s%s%s\n", 1847 quote, 1848 exp->name, 1849 quote, 1850 quote1, 1851 exp->internal_name, 1852 quote1, 1853 exp->ordinal, 1854 exp->noname ? " NONAME" : "", 1855 exp->private ? "PRIVATE " : "", 1856 exp->data ? " DATA" : "", 1857 exp->its_name ? " ==" : "", 1858 exp->its_name ? exp->its_name : ""); 1859 } 1860 } 1861 1862 inform (_("Added exports to output file")); 1863 } 1864 1865 /* generate_idata_ofile generates the portable assembly source code 1866 for the idata sections. It appends the source code to the end of 1867 the file. */ 1868 1869 static void 1870 generate_idata_ofile (FILE *filvar) 1871 { 1872 iheadtype *headptr; 1873 ifunctype *funcptr; 1874 int headindex; 1875 int funcindex; 1876 int nheads; 1877 1878 if (import_list == NULL) 1879 return; 1880 1881 fprintf (filvar, "%s Import data sections\n", ASM_C); 1882 fprintf (filvar, "\n\t.section\t.idata$2\n"); 1883 fprintf (filvar, "\t%s\tdoi_idata\n", ASM_GLOBAL); 1884 fprintf (filvar, "doi_idata:\n"); 1885 1886 nheads = 0; 1887 for (headptr = import_list; headptr != NULL; headptr = headptr->next) 1888 { 1889 fprintf (filvar, "\t%slistone%d%s\t%s %s\n", 1890 ASM_RVA_BEFORE, nheads, ASM_RVA_AFTER, 1891 ASM_C, headptr->dllname); 1892 fprintf (filvar, "\t%s\t0\n", ASM_LONG); 1893 fprintf (filvar, "\t%s\t0\n", ASM_LONG); 1894 fprintf (filvar, "\t%sdllname%d%s\n", 1895 ASM_RVA_BEFORE, nheads, ASM_RVA_AFTER); 1896 fprintf (filvar, "\t%slisttwo%d%s\n\n", 1897 ASM_RVA_BEFORE, nheads, ASM_RVA_AFTER); 1898 nheads++; 1899 } 1900 1901 fprintf (filvar, "\t%s\t0\n", ASM_LONG); /* NULL record at */ 1902 fprintf (filvar, "\t%s\t0\n", ASM_LONG); /* end of idata$2 */ 1903 fprintf (filvar, "\t%s\t0\n", ASM_LONG); /* section */ 1904 fprintf (filvar, "\t%s\t0\n", ASM_LONG); 1905 fprintf (filvar, "\t%s\t0\n", ASM_LONG); 1906 1907 fprintf (filvar, "\n\t.section\t.idata$4\n"); 1908 headindex = 0; 1909 for (headptr = import_list; headptr != NULL; headptr = headptr->next) 1910 { 1911 fprintf (filvar, "listone%d:\n", headindex); 1912 for (funcindex = 0; funcindex < headptr->nfuncs; funcindex++) 1913 { 1914 if (create_for_pep) 1915 fprintf (filvar, "\t%sfuncptr%d_%d%s\n%s\t0\n", 1916 ASM_RVA_BEFORE, headindex, funcindex, ASM_RVA_AFTER, 1917 ASM_LONG); 1918 else 1919 fprintf (filvar, "\t%sfuncptr%d_%d%s\n", 1920 ASM_RVA_BEFORE, headindex, funcindex, ASM_RVA_AFTER); 1921 } 1922 if (create_for_pep) 1923 fprintf (filvar, "\t%s\t0\n\t%s\t0\n", ASM_LONG, ASM_LONG); 1924 else 1925 fprintf (filvar, "\t%s\t0\n", ASM_LONG); /* NULL terminating list. */ 1926 headindex++; 1927 } 1928 1929 fprintf (filvar, "\n\t.section\t.idata$5\n"); 1930 headindex = 0; 1931 for (headptr = import_list; headptr != NULL; headptr = headptr->next) 1932 { 1933 fprintf (filvar, "listtwo%d:\n", headindex); 1934 for (funcindex = 0; funcindex < headptr->nfuncs; funcindex++) 1935 { 1936 if (create_for_pep) 1937 fprintf (filvar, "\t%sfuncptr%d_%d%s\n%s\t0\n", 1938 ASM_RVA_BEFORE, headindex, funcindex, ASM_RVA_AFTER, 1939 ASM_LONG); 1940 else 1941 fprintf (filvar, "\t%sfuncptr%d_%d%s\n", 1942 ASM_RVA_BEFORE, headindex, funcindex, ASM_RVA_AFTER); 1943 } 1944 if (create_for_pep) 1945 fprintf (filvar, "\t%s\t0\n\t%s\t0\n", ASM_LONG, ASM_LONG); 1946 else 1947 fprintf (filvar, "\t%s\t0\n", ASM_LONG); /* NULL terminating list. */ 1948 headindex++; 1949 } 1950 1951 fprintf (filvar, "\n\t.section\t.idata$6\n"); 1952 headindex = 0; 1953 for (headptr = import_list; headptr != NULL; headptr = headptr->next) 1954 { 1955 funcindex = 0; 1956 for (funcptr = headptr->funchead; funcptr != NULL; 1957 funcptr = funcptr->next) 1958 { 1959 fprintf (filvar,"funcptr%d_%d:\n", headindex, funcindex); 1960 fprintf (filvar,"\t%s\t%d\n", ASM_SHORT, 1961 ((funcptr->ord) & 0xFFFF)); 1962 fprintf (filvar,"\t%s\t\"%s\"\n", ASM_TEXT, 1963 (funcptr->its_name ? funcptr->its_name : funcptr->name)); 1964 fprintf (filvar,"\t%s\t0\n", ASM_BYTE); 1965 funcindex++; 1966 } 1967 headindex++; 1968 } 1969 1970 fprintf (filvar, "\n\t.section\t.idata$7\n"); 1971 headindex = 0; 1972 for (headptr = import_list; headptr != NULL; headptr = headptr->next) 1973 { 1974 fprintf (filvar,"dllname%d:\n", headindex); 1975 fprintf (filvar,"\t%s\t\"%s\"\n", ASM_TEXT, headptr->dllname); 1976 fprintf (filvar,"\t%s\t0\n", ASM_BYTE); 1977 headindex++; 1978 } 1979 } 1980 1981 /* Assemble the specified file. */ 1982 static void 1983 assemble_file (const char * source, const char * dest) 1984 { 1985 char * cmd; 1986 1987 cmd = (char *) alloca (strlen (ASM_SWITCHES) + strlen (as_flags) 1988 + strlen (source) + strlen (dest) + 50); 1989 1990 sprintf (cmd, "%s %s -o %s %s", ASM_SWITCHES, as_flags, dest, source); 1991 1992 run (as_name, cmd); 1993 } 1994 1995 static void 1996 gen_exp_file (void) 1997 { 1998 FILE *f; 1999 int i; 2000 export_type *exp; 2001 dlist_type *dl; 2002 2003 /* xgettext:c-format */ 2004 inform (_("Generating export file: %s"), exp_name); 2005 2006 f = fopen (TMP_ASM, FOPEN_WT); 2007 if (!f) 2008 /* xgettext:c-format */ 2009 fatal (_("Unable to open temporary assembler file: %s"), TMP_ASM); 2010 2011 /* xgettext:c-format */ 2012 inform (_("Opened temporary file: %s"), TMP_ASM); 2013 2014 dump_def_info (f); 2015 2016 if (d_exports) 2017 { 2018 fprintf (f, "\t.section .edata\n\n"); 2019 fprintf (f, "\t%s 0 %s Allways 0\n", ASM_LONG, ASM_C); 2020 fprintf (f, "\t%s 0x%lx %s Time and date\n", ASM_LONG, 2021 (unsigned long) time(0), ASM_C); 2022 fprintf (f, "\t%s 0 %s Major and Minor version\n", ASM_LONG, ASM_C); 2023 fprintf (f, "\t%sname%s %s Ptr to name of dll\n", ASM_RVA_BEFORE, ASM_RVA_AFTER, ASM_C); 2024 fprintf (f, "\t%s %d %s Starting ordinal of exports\n", ASM_LONG, d_low_ord, ASM_C); 2025 2026 2027 fprintf (f, "\t%s %d %s Number of functions\n", ASM_LONG, d_high_ord - d_low_ord + 1, ASM_C); 2028 fprintf(f,"\t%s named funcs %d, low ord %d, high ord %d\n", 2029 ASM_C, 2030 d_named_nfuncs, d_low_ord, d_high_ord); 2031 fprintf (f, "\t%s %d %s Number of names\n", ASM_LONG, 2032 show_allnames ? d_high_ord - d_low_ord + 1 : d_named_nfuncs, ASM_C); 2033 fprintf (f, "\t%safuncs%s %s Address of functions\n", ASM_RVA_BEFORE, ASM_RVA_AFTER, ASM_C); 2034 2035 fprintf (f, "\t%sanames%s %s Address of Name Pointer Table\n", 2036 ASM_RVA_BEFORE, ASM_RVA_AFTER, ASM_C); 2037 2038 fprintf (f, "\t%sanords%s %s Address of ordinals\n", ASM_RVA_BEFORE, ASM_RVA_AFTER, ASM_C); 2039 2040 fprintf (f, "name: %s \"%s\"\n", ASM_TEXT, dll_name); 2041 2042 2043 fprintf(f,"%s Export address Table\n", ASM_C); 2044 fprintf(f,"\t%s\n", ASM_ALIGN_LONG); 2045 fprintf (f, "afuncs:\n"); 2046 i = d_low_ord; 2047 2048 for (exp = d_exports; exp; exp = exp->next) 2049 { 2050 if (exp->ordinal != i) 2051 { 2052 while (i < exp->ordinal) 2053 { 2054 fprintf(f,"\t%s\t0\n", ASM_LONG); 2055 i++; 2056 } 2057 } 2058 2059 if (exp->forward == 0) 2060 { 2061 if (exp->internal_name[0] == '@') 2062 fprintf (f, "\t%s%s%s\t%s %d\n", ASM_RVA_BEFORE, 2063 exp->internal_name, ASM_RVA_AFTER, ASM_C, exp->ordinal); 2064 else 2065 fprintf (f, "\t%s%s%s%s\t%s %d\n", ASM_RVA_BEFORE, 2066 ASM_PREFIX (exp->internal_name), 2067 exp->internal_name, ASM_RVA_AFTER, ASM_C, exp->ordinal); 2068 } 2069 else 2070 fprintf (f, "\t%sf%d%s\t%s %d\n", ASM_RVA_BEFORE, 2071 exp->forward, ASM_RVA_AFTER, ASM_C, exp->ordinal); 2072 i++; 2073 } 2074 2075 fprintf (f,"%s Export Name Pointer Table\n", ASM_C); 2076 fprintf (f, "anames:\n"); 2077 2078 for (i = 0; (exp = d_exports_lexically[i]); i++) 2079 { 2080 if (!exp->noname || show_allnames) 2081 fprintf (f, "\t%sn%d%s\n", 2082 ASM_RVA_BEFORE, exp->ordinal, ASM_RVA_AFTER); 2083 } 2084 2085 fprintf (f,"%s Export Ordinal Table\n", ASM_C); 2086 fprintf (f, "anords:\n"); 2087 for (i = 0; (exp = d_exports_lexically[i]); i++) 2088 { 2089 if (!exp->noname || show_allnames) 2090 fprintf (f, "\t%s %d\n", ASM_SHORT, exp->ordinal - d_low_ord); 2091 } 2092 2093 fprintf(f,"%s Export Name Table\n", ASM_C); 2094 for (i = 0; (exp = d_exports_lexically[i]); i++) 2095 { 2096 if (!exp->noname || show_allnames) 2097 fprintf (f, "n%d: %s \"%s\"\n", 2098 exp->ordinal, ASM_TEXT, 2099 (exp->its_name ? exp->its_name : xlate (exp->name))); 2100 if (exp->forward != 0) 2101 fprintf (f, "f%d: %s \"%s\"\n", 2102 exp->forward, ASM_TEXT, exp->internal_name); 2103 } 2104 2105 if (a_list) 2106 { 2107 fprintf (f, "\t.section %s\n", DRECTVE_SECTION_NAME); 2108 for (dl = a_list; dl; dl = dl->next) 2109 { 2110 fprintf (f, "\t%s\t\"%s\"\n", ASM_TEXT, dl->text); 2111 } 2112 } 2113 2114 if (d_list) 2115 { 2116 fprintf (f, "\t.section .rdata\n"); 2117 for (dl = d_list; dl; dl = dl->next) 2118 { 2119 char *p; 2120 int l; 2121 2122 /* We don't output as ascii because there can 2123 be quote characters in the string. */ 2124 l = 0; 2125 for (p = dl->text; *p; p++) 2126 { 2127 if (l == 0) 2128 fprintf (f, "\t%s\t", ASM_BYTE); 2129 else 2130 fprintf (f, ","); 2131 fprintf (f, "%d", *p); 2132 if (p[1] == 0) 2133 { 2134 fprintf (f, ",0\n"); 2135 break; 2136 } 2137 if (++l == 10) 2138 { 2139 fprintf (f, "\n"); 2140 l = 0; 2141 } 2142 } 2143 } 2144 } 2145 } 2146 2147 2148 /* Add to the output file a way of getting to the exported names 2149 without using the import library. */ 2150 if (add_indirect) 2151 { 2152 fprintf (f, "\t.section\t.rdata\n"); 2153 for (i = 0, exp = d_exports; exp; i++, exp = exp->next) 2154 if (!exp->noname || show_allnames) 2155 { 2156 /* We use a single underscore for MS compatibility, and a 2157 double underscore for backward compatibility with old 2158 cygwin releases. */ 2159 if (create_compat_implib) 2160 fprintf (f, "\t%s\t__imp_%s\n", ASM_GLOBAL, exp->name); 2161 fprintf (f, "\t%s\t_imp_%s%s\n", ASM_GLOBAL, 2162 (!leading_underscore ? "" : "_"), exp->name); 2163 if (create_compat_implib) 2164 fprintf (f, "__imp_%s:\n", exp->name); 2165 fprintf (f, "_imp_%s%s:\n", (!leading_underscore ? "" : "_"), exp->name); 2166 fprintf (f, "\t%s\t%s\n", ASM_LONG, exp->name); 2167 } 2168 } 2169 2170 /* Dump the reloc section if a base file is provided. */ 2171 if (base_file) 2172 { 2173 bfd_vma addr; 2174 bfd_vma need[COFF_PAGE_SIZE]; 2175 bfd_vma page_addr; 2176 bfd_size_type numbytes; 2177 int num_entries; 2178 bfd_vma *copy; 2179 int j; 2180 int on_page; 2181 fprintf (f, "\t.section\t.init\n"); 2182 fprintf (f, "lab:\n"); 2183 2184 fseek (base_file, 0, SEEK_END); 2185 numbytes = ftell (base_file); 2186 fseek (base_file, 0, SEEK_SET); 2187 copy = xmalloc (numbytes); 2188 if (fread (copy, 1, numbytes, base_file) < numbytes) 2189 fatal (_("failed to read the number of entries from base file")); 2190 num_entries = numbytes / sizeof (bfd_vma); 2191 2192 2193 fprintf (f, "\t.section\t.reloc\n"); 2194 if (num_entries) 2195 { 2196 int src; 2197 int dst = 0; 2198 bfd_vma last = (bfd_vma) -1; 2199 qsort (copy, num_entries, sizeof (bfd_vma), sfunc); 2200 /* Delete duplicates */ 2201 for (src = 0; src < num_entries; src++) 2202 { 2203 if (last != copy[src]) 2204 last = copy[dst++] = copy[src]; 2205 } 2206 num_entries = dst; 2207 addr = copy[0]; 2208 page_addr = addr & PAGE_MASK; /* work out the page addr */ 2209 on_page = 0; 2210 for (j = 0; j < num_entries; j++) 2211 { 2212 addr = copy[j]; 2213 if ((addr & PAGE_MASK) != page_addr) 2214 { 2215 flush_page (f, need, page_addr, on_page); 2216 on_page = 0; 2217 page_addr = addr & PAGE_MASK; 2218 } 2219 need[on_page++] = addr; 2220 } 2221 flush_page (f, need, page_addr, on_page); 2222 2223 /* fprintf (f, "\t%s\t0,0\t%s End\n", ASM_LONG, ASM_C);*/ 2224 } 2225 } 2226 2227 generate_idata_ofile (f); 2228 2229 fclose (f); 2230 2231 /* Assemble the file. */ 2232 assemble_file (TMP_ASM, exp_name); 2233 2234 if (dontdeltemps == 0) 2235 unlink (TMP_ASM); 2236 2237 inform (_("Generated exports file")); 2238 } 2239 2240 static const char * 2241 xlate (const char *name) 2242 { 2243 int lead_at = (*name == '@'); 2244 int is_stdcall = (!lead_at && strchr (name, '@') != NULL); 2245 2246 if (!lead_at && (add_underscore 2247 || (add_stdcall_underscore && is_stdcall))) 2248 { 2249 char *copy = xmalloc (strlen (name) + 2); 2250 2251 copy[0] = '_'; 2252 strcpy (copy + 1, name); 2253 name = copy; 2254 } 2255 2256 if (killat) 2257 { 2258 char *p; 2259 2260 name += lead_at; 2261 /* PR 9766: Look for the last @ sign in the name. */ 2262 p = strrchr (name, '@'); 2263 if (p && ISDIGIT (p[1])) 2264 *p = 0; 2265 } 2266 return name; 2267 } 2268 2269 typedef struct 2270 { 2271 int id; 2272 const char *name; 2273 int flags; 2274 int align; 2275 asection *sec; 2276 asymbol *sym; 2277 asymbol **sympp; 2278 int size; 2279 unsigned char *data; 2280 } sinfo; 2281 2282 #define INIT_SEC_DATA(id, name, flags, align) \ 2283 { id, name, flags, align, NULL, NULL, NULL, 0, NULL } 2284 2285 #ifndef DLLTOOL_PPC 2286 2287 #define TEXT 0 2288 #define DATA 1 2289 #define BSS 2 2290 #define IDATA7 3 2291 #define IDATA5 4 2292 #define IDATA4 5 2293 #define IDATA6 6 2294 2295 #define NSECS 7 2296 2297 #define TEXT_SEC_FLAGS \ 2298 (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY | SEC_HAS_CONTENTS) 2299 #define DATA_SEC_FLAGS (SEC_ALLOC | SEC_LOAD | SEC_DATA) 2300 #define BSS_SEC_FLAGS SEC_ALLOC 2301 2302 static sinfo secdata[NSECS] = 2303 { 2304 INIT_SEC_DATA (TEXT, ".text", TEXT_SEC_FLAGS, 2), 2305 INIT_SEC_DATA (DATA, ".data", DATA_SEC_FLAGS, 2), 2306 INIT_SEC_DATA (BSS, ".bss", BSS_SEC_FLAGS, 2), 2307 INIT_SEC_DATA (IDATA7, ".idata$7", SEC_HAS_CONTENTS, 2), 2308 INIT_SEC_DATA (IDATA5, ".idata$5", SEC_HAS_CONTENTS, 2), 2309 INIT_SEC_DATA (IDATA4, ".idata$4", SEC_HAS_CONTENTS, 2), 2310 INIT_SEC_DATA (IDATA6, ".idata$6", SEC_HAS_CONTENTS, 1) 2311 }; 2312 2313 #else 2314 2315 /* Sections numbered to make the order the same as other PowerPC NT 2316 compilers. This also keeps funny alignment thingies from happening. */ 2317 #define TEXT 0 2318 #define PDATA 1 2319 #define RDATA 2 2320 #define IDATA5 3 2321 #define IDATA4 4 2322 #define IDATA6 5 2323 #define IDATA7 6 2324 #define DATA 7 2325 #define BSS 8 2326 2327 #define NSECS 9 2328 2329 static sinfo secdata[NSECS] = 2330 { 2331 INIT_SEC_DATA (TEXT, ".text", SEC_CODE | SEC_HAS_CONTENTS, 3), 2332 INIT_SEC_DATA (PDATA, ".pdata", SEC_HAS_CONTENTS, 2), 2333 INIT_SEC_DATA (RDATA, ".reldata", SEC_HAS_CONTENTS, 2), 2334 INIT_SEC_DATA (IDATA5, ".idata$5", SEC_HAS_CONTENTS, 2), 2335 INIT_SEC_DATA (IDATA4, ".idata$4", SEC_HAS_CONTENTS, 2), 2336 INIT_SEC_DATA (IDATA6, ".idata$6", SEC_HAS_CONTENTS, 1), 2337 INIT_SEC_DATA (IDATA7, ".idata$7", SEC_HAS_CONTENTS, 2), 2338 INIT_SEC_DATA (DATA, ".data", SEC_DATA, 2), 2339 INIT_SEC_DATA (BSS, ".bss", 0, 2) 2340 }; 2341 2342 #endif 2343 2344 /* This is what we're trying to make. We generate the imp symbols with 2345 both single and double underscores, for compatibility. 2346 2347 .text 2348 .global _GetFileVersionInfoSizeW@8 2349 .global __imp_GetFileVersionInfoSizeW@8 2350 _GetFileVersionInfoSizeW@8: 2351 jmp * __imp_GetFileVersionInfoSizeW@8 2352 .section .idata$7 # To force loading of head 2353 .long __version_a_head 2354 # Import Address Table 2355 .section .idata$5 2356 __imp_GetFileVersionInfoSizeW@8: 2357 .rva ID2 2358 2359 # Import Lookup Table 2360 .section .idata$4 2361 .rva ID2 2362 # Hint/Name table 2363 .section .idata$6 2364 ID2: .short 2 2365 .asciz "GetFileVersionInfoSizeW" 2366 2367 2368 For the PowerPC, here's the variation on the above scheme: 2369 2370 # Rather than a simple "jmp *", the code to get to the dll function 2371 # looks like: 2372 .text 2373 lwz r11,[tocv]__imp_function_name(r2) 2374 # RELOC: 00000000 TOCREL16,TOCDEFN __imp_function_name 2375 lwz r12,0(r11) 2376 stw r2,4(r1) 2377 mtctr r12 2378 lwz r2,4(r11) 2379 bctr */ 2380 2381 static char * 2382 make_label (const char *prefix, const char *name) 2383 { 2384 int len = strlen (ASM_PREFIX (name)) + strlen (prefix) + strlen (name); 2385 char *copy = xmalloc (len + 1); 2386 2387 strcpy (copy, ASM_PREFIX (name)); 2388 strcat (copy, prefix); 2389 strcat (copy, name); 2390 return copy; 2391 } 2392 2393 static char * 2394 make_imp_label (const char *prefix, const char *name) 2395 { 2396 int len; 2397 char *copy; 2398 2399 if (name[0] == '@') 2400 { 2401 len = strlen (prefix) + strlen (name); 2402 copy = xmalloc (len + 1); 2403 strcpy (copy, prefix); 2404 strcat (copy, name); 2405 } 2406 else 2407 { 2408 len = strlen (ASM_PREFIX (name)) + strlen (prefix) + strlen (name); 2409 copy = xmalloc (len + 1); 2410 strcpy (copy, prefix); 2411 strcat (copy, ASM_PREFIX (name)); 2412 strcat (copy, name); 2413 } 2414 return copy; 2415 } 2416 2417 static bfd * 2418 make_one_lib_file (export_type *exp, int i, int delay) 2419 { 2420 bfd * abfd; 2421 asymbol * exp_label; 2422 asymbol * iname = 0; 2423 asymbol * iname2; 2424 asymbol * iname_lab; 2425 asymbol ** iname_lab_pp; 2426 asymbol ** iname_pp; 2427 #ifdef DLLTOOL_PPC 2428 asymbol ** fn_pp; 2429 asymbol ** toc_pp; 2430 #define EXTRA 2 2431 #endif 2432 #ifndef EXTRA 2433 #define EXTRA 0 2434 #endif 2435 asymbol * ptrs[NSECS + 4 + EXTRA + 1]; 2436 flagword applicable; 2437 char * outname = xmalloc (strlen (TMP_STUB) + 10); 2438 int oidx = 0; 2439 2440 2441 sprintf (outname, "%s%05d.o", TMP_STUB, i); 2442 2443 abfd = bfd_openw (outname, HOW_BFD_WRITE_TARGET); 2444 2445 if (!abfd) 2446 /* xgettext:c-format */ 2447 fatal (_("bfd_open failed open stub file: %s: %s"), 2448 outname, bfd_get_errmsg ()); 2449 2450 /* xgettext:c-format */ 2451 inform (_("Creating stub file: %s"), outname); 2452 2453 bfd_set_format (abfd, bfd_object); 2454 bfd_set_arch_mach (abfd, HOW_BFD_ARCH, 0); 2455 2456 #ifdef DLLTOOL_ARM 2457 if (machine == MARM_INTERWORK || machine == MTHUMB) 2458 bfd_set_private_flags (abfd, F_INTERWORK); 2459 #endif 2460 2461 applicable = bfd_applicable_section_flags (abfd); 2462 2463 /* First make symbols for the sections. */ 2464 for (i = 0; i < NSECS; i++) 2465 { 2466 sinfo *si = secdata + i; 2467 2468 if (si->id != i) 2469 abort (); 2470 si->sec = bfd_make_section_old_way (abfd, si->name); 2471 bfd_set_section_flags (abfd, 2472 si->sec, 2473 si->flags & applicable); 2474 2475 bfd_set_section_alignment(abfd, si->sec, si->align); 2476 si->sec->output_section = si->sec; 2477 si->sym = bfd_make_empty_symbol(abfd); 2478 si->sym->name = si->sec->name; 2479 si->sym->section = si->sec; 2480 si->sym->flags = BSF_LOCAL; 2481 si->sym->value = 0; 2482 ptrs[oidx] = si->sym; 2483 si->sympp = ptrs + oidx; 2484 si->size = 0; 2485 si->data = NULL; 2486 2487 oidx++; 2488 } 2489 2490 if (! exp->data) 2491 { 2492 exp_label = bfd_make_empty_symbol (abfd); 2493 exp_label->name = make_imp_label ("", exp->name); 2494 2495 /* On PowerPC, the function name points to a descriptor in 2496 the rdata section, the first element of which is a 2497 pointer to the code (..function_name), and the second 2498 points to the .toc. */ 2499 #ifdef DLLTOOL_PPC 2500 if (machine == MPPC) 2501 exp_label->section = secdata[RDATA].sec; 2502 else 2503 #endif 2504 exp_label->section = secdata[TEXT].sec; 2505 2506 exp_label->flags = BSF_GLOBAL; 2507 exp_label->value = 0; 2508 2509 #ifdef DLLTOOL_ARM 2510 if (machine == MTHUMB) 2511 bfd_coff_set_symbol_class (abfd, exp_label, C_THUMBEXTFUNC); 2512 #endif 2513 ptrs[oidx++] = exp_label; 2514 } 2515 2516 /* Generate imp symbols with one underscore for Microsoft 2517 compatibility, and with two underscores for backward 2518 compatibility with old versions of cygwin. */ 2519 if (create_compat_implib) 2520 { 2521 iname = bfd_make_empty_symbol (abfd); 2522 iname->name = make_imp_label ("___imp", exp->name); 2523 iname->section = secdata[IDATA5].sec; 2524 iname->flags = BSF_GLOBAL; 2525 iname->value = 0; 2526 } 2527 2528 iname2 = bfd_make_empty_symbol (abfd); 2529 iname2->name = make_imp_label ("__imp_", exp->name); 2530 iname2->section = secdata[IDATA5].sec; 2531 iname2->flags = BSF_GLOBAL; 2532 iname2->value = 0; 2533 2534 iname_lab = bfd_make_empty_symbol (abfd); 2535 2536 iname_lab->name = head_label; 2537 iname_lab->section = bfd_und_section_ptr; 2538 iname_lab->flags = 0; 2539 iname_lab->value = 0; 2540 2541 iname_pp = ptrs + oidx; 2542 if (create_compat_implib) 2543 ptrs[oidx++] = iname; 2544 ptrs[oidx++] = iname2; 2545 2546 iname_lab_pp = ptrs + oidx; 2547 ptrs[oidx++] = iname_lab; 2548 2549 #ifdef DLLTOOL_PPC 2550 /* The symbol referring to the code (.text). */ 2551 { 2552 asymbol *function_name; 2553 2554 function_name = bfd_make_empty_symbol(abfd); 2555 function_name->name = make_label ("..", exp->name); 2556 function_name->section = secdata[TEXT].sec; 2557 function_name->flags = BSF_GLOBAL; 2558 function_name->value = 0; 2559 2560 fn_pp = ptrs + oidx; 2561 ptrs[oidx++] = function_name; 2562 } 2563 2564 /* The .toc symbol. */ 2565 { 2566 asymbol *toc_symbol; 2567 2568 toc_symbol = bfd_make_empty_symbol (abfd); 2569 toc_symbol->name = make_label (".", "toc"); 2570 toc_symbol->section = bfd_und_section_ptr; 2571 toc_symbol->flags = BSF_GLOBAL; 2572 toc_symbol->value = 0; 2573 2574 toc_pp = ptrs + oidx; 2575 ptrs[oidx++] = toc_symbol; 2576 } 2577 #endif 2578 2579 ptrs[oidx] = 0; 2580 2581 for (i = 0; i < NSECS; i++) 2582 { 2583 sinfo *si = secdata + i; 2584 asection *sec = si->sec; 2585 arelent *rel, *rel2 = 0, *rel3 = 0; 2586 arelent **rpp; 2587 2588 switch (i) 2589 { 2590 case TEXT: 2591 if (! exp->data) 2592 { 2593 si->size = HOW_JTAB_SIZE; 2594 si->data = xmalloc (HOW_JTAB_SIZE); 2595 memcpy (si->data, HOW_JTAB, HOW_JTAB_SIZE); 2596 2597 /* Add the reloc into idata$5. */ 2598 rel = xmalloc (sizeof (arelent)); 2599 2600 rpp = xmalloc (sizeof (arelent *) * (delay ? 4 : 2)); 2601 rpp[0] = rel; 2602 rpp[1] = 0; 2603 2604 rel->address = HOW_JTAB_ROFF; 2605 rel->addend = 0; 2606 2607 if (delay) 2608 { 2609 rel2 = xmalloc (sizeof (arelent)); 2610 rpp[1] = rel2; 2611 rel2->address = HOW_JTAB_ROFF2; 2612 rel2->addend = 0; 2613 rel3 = xmalloc (sizeof (arelent)); 2614 rpp[2] = rel3; 2615 rel3->address = HOW_JTAB_ROFF3; 2616 rel3->addend = 0; 2617 rpp[3] = 0; 2618 } 2619 2620 if (machine == MPPC) 2621 { 2622 rel->howto = bfd_reloc_type_lookup (abfd, 2623 BFD_RELOC_16_GOTOFF); 2624 rel->sym_ptr_ptr = iname_pp; 2625 } 2626 else if (machine == MX86) 2627 { 2628 rel->howto = bfd_reloc_type_lookup (abfd, 2629 BFD_RELOC_32_PCREL); 2630 rel->sym_ptr_ptr = iname_pp; 2631 } 2632 else 2633 { 2634 rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_32); 2635 rel->sym_ptr_ptr = secdata[IDATA5].sympp; 2636 } 2637 2638 if (delay) 2639 { 2640 if (machine == MX86) 2641 rel2->howto = bfd_reloc_type_lookup (abfd, 2642 BFD_RELOC_32_PCREL); 2643 else 2644 rel2->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_32); 2645 rel2->sym_ptr_ptr = rel->sym_ptr_ptr; 2646 rel3->howto = bfd_reloc_type_lookup (abfd, 2647 BFD_RELOC_32_PCREL); 2648 rel3->sym_ptr_ptr = iname_lab_pp; 2649 } 2650 2651 sec->orelocation = rpp; 2652 sec->reloc_count = delay ? 3 : 1; 2653 } 2654 break; 2655 2656 case IDATA5: 2657 if (delay) 2658 { 2659 si->size = create_for_pep ? 8 : 4; 2660 si->data = xmalloc (si->size); 2661 sec->reloc_count = 1; 2662 memset (si->data, 0, si->size); 2663 /* Point after jmp [__imp_...] instruction. */ 2664 si->data[0] = 6; 2665 rel = xmalloc (sizeof (arelent)); 2666 rpp = xmalloc (sizeof (arelent *) * 2); 2667 rpp[0] = rel; 2668 rpp[1] = 0; 2669 rel->address = 0; 2670 rel->addend = 0; 2671 if (create_for_pep) 2672 rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_64); 2673 else 2674 rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_32); 2675 rel->sym_ptr_ptr = secdata[TEXT].sympp; 2676 sec->orelocation = rpp; 2677 break; 2678 } 2679 /* else fall through */ 2680 case IDATA4: 2681 /* An idata$4 or idata$5 is one word long, and has an 2682 rva to idata$6. */ 2683 2684 if (create_for_pep) 2685 { 2686 si->data = xmalloc (8); 2687 si->size = 8; 2688 if (exp->noname) 2689 { 2690 si->data[0] = exp->ordinal ; 2691 si->data[1] = exp->ordinal >> 8; 2692 si->data[2] = exp->ordinal >> 16; 2693 si->data[3] = exp->ordinal >> 24; 2694 si->data[4] = 0; 2695 si->data[5] = 0; 2696 si->data[6] = 0; 2697 si->data[7] = 0x80; 2698 } 2699 else 2700 { 2701 sec->reloc_count = 1; 2702 memset (si->data, 0, si->size); 2703 rel = xmalloc (sizeof (arelent)); 2704 rpp = xmalloc (sizeof (arelent *) * 2); 2705 rpp[0] = rel; 2706 rpp[1] = 0; 2707 rel->address = 0; 2708 rel->addend = 0; 2709 rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_RVA); 2710 rel->sym_ptr_ptr = secdata[IDATA6].sympp; 2711 sec->orelocation = rpp; 2712 } 2713 } 2714 else 2715 { 2716 si->data = xmalloc (4); 2717 si->size = 4; 2718 2719 if (exp->noname) 2720 { 2721 si->data[0] = exp->ordinal ; 2722 si->data[1] = exp->ordinal >> 8; 2723 si->data[2] = exp->ordinal >> 16; 2724 si->data[3] = 0x80; 2725 } 2726 else 2727 { 2728 sec->reloc_count = 1; 2729 memset (si->data, 0, si->size); 2730 rel = xmalloc (sizeof (arelent)); 2731 rpp = xmalloc (sizeof (arelent *) * 2); 2732 rpp[0] = rel; 2733 rpp[1] = 0; 2734 rel->address = 0; 2735 rel->addend = 0; 2736 rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_RVA); 2737 rel->sym_ptr_ptr = secdata[IDATA6].sympp; 2738 sec->orelocation = rpp; 2739 } 2740 } 2741 break; 2742 2743 case IDATA6: 2744 if (!exp->noname) 2745 { 2746 /* This used to add 1 to exp->hint. I don't know 2747 why it did that, and it does not match what I see 2748 in programs compiled with the MS tools. */ 2749 int idx = exp->hint; 2750 if (exp->its_name) 2751 si->size = strlen (exp->its_name) + 3; 2752 else 2753 si->size = strlen (xlate (exp->import_name)) + 3; 2754 si->data = xmalloc (si->size); 2755 si->data[0] = idx & 0xff; 2756 si->data[1] = idx >> 8; 2757 if (exp->its_name) 2758 strcpy ((char *) si->data + 2, exp->its_name); 2759 else 2760 strcpy ((char *) si->data + 2, xlate (exp->import_name)); 2761 } 2762 break; 2763 case IDATA7: 2764 if (delay) 2765 break; 2766 si->size = 4; 2767 si->data = xmalloc (4); 2768 memset (si->data, 0, si->size); 2769 rel = xmalloc (sizeof (arelent)); 2770 rpp = xmalloc (sizeof (arelent *) * 2); 2771 rpp[0] = rel; 2772 rel->address = 0; 2773 rel->addend = 0; 2774 rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_RVA); 2775 rel->sym_ptr_ptr = iname_lab_pp; 2776 sec->orelocation = rpp; 2777 sec->reloc_count = 1; 2778 break; 2779 2780 #ifdef DLLTOOL_PPC 2781 case PDATA: 2782 { 2783 /* The .pdata section is 5 words long. 2784 Think of it as: 2785 struct 2786 { 2787 bfd_vma BeginAddress, [0x00] 2788 EndAddress, [0x04] 2789 ExceptionHandler, [0x08] 2790 HandlerData, [0x0c] 2791 PrologEndAddress; [0x10] 2792 }; */ 2793 2794 /* So this pdata section setups up this as a glue linkage to 2795 a dll routine. There are a number of house keeping things 2796 we need to do: 2797 2798 1. In the name of glue trickery, the ADDR32 relocs for 0, 2799 4, and 0x10 are set to point to the same place: 2800 "..function_name". 2801 2. There is one more reloc needed in the pdata section. 2802 The actual glue instruction to restore the toc on 2803 return is saved as the offset in an IMGLUE reloc. 2804 So we need a total of four relocs for this section. 2805 2806 3. Lastly, the HandlerData field is set to 0x03, to indicate 2807 that this is a glue routine. */ 2808 arelent *imglue, *ba_rel, *ea_rel, *pea_rel; 2809 2810 /* Alignment must be set to 2**2 or you get extra stuff. */ 2811 bfd_set_section_alignment(abfd, sec, 2); 2812 2813 si->size = 4 * 5; 2814 si->data = xmalloc (si->size); 2815 memset (si->data, 0, si->size); 2816 rpp = xmalloc (sizeof (arelent *) * 5); 2817 rpp[0] = imglue = xmalloc (sizeof (arelent)); 2818 rpp[1] = ba_rel = xmalloc (sizeof (arelent)); 2819 rpp[2] = ea_rel = xmalloc (sizeof (arelent)); 2820 rpp[3] = pea_rel = xmalloc (sizeof (arelent)); 2821 rpp[4] = 0; 2822 2823 /* Stick the toc reload instruction in the glue reloc. */ 2824 bfd_put_32(abfd, ppc_glue_insn, (char *) &imglue->address); 2825 2826 imglue->addend = 0; 2827 imglue->howto = bfd_reloc_type_lookup (abfd, 2828 BFD_RELOC_32_GOTOFF); 2829 imglue->sym_ptr_ptr = fn_pp; 2830 2831 ba_rel->address = 0; 2832 ba_rel->addend = 0; 2833 ba_rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_32); 2834 ba_rel->sym_ptr_ptr = fn_pp; 2835 2836 bfd_put_32 (abfd, 0x18, si->data + 0x04); 2837 ea_rel->address = 4; 2838 ea_rel->addend = 0; 2839 ea_rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_32); 2840 ea_rel->sym_ptr_ptr = fn_pp; 2841 2842 /* Mark it as glue. */ 2843 bfd_put_32 (abfd, 0x03, si->data + 0x0c); 2844 2845 /* Mark the prolog end address. */ 2846 bfd_put_32 (abfd, 0x0D, si->data + 0x10); 2847 pea_rel->address = 0x10; 2848 pea_rel->addend = 0; 2849 pea_rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_32); 2850 pea_rel->sym_ptr_ptr = fn_pp; 2851 2852 sec->orelocation = rpp; 2853 sec->reloc_count = 4; 2854 break; 2855 } 2856 case RDATA: 2857 /* Each external function in a PowerPC PE file has a two word 2858 descriptor consisting of: 2859 1. The address of the code. 2860 2. The address of the appropriate .toc 2861 We use relocs to build this. */ 2862 si->size = 8; 2863 si->data = xmalloc (8); 2864 memset (si->data, 0, si->size); 2865 2866 rpp = xmalloc (sizeof (arelent *) * 3); 2867 rpp[0] = rel = xmalloc (sizeof (arelent)); 2868 rpp[1] = xmalloc (sizeof (arelent)); 2869 rpp[2] = 0; 2870 2871 rel->address = 0; 2872 rel->addend = 0; 2873 rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_32); 2874 rel->sym_ptr_ptr = fn_pp; 2875 2876 rel = rpp[1]; 2877 2878 rel->address = 4; 2879 rel->addend = 0; 2880 rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_32); 2881 rel->sym_ptr_ptr = toc_pp; 2882 2883 sec->orelocation = rpp; 2884 sec->reloc_count = 2; 2885 break; 2886 #endif /* DLLTOOL_PPC */ 2887 } 2888 } 2889 2890 { 2891 bfd_vma vma = 0; 2892 /* Size up all the sections. */ 2893 for (i = 0; i < NSECS; i++) 2894 { 2895 sinfo *si = secdata + i; 2896 2897 bfd_set_section_size (abfd, si->sec, si->size); 2898 bfd_set_section_vma (abfd, si->sec, vma); 2899 } 2900 } 2901 /* Write them out. */ 2902 for (i = 0; i < NSECS; i++) 2903 { 2904 sinfo *si = secdata + i; 2905 2906 if (i == IDATA5 && no_idata5) 2907 continue; 2908 2909 if (i == IDATA4 && no_idata4) 2910 continue; 2911 2912 bfd_set_section_contents (abfd, si->sec, 2913 si->data, 0, 2914 si->size); 2915 } 2916 2917 bfd_set_symtab (abfd, ptrs, oidx); 2918 bfd_close (abfd); 2919 abfd = bfd_openr (outname, HOW_BFD_READ_TARGET); 2920 if (!abfd) 2921 /* xgettext:c-format */ 2922 fatal (_("bfd_open failed reopen stub file: %s: %s"), 2923 outname, bfd_get_errmsg ()); 2924 2925 return abfd; 2926 } 2927 2928 static bfd * 2929 make_head (void) 2930 { 2931 FILE *f = fopen (TMP_HEAD_S, FOPEN_WT); 2932 bfd *abfd; 2933 2934 if (f == NULL) 2935 { 2936 fatal (_("failed to open temporary head file: %s"), TMP_HEAD_S); 2937 return NULL; 2938 } 2939 2940 fprintf (f, "%s IMAGE_IMPORT_DESCRIPTOR\n", ASM_C); 2941 fprintf (f, "\t.section\t.idata$2\n"); 2942 2943 fprintf (f,"\t%s\t%s\n", ASM_GLOBAL, head_label); 2944 2945 fprintf (f, "%s:\n", head_label); 2946 2947 fprintf (f, "\t%shname%s\t%sPtr to image import by name list\n", 2948 ASM_RVA_BEFORE, ASM_RVA_AFTER, ASM_C); 2949 2950 fprintf (f, "\t%sthis should be the timestamp, but NT sometimes\n", ASM_C); 2951 fprintf (f, "\t%sdoesn't load DLLs when this is set.\n", ASM_C); 2952 fprintf (f, "\t%s\t0\t%s loaded time\n", ASM_LONG, ASM_C); 2953 fprintf (f, "\t%s\t0\t%s Forwarder chain\n", ASM_LONG, ASM_C); 2954 fprintf (f, "\t%s__%s_iname%s\t%s imported dll's name\n", 2955 ASM_RVA_BEFORE, 2956 imp_name_lab, 2957 ASM_RVA_AFTER, 2958 ASM_C); 2959 fprintf (f, "\t%sfthunk%s\t%s pointer to firstthunk\n", 2960 ASM_RVA_BEFORE, 2961 ASM_RVA_AFTER, ASM_C); 2962 2963 fprintf (f, "%sStuff for compatibility\n", ASM_C); 2964 2965 if (!no_idata5) 2966 { 2967 fprintf (f, "\t.section\t.idata$5\n"); 2968 if (use_nul_prefixed_import_tables) 2969 { 2970 if (create_for_pep) 2971 fprintf (f,"\t%s\t0\n\t%s\t0\n", ASM_LONG, ASM_LONG); 2972 else 2973 fprintf (f,"\t%s\t0\n", ASM_LONG); 2974 } 2975 fprintf (f, "fthunk:\n"); 2976 } 2977 2978 if (!no_idata4) 2979 { 2980 fprintf (f, "\t.section\t.idata$4\n"); 2981 if (use_nul_prefixed_import_tables) 2982 { 2983 if (create_for_pep) 2984 fprintf (f,"\t%s\t0\n\t%s\t0\n", ASM_LONG, ASM_LONG); 2985 else 2986 fprintf (f,"\t%s\t0\n", ASM_LONG); 2987 } 2988 fprintf (f, "hname:\n"); 2989 } 2990 2991 fclose (f); 2992 2993 assemble_file (TMP_HEAD_S, TMP_HEAD_O); 2994 2995 abfd = bfd_openr (TMP_HEAD_O, HOW_BFD_READ_TARGET); 2996 if (abfd == NULL) 2997 /* xgettext:c-format */ 2998 fatal (_("failed to open temporary head file: %s: %s"), 2999 TMP_HEAD_O, bfd_get_errmsg ()); 3000 3001 return abfd; 3002 } 3003 3004 bfd * 3005 make_delay_head (void) 3006 { 3007 FILE *f = fopen (TMP_HEAD_S, FOPEN_WT); 3008 bfd *abfd; 3009 3010 if (f == NULL) 3011 { 3012 fatal (_("failed to open temporary head file: %s"), TMP_HEAD_S); 3013 return NULL; 3014 } 3015 3016 /* Output the __tailMerge__xxx function */ 3017 fprintf (f, "%s Import trampoline\n", ASM_C); 3018 fprintf (f, "\t.section\t.text\n"); 3019 fprintf(f,"\t%s\t%s\n", ASM_GLOBAL, head_label); 3020 fprintf (f, "%s:\n", head_label); 3021 fprintf (f, mtable[machine].trampoline, imp_name_lab); 3022 3023 /* Output the delay import descriptor */ 3024 fprintf (f, "\n%s DELAY_IMPORT_DESCRIPTOR\n", ASM_C); 3025 fprintf (f, ".section\t.text$2\n"); 3026 fprintf (f,"%s __DELAY_IMPORT_DESCRIPTOR_%s\n", ASM_GLOBAL,imp_name_lab); 3027 fprintf (f, "__DELAY_IMPORT_DESCRIPTOR_%s:\n", imp_name_lab); 3028 fprintf (f, "\t%s 1\t%s grAttrs\n", ASM_LONG, ASM_C); 3029 fprintf (f, "\t%s__%s_iname%s\t%s rvaDLLName\n", 3030 ASM_RVA_BEFORE, imp_name_lab, ASM_RVA_AFTER, ASM_C); 3031 fprintf (f, "\t%s__DLL_HANDLE_%s%s\t%s rvaHmod\n", 3032 ASM_RVA_BEFORE, imp_name_lab, ASM_RVA_AFTER, ASM_C); 3033 fprintf (f, "\t%s__IAT_%s%s\t%s rvaIAT\n", 3034 ASM_RVA_BEFORE, imp_name_lab, ASM_RVA_AFTER, ASM_C); 3035 fprintf (f, "\t%s__INT_%s%s\t%s rvaINT\n", 3036 ASM_RVA_BEFORE, imp_name_lab, ASM_RVA_AFTER, ASM_C); 3037 fprintf (f, "\t%s\t0\t%s rvaBoundIAT\n", ASM_LONG, ASM_C); 3038 fprintf (f, "\t%s\t0\t%s rvaUnloadIAT\n", ASM_LONG, ASM_C); 3039 fprintf (f, "\t%s\t0\t%s dwTimeStamp\n", ASM_LONG, ASM_C); 3040 3041 /* Output the dll_handle */ 3042 fprintf (f, "\n.section .data\n"); 3043 fprintf (f, "__DLL_HANDLE_%s:\n", imp_name_lab); 3044 fprintf (f, "\t%s\t0\t%s Handle\n", ASM_LONG, ASM_C); 3045 if (create_for_pep) 3046 fprintf (f, "\t%s\t0\n", ASM_LONG); 3047 fprintf (f, "\n"); 3048 3049 fprintf (f, "%sStuff for compatibility\n", ASM_C); 3050 3051 if (!no_idata5) 3052 { 3053 fprintf (f, "\t.section\t.idata$5\n"); 3054 /* NULL terminating list. */ 3055 if (create_for_pep) 3056 fprintf (f,"\t%s\t0\n\t%s\t0\n", ASM_LONG, ASM_LONG); 3057 else 3058 fprintf (f,"\t%s\t0\n", ASM_LONG); 3059 fprintf (f, "__IAT_%s:\n", imp_name_lab); 3060 } 3061 3062 if (!no_idata4) 3063 { 3064 fprintf (f, "\t.section\t.idata$4\n"); 3065 fprintf (f, "\t%s\t0\n", ASM_LONG); 3066 if (create_for_pep) 3067 fprintf (f, "\t%s\t0\n", ASM_LONG); 3068 fprintf (f, "\t.section\t.idata$4\n"); 3069 fprintf (f, "__INT_%s:\n", imp_name_lab); 3070 } 3071 3072 fprintf (f, "\t.section\t.idata$2\n"); 3073 3074 fclose (f); 3075 3076 assemble_file (TMP_HEAD_S, TMP_HEAD_O); 3077 3078 abfd = bfd_openr (TMP_HEAD_O, HOW_BFD_READ_TARGET); 3079 if (abfd == NULL) 3080 /* xgettext:c-format */ 3081 fatal (_("failed to open temporary head file: %s: %s"), 3082 TMP_HEAD_O, bfd_get_errmsg ()); 3083 3084 return abfd; 3085 } 3086 3087 static bfd * 3088 make_tail (void) 3089 { 3090 FILE *f = fopen (TMP_TAIL_S, FOPEN_WT); 3091 bfd *abfd; 3092 3093 if (f == NULL) 3094 { 3095 fatal (_("failed to open temporary tail file: %s"), TMP_TAIL_S); 3096 return NULL; 3097 } 3098 3099 if (!no_idata4) 3100 { 3101 fprintf (f, "\t.section\t.idata$4\n"); 3102 if (create_for_pep) 3103 fprintf (f,"\t%s\t0\n\t%s\t0\n", ASM_LONG, ASM_LONG); 3104 else 3105 fprintf (f,"\t%s\t0\n", ASM_LONG); /* NULL terminating list. */ 3106 } 3107 3108 if (!no_idata5) 3109 { 3110 fprintf (f, "\t.section\t.idata$5\n"); 3111 if (create_for_pep) 3112 fprintf (f,"\t%s\t0\n\t%s\t0\n", ASM_LONG, ASM_LONG); 3113 else 3114 fprintf (f,"\t%s\t0\n", ASM_LONG); /* NULL terminating list. */ 3115 } 3116 3117 #ifdef DLLTOOL_PPC 3118 /* Normally, we need to see a null descriptor built in idata$3 to 3119 act as the terminator for the list. The ideal way, I suppose, 3120 would be to mark this section as a comdat type 2 section, so 3121 only one would appear in the final .exe (if our linker supported 3122 comdat, that is) or cause it to be inserted by something else (say 3123 crt0). */ 3124 3125 fprintf (f, "\t.section\t.idata$3\n"); 3126 fprintf (f, "\t%s\t0\n", ASM_LONG); 3127 fprintf (f, "\t%s\t0\n", ASM_LONG); 3128 fprintf (f, "\t%s\t0\n", ASM_LONG); 3129 fprintf (f, "\t%s\t0\n", ASM_LONG); 3130 fprintf (f, "\t%s\t0\n", ASM_LONG); 3131 #endif 3132 3133 #ifdef DLLTOOL_PPC 3134 /* Other PowerPC NT compilers use idata$6 for the dllname, so I 3135 do too. Original, huh? */ 3136 fprintf (f, "\t.section\t.idata$6\n"); 3137 #else 3138 fprintf (f, "\t.section\t.idata$7\n"); 3139 #endif 3140 3141 fprintf (f, "\t%s\t__%s_iname\n", ASM_GLOBAL, imp_name_lab); 3142 fprintf (f, "__%s_iname:\t%s\t\"%s\"\n", 3143 imp_name_lab, ASM_TEXT, dll_name); 3144 3145 fclose (f); 3146 3147 assemble_file (TMP_TAIL_S, TMP_TAIL_O); 3148 3149 abfd = bfd_openr (TMP_TAIL_O, HOW_BFD_READ_TARGET); 3150 if (abfd == NULL) 3151 /* xgettext:c-format */ 3152 fatal (_("failed to open temporary tail file: %s: %s"), 3153 TMP_TAIL_O, bfd_get_errmsg ()); 3154 3155 return abfd; 3156 } 3157 3158 static void 3159 gen_lib_file (int delay) 3160 { 3161 int i; 3162 export_type *exp; 3163 bfd *ar_head; 3164 bfd *ar_tail; 3165 bfd *outarch; 3166 bfd * head = 0; 3167 3168 unlink (imp_name); 3169 3170 outarch = bfd_openw (imp_name, HOW_BFD_WRITE_TARGET); 3171 3172 if (!outarch) 3173 /* xgettext:c-format */ 3174 fatal (_("Can't create .lib file: %s: %s"), 3175 imp_name, bfd_get_errmsg ()); 3176 3177 /* xgettext:c-format */ 3178 inform (_("Creating library file: %s"), imp_name); 3179 3180 bfd_set_format (outarch, bfd_archive); 3181 outarch->has_armap = 1; 3182 outarch->is_thin_archive = 0; 3183 3184 /* Work out a reasonable size of things to put onto one line. */ 3185 if (delay) 3186 { 3187 ar_head = make_delay_head (); 3188 } 3189 else 3190 { 3191 ar_head = make_head (); 3192 } 3193 ar_tail = make_tail(); 3194 3195 if (ar_head == NULL || ar_tail == NULL) 3196 return; 3197 3198 for (i = 0; (exp = d_exports_lexically[i]); i++) 3199 { 3200 bfd *n; 3201 /* Don't add PRIVATE entries to import lib. */ 3202 if (exp->private) 3203 continue; 3204 n = make_one_lib_file (exp, i, delay); 3205 n->archive_next = head; 3206 head = n; 3207 if (ext_prefix_alias) 3208 { 3209 export_type alias_exp; 3210 3211 assert (i < PREFIX_ALIAS_BASE); 3212 alias_exp.name = make_imp_label (ext_prefix_alias, exp->name); 3213 alias_exp.internal_name = exp->internal_name; 3214 alias_exp.its_name = exp->its_name; 3215 alias_exp.import_name = exp->name; 3216 alias_exp.ordinal = exp->ordinal; 3217 alias_exp.constant = exp->constant; 3218 alias_exp.noname = exp->noname; 3219 alias_exp.private = exp->private; 3220 alias_exp.data = exp->data; 3221 alias_exp.hint = exp->hint; 3222 alias_exp.forward = exp->forward; 3223 alias_exp.next = exp->next; 3224 n = make_one_lib_file (&alias_exp, i + PREFIX_ALIAS_BASE, delay); 3225 n->archive_next = head; 3226 head = n; 3227 } 3228 } 3229 3230 /* Now stick them all into the archive. */ 3231 ar_head->archive_next = head; 3232 ar_tail->archive_next = ar_head; 3233 head = ar_tail; 3234 3235 if (! bfd_set_archive_head (outarch, head)) 3236 bfd_fatal ("bfd_set_archive_head"); 3237 3238 if (! bfd_close (outarch)) 3239 bfd_fatal (imp_name); 3240 3241 while (head != NULL) 3242 { 3243 bfd *n = head->archive_next; 3244 bfd_close (head); 3245 head = n; 3246 } 3247 3248 /* Delete all the temp files. */ 3249 if (dontdeltemps == 0) 3250 { 3251 unlink (TMP_HEAD_O); 3252 unlink (TMP_HEAD_S); 3253 unlink (TMP_TAIL_O); 3254 unlink (TMP_TAIL_S); 3255 } 3256 3257 if (dontdeltemps < 2) 3258 { 3259 char *name; 3260 3261 name = (char *) alloca (strlen (TMP_STUB) + 10); 3262 for (i = 0; (exp = d_exports_lexically[i]); i++) 3263 { 3264 /* Don't delete non-existent stubs for PRIVATE entries. */ 3265 if (exp->private) 3266 continue; 3267 sprintf (name, "%s%05d.o", TMP_STUB, i); 3268 if (unlink (name) < 0) 3269 /* xgettext:c-format */ 3270 non_fatal (_("cannot delete %s: %s"), name, strerror (errno)); 3271 if (ext_prefix_alias) 3272 { 3273 sprintf (name, "%s%05d.o", TMP_STUB, i + PREFIX_ALIAS_BASE); 3274 if (unlink (name) < 0) 3275 /* xgettext:c-format */ 3276 non_fatal (_("cannot delete %s: %s"), name, strerror (errno)); 3277 } 3278 } 3279 } 3280 3281 inform (_("Created lib file")); 3282 } 3283 3284 /* Append a copy of data (cast to char *) to list. */ 3285 3286 static void 3287 dll_name_list_append (dll_name_list_type * list, bfd_byte * data) 3288 { 3289 dll_name_list_node_type * entry; 3290 3291 /* Error checking. */ 3292 if (! list || ! list->tail) 3293 return; 3294 3295 /* Allocate new node. */ 3296 entry = ((dll_name_list_node_type *) 3297 xmalloc (sizeof (dll_name_list_node_type))); 3298 3299 /* Initialize its values. */ 3300 entry->dllname = xstrdup ((char *) data); 3301 entry->next = NULL; 3302 3303 /* Add to tail, and move tail. */ 3304 list->tail->next = entry; 3305 list->tail = entry; 3306 } 3307 3308 /* Count the number of entries in list. */ 3309 3310 static int 3311 dll_name_list_count (dll_name_list_type * list) 3312 { 3313 dll_name_list_node_type * p; 3314 int count = 0; 3315 3316 /* Error checking. */ 3317 if (! list || ! list->head) 3318 return 0; 3319 3320 p = list->head; 3321 3322 while (p && p->next) 3323 { 3324 count++; 3325 p = p->next; 3326 } 3327 return count; 3328 } 3329 3330 /* Print each entry in list to stdout. */ 3331 3332 static void 3333 dll_name_list_print (dll_name_list_type * list) 3334 { 3335 dll_name_list_node_type * p; 3336 3337 /* Error checking. */ 3338 if (! list || ! list->head) 3339 return; 3340 3341 p = list->head; 3342 3343 while (p && p->next && p->next->dllname && *(p->next->dllname)) 3344 { 3345 printf ("%s\n", p->next->dllname); 3346 p = p->next; 3347 } 3348 } 3349 3350 /* Free all entries in list, and list itself. */ 3351 3352 static void 3353 dll_name_list_free (dll_name_list_type * list) 3354 { 3355 if (list) 3356 { 3357 dll_name_list_free_contents (list->head); 3358 list->head = NULL; 3359 list->tail = NULL; 3360 free (list); 3361 } 3362 } 3363 3364 /* Recursive function to free all nodes entry->next->next... 3365 as well as entry itself. */ 3366 3367 static void 3368 dll_name_list_free_contents (dll_name_list_node_type * entry) 3369 { 3370 if (entry) 3371 { 3372 if (entry->next) 3373 { 3374 dll_name_list_free_contents (entry->next); 3375 entry->next = NULL; 3376 } 3377 if (entry->dllname) 3378 { 3379 free (entry->dllname); 3380 entry->dllname = NULL; 3381 } 3382 free (entry); 3383 } 3384 } 3385 3386 /* Allocate and initialize a dll_name_list_type object, 3387 including its sentinel node. Caller is responsible 3388 for calling dll_name_list_free when finished with 3389 the list. */ 3390 3391 static dll_name_list_type * 3392 dll_name_list_create (void) 3393 { 3394 /* Allocate list. */ 3395 dll_name_list_type * list = xmalloc (sizeof (dll_name_list_type)); 3396 3397 /* Allocate and initialize sentinel node. */ 3398 list->head = xmalloc (sizeof (dll_name_list_node_type)); 3399 list->head->dllname = NULL; 3400 list->head->next = NULL; 3401 3402 /* Bookkeeping for empty list. */ 3403 list->tail = list->head; 3404 3405 return list; 3406 } 3407 3408 /* Search the symbol table of the suppled BFD for a symbol whose name matches 3409 OBJ (where obj is cast to const char *). If found, set global variable 3410 identify_member_contains_symname_result TRUE. It is the caller's 3411 responsibility to set the result variable FALSE before iterating with 3412 this function. */ 3413 3414 static void 3415 identify_member_contains_symname (bfd * abfd, 3416 bfd * archive_bfd ATTRIBUTE_UNUSED, 3417 void * obj) 3418 { 3419 long storage_needed; 3420 asymbol ** symbol_table; 3421 long number_of_symbols; 3422 long i; 3423 symname_search_data_type * search_data = (symname_search_data_type *) obj; 3424 3425 /* If we already found the symbol in a different member, 3426 short circuit. */ 3427 if (search_data->found) 3428 return; 3429 3430 storage_needed = bfd_get_symtab_upper_bound (abfd); 3431 if (storage_needed <= 0) 3432 return; 3433 3434 symbol_table = xmalloc (storage_needed); 3435 number_of_symbols = bfd_canonicalize_symtab (abfd, symbol_table); 3436 if (number_of_symbols < 0) 3437 { 3438 free (symbol_table); 3439 return; 3440 } 3441 3442 for (i = 0; i < number_of_symbols; i++) 3443 { 3444 if (strncmp (symbol_table[i]->name, 3445 search_data->symname, 3446 strlen (search_data->symname)) == 0) 3447 { 3448 search_data->found = TRUE; 3449 break; 3450 } 3451 } 3452 free (symbol_table); 3453 } 3454 3455 /* This is the main implementation for the --identify option. 3456 Given the name of an import library in identify_imp_name, first determine 3457 if the import library is a GNU binutils-style one (where the DLL name is 3458 stored in an .idata$7 (.idata$6 on PPC) section, or if it is a MS-style 3459 one (where the DLL name, along with much other data, is stored in the 3460 .idata$6 section). We determine the style of import library by searching 3461 for the DLL-structure symbol inserted by MS tools: 3462 __NULL_IMPORT_DESCRIPTOR. 3463 3464 Once we know which section to search, evaluate each section for the 3465 appropriate properties that indicate it may contain the name of the 3466 associated DLL (this differs depending on the style). Add the contents 3467 of all sections which meet the criteria to a linked list of dll names. 3468 3469 Finally, print them all to stdout. (If --identify-strict, an error is 3470 reported if more than one match was found). */ 3471 3472 static void 3473 identify_dll_for_implib (void) 3474 { 3475 bfd * abfd = NULL; 3476 int count = 0; 3477 identify_data_type identify_data; 3478 symname_search_data_type search_data; 3479 3480 /* Initialize identify_data. */ 3481 identify_data.list = dll_name_list_create (); 3482 identify_data.ms_style_implib = FALSE; 3483 3484 /* Initialize search_data. */ 3485 search_data.symname = "__NULL_IMPORT_DESCRIPTOR"; 3486 search_data.found = FALSE; 3487 3488 bfd_init (); 3489 3490 abfd = bfd_openr (identify_imp_name, 0); 3491 if (abfd == NULL) 3492 /* xgettext:c-format */ 3493 fatal (_("Can't open .lib file: %s: %s"), 3494 identify_imp_name, bfd_get_errmsg ()); 3495 3496 if (! bfd_check_format (abfd, bfd_archive)) 3497 { 3498 if (! bfd_close (abfd)) 3499 bfd_fatal (identify_imp_name); 3500 3501 fatal (_("%s is not a library"), identify_imp_name); 3502 } 3503 3504 /* Detect if this a Microsoft import library. */ 3505 identify_search_archive (abfd, 3506 identify_member_contains_symname, 3507 (void *)(& search_data)); 3508 if (search_data.found) 3509 identify_data.ms_style_implib = TRUE; 3510 3511 /* Rewind the bfd. */ 3512 if (! bfd_close (abfd)) 3513 bfd_fatal (identify_imp_name); 3514 abfd = bfd_openr (identify_imp_name, 0); 3515 if (abfd == NULL) 3516 bfd_fatal (identify_imp_name); 3517 3518 if (!bfd_check_format (abfd, bfd_archive)) 3519 { 3520 if (!bfd_close (abfd)) 3521 bfd_fatal (identify_imp_name); 3522 3523 fatal (_("%s is not a library"), identify_imp_name); 3524 } 3525 3526 /* Now search for the dll name. */ 3527 identify_search_archive (abfd, 3528 identify_search_member, 3529 (void *)(& identify_data)); 3530 3531 if (! bfd_close (abfd)) 3532 bfd_fatal (identify_imp_name); 3533 3534 count = dll_name_list_count (identify_data.list); 3535 if (count > 0) 3536 { 3537 if (identify_strict && count > 1) 3538 { 3539 dll_name_list_free (identify_data.list); 3540 identify_data.list = NULL; 3541 fatal (_("Import library `%s' specifies two or more dlls"), 3542 identify_imp_name); 3543 } 3544 dll_name_list_print (identify_data.list); 3545 dll_name_list_free (identify_data.list); 3546 identify_data.list = NULL; 3547 } 3548 else 3549 { 3550 dll_name_list_free (identify_data.list); 3551 identify_data.list = NULL; 3552 fatal (_("Unable to determine dll name for `%s' (not an import library?)"), 3553 identify_imp_name); 3554 } 3555 } 3556 3557 /* Loop over all members of the archive, applying the supplied function to 3558 each member that is a bfd_object. The function will be called as if: 3559 func (member_bfd, abfd, user_storage) */ 3560 3561 static void 3562 identify_search_archive (bfd * abfd, 3563 void (* operation) (bfd *, bfd *, void *), 3564 void * user_storage) 3565 { 3566 bfd * arfile = NULL; 3567 bfd * last_arfile = NULL; 3568 char ** matching; 3569 3570 while (1) 3571 { 3572 arfile = bfd_openr_next_archived_file (abfd, arfile); 3573 3574 if (arfile == NULL) 3575 { 3576 if (bfd_get_error () != bfd_error_no_more_archived_files) 3577 bfd_fatal (bfd_get_filename (abfd)); 3578 break; 3579 } 3580 3581 if (bfd_check_format_matches (arfile, bfd_object, &matching)) 3582 (*operation) (arfile, abfd, user_storage); 3583 else 3584 { 3585 bfd_nonfatal (bfd_get_filename (arfile)); 3586 free (matching); 3587 } 3588 3589 if (last_arfile != NULL) 3590 bfd_close (last_arfile); 3591 3592 last_arfile = arfile; 3593 } 3594 3595 if (last_arfile != NULL) 3596 { 3597 bfd_close (last_arfile); 3598 } 3599 } 3600 3601 /* Call the identify_search_section() function for each section of this 3602 archive member. */ 3603 3604 static void 3605 identify_search_member (bfd *abfd, 3606 bfd *archive_bfd ATTRIBUTE_UNUSED, 3607 void *obj) 3608 { 3609 bfd_map_over_sections (abfd, identify_search_section, obj); 3610 } 3611 3612 /* This predicate returns true if section->name matches the desired value. 3613 By default, this is .idata$7 (.idata$6 on PPC, or if the import 3614 library is ms-style). */ 3615 3616 static bfd_boolean 3617 identify_process_section_p (asection * section, bfd_boolean ms_style_implib) 3618 { 3619 static const char * SECTION_NAME = 3620 #ifdef DLLTOOL_PPC 3621 /* dllname is stored in idata$6 on PPC */ 3622 ".idata$6"; 3623 #else 3624 ".idata$7"; 3625 #endif 3626 static const char * MS_SECTION_NAME = ".idata$6"; 3627 3628 const char * section_name = 3629 (ms_style_implib ? MS_SECTION_NAME : SECTION_NAME); 3630 3631 if (strcmp (section_name, section->name) == 0) 3632 return TRUE; 3633 return FALSE; 3634 } 3635 3636 /* If *section has contents and its name is .idata$7 (.data$6 on PPC or if 3637 import lib ms-generated) -- and it satisfies several other constraints 3638 -- then add the contents of the section to obj->list. */ 3639 3640 static void 3641 identify_search_section (bfd * abfd, asection * section, void * obj) 3642 { 3643 bfd_byte *data = 0; 3644 bfd_size_type datasize; 3645 identify_data_type * identify_data = (identify_data_type *)obj; 3646 bfd_boolean ms_style = identify_data->ms_style_implib; 3647 3648 if ((section->flags & SEC_HAS_CONTENTS) == 0) 3649 return; 3650 3651 if (! identify_process_section_p (section, ms_style)) 3652 return; 3653 3654 /* Binutils import libs seem distinguish the .idata$7 section that contains 3655 the DLL name from other .idata$7 sections by the absence of the 3656 SEC_RELOC flag. */ 3657 if (!ms_style && ((section->flags & SEC_RELOC) == SEC_RELOC)) 3658 return; 3659 3660 /* MS import libs seem to distinguish the .idata$6 section 3661 that contains the DLL name from other .idata$6 sections 3662 by the presence of the SEC_DATA flag. */ 3663 if (ms_style && ((section->flags & SEC_DATA) == 0)) 3664 return; 3665 3666 if ((datasize = bfd_section_size (abfd, section)) == 0) 3667 return; 3668 3669 data = (bfd_byte *) xmalloc (datasize + 1); 3670 data[0] = '\0'; 3671 3672 bfd_get_section_contents (abfd, section, data, 0, datasize); 3673 data[datasize] = '\0'; 3674 3675 /* Use a heuristic to determine if data is a dll name. 3676 Possible to defeat this if (a) the library has MANY 3677 (more than 0x302f) imports, (b) it is an ms-style 3678 import library, but (c) it is buggy, in that the SEC_DATA 3679 flag is set on the "wrong" sections. This heuristic might 3680 also fail to record a valid dll name if the dllname uses 3681 a multibyte or unicode character set (is that valid?). 3682 3683 This heuristic is based on the fact that symbols names in 3684 the chosen section -- as opposed to the dll name -- begin 3685 at offset 2 in the data. The first two bytes are a 16bit 3686 little-endian count, and start at 0x0000. However, the dll 3687 name begins at offset 0 in the data. We assume that the 3688 dll name does not contain unprintable characters. */ 3689 if (data[0] != '\0' && ISPRINT (data[0]) 3690 && ((datasize < 2) || ISPRINT (data[1]))) 3691 dll_name_list_append (identify_data->list, data); 3692 3693 free (data); 3694 } 3695 3696 /* Run through the information gathered from the .o files and the 3697 .def file and work out the best stuff. */ 3698 3699 static int 3700 pfunc (const void *a, const void *b) 3701 { 3702 export_type *ap = *(export_type **) a; 3703 export_type *bp = *(export_type **) b; 3704 3705 if (ap->ordinal == bp->ordinal) 3706 return 0; 3707 3708 /* Unset ordinals go to the bottom. */ 3709 if (ap->ordinal == -1) 3710 return 1; 3711 if (bp->ordinal == -1) 3712 return -1; 3713 return (ap->ordinal - bp->ordinal); 3714 } 3715 3716 static int 3717 nfunc (const void *a, const void *b) 3718 { 3719 export_type *ap = *(export_type **) a; 3720 export_type *bp = *(export_type **) b; 3721 const char *an = ap->name; 3722 const char *bn = bp->name; 3723 if (ap->its_name) 3724 an = ap->its_name; 3725 if (bp->its_name) 3726 an = bp->its_name; 3727 if (killat) 3728 { 3729 an = (an[0] == '@') ? an + 1 : an; 3730 bn = (bn[0] == '@') ? bn + 1 : bn; 3731 } 3732 3733 return (strcmp (an, bn)); 3734 } 3735 3736 static void 3737 remove_null_names (export_type **ptr) 3738 { 3739 int src; 3740 int dst; 3741 3742 for (dst = src = 0; src < d_nfuncs; src++) 3743 { 3744 if (ptr[src]) 3745 { 3746 ptr[dst] = ptr[src]; 3747 dst++; 3748 } 3749 } 3750 d_nfuncs = dst; 3751 } 3752 3753 static void 3754 process_duplicates (export_type **d_export_vec) 3755 { 3756 int more = 1; 3757 int i; 3758 3759 while (more) 3760 { 3761 more = 0; 3762 /* Remove duplicates. */ 3763 qsort (d_export_vec, d_nfuncs, sizeof (export_type *), nfunc); 3764 3765 for (i = 0; i < d_nfuncs - 1; i++) 3766 { 3767 if (strcmp (d_export_vec[i]->name, 3768 d_export_vec[i + 1]->name) == 0) 3769 { 3770 export_type *a = d_export_vec[i]; 3771 export_type *b = d_export_vec[i + 1]; 3772 3773 more = 1; 3774 3775 /* xgettext:c-format */ 3776 inform (_("Warning, ignoring duplicate EXPORT %s %d,%d"), 3777 a->name, a->ordinal, b->ordinal); 3778 3779 if (a->ordinal != -1 3780 && b->ordinal != -1) 3781 /* xgettext:c-format */ 3782 fatal (_("Error, duplicate EXPORT with ordinals: %s"), 3783 a->name); 3784 3785 /* Merge attributes. */ 3786 b->ordinal = a->ordinal > 0 ? a->ordinal : b->ordinal; 3787 b->constant |= a->constant; 3788 b->noname |= a->noname; 3789 b->data |= a->data; 3790 d_export_vec[i] = 0; 3791 } 3792 3793 remove_null_names (d_export_vec); 3794 } 3795 } 3796 3797 /* Count the names. */ 3798 for (i = 0; i < d_nfuncs; i++) 3799 if (!d_export_vec[i]->noname) 3800 d_named_nfuncs++; 3801 } 3802 3803 static void 3804 fill_ordinals (export_type **d_export_vec) 3805 { 3806 int lowest = -1; 3807 int i; 3808 char *ptr; 3809 int size = 65536; 3810 3811 qsort (d_export_vec, d_nfuncs, sizeof (export_type *), pfunc); 3812 3813 /* Fill in the unset ordinals with ones from our range. */ 3814 ptr = (char *) xmalloc (size); 3815 3816 memset (ptr, 0, size); 3817 3818 /* Mark in our large vector all the numbers that are taken. */ 3819 for (i = 0; i < d_nfuncs; i++) 3820 { 3821 if (d_export_vec[i]->ordinal != -1) 3822 { 3823 ptr[d_export_vec[i]->ordinal] = 1; 3824 3825 if (lowest == -1 || d_export_vec[i]->ordinal < lowest) 3826 lowest = d_export_vec[i]->ordinal; 3827 } 3828 } 3829 3830 /* Start at 1 for compatibility with MS toolchain. */ 3831 if (lowest == -1) 3832 lowest = 1; 3833 3834 /* Now fill in ordinals where the user wants us to choose. */ 3835 for (i = 0; i < d_nfuncs; i++) 3836 { 3837 if (d_export_vec[i]->ordinal == -1) 3838 { 3839 int j; 3840 3841 /* First try within or after any user supplied range. */ 3842 for (j = lowest; j < size; j++) 3843 if (ptr[j] == 0) 3844 { 3845 ptr[j] = 1; 3846 d_export_vec[i]->ordinal = j; 3847 goto done; 3848 } 3849 3850 /* Then try before the range. */ 3851 for (j = lowest; j >0; j--) 3852 if (ptr[j] == 0) 3853 { 3854 ptr[j] = 1; 3855 d_export_vec[i]->ordinal = j; 3856 goto done; 3857 } 3858 done:; 3859 } 3860 } 3861 3862 free (ptr); 3863 3864 /* And resort. */ 3865 qsort (d_export_vec, d_nfuncs, sizeof (export_type *), pfunc); 3866 3867 /* Work out the lowest and highest ordinal numbers. */ 3868 if (d_nfuncs) 3869 { 3870 if (d_export_vec[0]) 3871 d_low_ord = d_export_vec[0]->ordinal; 3872 if (d_export_vec[d_nfuncs-1]) 3873 d_high_ord = d_export_vec[d_nfuncs-1]->ordinal; 3874 } 3875 } 3876 3877 static void 3878 mangle_defs (void) 3879 { 3880 /* First work out the minimum ordinal chosen. */ 3881 export_type *exp; 3882 3883 int i; 3884 int hint = 0; 3885 export_type **d_export_vec = xmalloc (sizeof (export_type *) * d_nfuncs); 3886 3887 inform (_("Processing definitions")); 3888 3889 for (i = 0, exp = d_exports; exp; i++, exp = exp->next) 3890 d_export_vec[i] = exp; 3891 3892 process_duplicates (d_export_vec); 3893 fill_ordinals (d_export_vec); 3894 3895 /* Put back the list in the new order. */ 3896 d_exports = 0; 3897 for (i = d_nfuncs - 1; i >= 0; i--) 3898 { 3899 d_export_vec[i]->next = d_exports; 3900 d_exports = d_export_vec[i]; 3901 } 3902 3903 /* Build list in alpha order. */ 3904 d_exports_lexically = (export_type **) 3905 xmalloc (sizeof (export_type *) * (d_nfuncs + 1)); 3906 3907 for (i = 0, exp = d_exports; exp; i++, exp = exp->next) 3908 d_exports_lexically[i] = exp; 3909 3910 d_exports_lexically[i] = 0; 3911 3912 qsort (d_exports_lexically, i, sizeof (export_type *), nfunc); 3913 3914 /* Fill exp entries with their hint values. */ 3915 for (i = 0; i < d_nfuncs; i++) 3916 if (!d_exports_lexically[i]->noname || show_allnames) 3917 d_exports_lexically[i]->hint = hint++; 3918 3919 inform (_("Processed definitions")); 3920 } 3921 3922 static void 3923 usage (FILE *file, int status) 3924 { 3925 /* xgetext:c-format */ 3926 fprintf (file, _("Usage %s <option(s)> <object-file(s)>\n"), program_name); 3927 /* xgetext:c-format */ 3928 fprintf (file, _(" -m --machine <machine> Create as DLL for <machine>. [default: %s]\n"), mname); 3929 fprintf (file, _(" possible <machine>: arm[_interwork], i386, mcore[-elf]{-le|-be}, ppc, thumb\n")); 3930 fprintf (file, _(" -e --output-exp <outname> Generate an export file.\n")); 3931 fprintf (file, _(" -l --output-lib <outname> Generate an interface library.\n")); 3932 fprintf (file, _(" -y --output-delaylib <outname> Create a delay-import library.\n")); 3933 fprintf (file, _(" -a --add-indirect Add dll indirects to export file.\n")); 3934 fprintf (file, _(" -D --dllname <name> Name of input dll to put into interface lib.\n")); 3935 fprintf (file, _(" -d --input-def <deffile> Name of .def file to be read in.\n")); 3936 fprintf (file, _(" -z --output-def <deffile> Name of .def file to be created.\n")); 3937 fprintf (file, _(" --export-all-symbols Export all symbols to .def\n")); 3938 fprintf (file, _(" --no-export-all-symbols Only export listed symbols\n")); 3939 fprintf (file, _(" --exclude-symbols <list> Don't export <list>\n")); 3940 fprintf (file, _(" --no-default-excludes Clear default exclude symbols\n")); 3941 fprintf (file, _(" -b --base-file <basefile> Read linker generated base file.\n")); 3942 fprintf (file, _(" -x --no-idata4 Don't generate idata$4 section.\n")); 3943 fprintf (file, _(" -c --no-idata5 Don't generate idata$5 section.\n")); 3944 fprintf (file, _(" --use-nul-prefixed-import-tables Use zero prefixed idata$4 and idata$5.\n")); 3945 fprintf (file, _(" -U --add-underscore Add underscores to all symbols in interface library.\n")); 3946 fprintf (file, _(" --add-stdcall-underscore Add underscores to stdcall symbols in interface library.\n")); 3947 fprintf (file, _(" --no-leading-underscore All symbols shouldn't be prefixed by an underscore.\n")); 3948 fprintf (file, _(" --leading-underscore All symbols should be prefixed by an underscore.\n")); 3949 fprintf (file, _(" -k --kill-at Kill @<n> from exported names.\n")); 3950 fprintf (file, _(" -A --add-stdcall-alias Add aliases without @<n>.\n")); 3951 fprintf (file, _(" -p --ext-prefix-alias <prefix> Add aliases with <prefix>.\n")); 3952 fprintf (file, _(" -S --as <name> Use <name> for assembler.\n")); 3953 fprintf (file, _(" -f --as-flags <flags> Pass <flags> to the assembler.\n")); 3954 fprintf (file, _(" -C --compat-implib Create backward compatible import library.\n")); 3955 fprintf (file, _(" -n --no-delete Keep temp files (repeat for extra preservation).\n")); 3956 fprintf (file, _(" -t --temp-prefix <prefix> Use <prefix> to construct temp file names.\n")); 3957 fprintf (file, _(" -I --identify <implib> Report the name of the DLL associated with <implib>.\n")); 3958 fprintf (file, _(" --identify-strict Causes --identify to report error when multiple DLLs.\n")); 3959 fprintf (file, _(" -v --verbose Be verbose.\n")); 3960 fprintf (file, _(" -V --version Display the program version.\n")); 3961 fprintf (file, _(" -h --help Display this information.\n")); 3962 fprintf (file, _(" @<file> Read options from <file>.\n")); 3963 #ifdef DLLTOOL_MCORE_ELF 3964 fprintf (file, _(" -M --mcore-elf <outname> Process mcore-elf object files into <outname>.\n")); 3965 fprintf (file, _(" -L --linker <name> Use <name> as the linker.\n")); 3966 fprintf (file, _(" -F --linker-flags <flags> Pass <flags> to the linker.\n")); 3967 #endif 3968 if (REPORT_BUGS_TO[0] && status == 0) 3969 fprintf (file, _("Report bugs to %s\n"), REPORT_BUGS_TO); 3970 exit (status); 3971 } 3972 3973 #define OPTION_EXPORT_ALL_SYMS 150 3974 #define OPTION_NO_EXPORT_ALL_SYMS (OPTION_EXPORT_ALL_SYMS + 1) 3975 #define OPTION_EXCLUDE_SYMS (OPTION_NO_EXPORT_ALL_SYMS + 1) 3976 #define OPTION_NO_DEFAULT_EXCLUDES (OPTION_EXCLUDE_SYMS + 1) 3977 #define OPTION_ADD_STDCALL_UNDERSCORE (OPTION_NO_DEFAULT_EXCLUDES + 1) 3978 #define OPTION_USE_NUL_PREFIXED_IMPORT_TABLES \ 3979 (OPTION_ADD_STDCALL_UNDERSCORE + 1) 3980 #define OPTION_IDENTIFY_STRICT (OPTION_USE_NUL_PREFIXED_IMPORT_TABLES + 1) 3981 #define OPTION_NO_LEADING_UNDERSCORE (OPTION_IDENTIFY_STRICT + 1) 3982 #define OPTION_LEADING_UNDERSCORE (OPTION_NO_LEADING_UNDERSCORE + 1) 3983 3984 static const struct option long_options[] = 3985 { 3986 {"no-delete", no_argument, NULL, 'n'}, 3987 {"dllname", required_argument, NULL, 'D'}, 3988 {"no-idata4", no_argument, NULL, 'x'}, 3989 {"no-idata5", no_argument, NULL, 'c'}, 3990 {"use-nul-prefixed-import-tables", no_argument, NULL, 3991 OPTION_USE_NUL_PREFIXED_IMPORT_TABLES}, 3992 {"output-exp", required_argument, NULL, 'e'}, 3993 {"output-def", required_argument, NULL, 'z'}, 3994 {"export-all-symbols", no_argument, NULL, OPTION_EXPORT_ALL_SYMS}, 3995 {"no-export-all-symbols", no_argument, NULL, OPTION_NO_EXPORT_ALL_SYMS}, 3996 {"exclude-symbols", required_argument, NULL, OPTION_EXCLUDE_SYMS}, 3997 {"no-default-excludes", no_argument, NULL, OPTION_NO_DEFAULT_EXCLUDES}, 3998 {"output-lib", required_argument, NULL, 'l'}, 3999 {"def", required_argument, NULL, 'd'}, /* for compatibility with older versions */ 4000 {"input-def", required_argument, NULL, 'd'}, 4001 {"add-underscore", no_argument, NULL, 'U'}, 4002 {"add-stdcall-underscore", no_argument, NULL, OPTION_ADD_STDCALL_UNDERSCORE}, 4003 {"no-leading-underscore", no_argument, NULL, OPTION_NO_LEADING_UNDERSCORE}, 4004 {"leading-underscore", no_argument, NULL, OPTION_LEADING_UNDERSCORE}, 4005 {"kill-at", no_argument, NULL, 'k'}, 4006 {"add-stdcall-alias", no_argument, NULL, 'A'}, 4007 {"ext-prefix-alias", required_argument, NULL, 'p'}, 4008 {"identify", required_argument, NULL, 'I'}, 4009 {"identify-strict", no_argument, NULL, OPTION_IDENTIFY_STRICT}, 4010 {"verbose", no_argument, NULL, 'v'}, 4011 {"version", no_argument, NULL, 'V'}, 4012 {"help", no_argument, NULL, 'h'}, 4013 {"machine", required_argument, NULL, 'm'}, 4014 {"add-indirect", no_argument, NULL, 'a'}, 4015 {"base-file", required_argument, NULL, 'b'}, 4016 {"as", required_argument, NULL, 'S'}, 4017 {"as-flags", required_argument, NULL, 'f'}, 4018 {"mcore-elf", required_argument, NULL, 'M'}, 4019 {"compat-implib", no_argument, NULL, 'C'}, 4020 {"temp-prefix", required_argument, NULL, 't'}, 4021 {"output-delaylib", required_argument, NULL, 'y'}, 4022 {NULL,0,NULL,0} 4023 }; 4024 4025 int main (int, char **); 4026 4027 int 4028 main (int ac, char **av) 4029 { 4030 int c; 4031 int i; 4032 char *firstarg = 0; 4033 program_name = av[0]; 4034 oav = av; 4035 4036 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES) 4037 setlocale (LC_MESSAGES, ""); 4038 #endif 4039 #if defined (HAVE_SETLOCALE) 4040 setlocale (LC_CTYPE, ""); 4041 #endif 4042 bindtextdomain (PACKAGE, LOCALEDIR); 4043 textdomain (PACKAGE); 4044 4045 expandargv (&ac, &av); 4046 4047 while ((c = getopt_long (ac, av, 4048 #ifdef DLLTOOL_MCORE_ELF 4049 "m:e:l:aD:d:z:b:xp:cCuUkAS:f:nI:vVHhM:L:F:", 4050 #else 4051 "m:e:l:y:aD:d:z:b:xp:cCuUkAS:f:nI:vVHh", 4052 #endif 4053 long_options, 0)) 4054 != EOF) 4055 { 4056 switch (c) 4057 { 4058 case OPTION_EXPORT_ALL_SYMS: 4059 export_all_symbols = TRUE; 4060 break; 4061 case OPTION_NO_EXPORT_ALL_SYMS: 4062 export_all_symbols = FALSE; 4063 break; 4064 case OPTION_EXCLUDE_SYMS: 4065 add_excludes (optarg); 4066 break; 4067 case OPTION_NO_DEFAULT_EXCLUDES: 4068 do_default_excludes = FALSE; 4069 break; 4070 case OPTION_USE_NUL_PREFIXED_IMPORT_TABLES: 4071 use_nul_prefixed_import_tables = TRUE; 4072 break; 4073 case OPTION_ADD_STDCALL_UNDERSCORE: 4074 add_stdcall_underscore = 1; 4075 break; 4076 case OPTION_NO_LEADING_UNDERSCORE: 4077 leading_underscore = 0; 4078 break; 4079 case OPTION_LEADING_UNDERSCORE: 4080 leading_underscore = 1; 4081 break; 4082 case OPTION_IDENTIFY_STRICT: 4083 identify_strict = 1; 4084 break; 4085 case 'x': 4086 no_idata4 = 1; 4087 break; 4088 case 'c': 4089 no_idata5 = 1; 4090 break; 4091 case 'S': 4092 as_name = optarg; 4093 break; 4094 case 't': 4095 tmp_prefix = optarg; 4096 break; 4097 case 'f': 4098 as_flags = optarg; 4099 break; 4100 4101 /* Ignored for compatibility. */ 4102 case 'u': 4103 break; 4104 case 'a': 4105 add_indirect = 1; 4106 break; 4107 case 'z': 4108 output_def = fopen (optarg, FOPEN_WT); 4109 break; 4110 case 'D': 4111 dll_name = (char*) lbasename (optarg); 4112 if (dll_name != optarg) 4113 non_fatal (_("Path components stripped from dllname, '%s'."), 4114 optarg); 4115 break; 4116 case 'l': 4117 imp_name = optarg; 4118 break; 4119 case 'e': 4120 exp_name = optarg; 4121 break; 4122 case 'H': 4123 case 'h': 4124 usage (stdout, 0); 4125 break; 4126 case 'm': 4127 mname = optarg; 4128 break; 4129 case 'I': 4130 identify_imp_name = optarg; 4131 break; 4132 case 'v': 4133 verbose = 1; 4134 break; 4135 case 'V': 4136 print_version (program_name); 4137 break; 4138 case 'U': 4139 add_underscore = 1; 4140 break; 4141 case 'k': 4142 killat = 1; 4143 break; 4144 case 'A': 4145 add_stdcall_alias = 1; 4146 break; 4147 case 'p': 4148 ext_prefix_alias = optarg; 4149 break; 4150 case 'd': 4151 def_file = optarg; 4152 break; 4153 case 'n': 4154 dontdeltemps++; 4155 break; 4156 case 'b': 4157 base_file = fopen (optarg, FOPEN_RB); 4158 4159 if (!base_file) 4160 /* xgettext:c-format */ 4161 fatal (_("Unable to open base-file: %s"), optarg); 4162 4163 break; 4164 #ifdef DLLTOOL_MCORE_ELF 4165 case 'M': 4166 mcore_elf_out_file = optarg; 4167 break; 4168 case 'L': 4169 mcore_elf_linker = optarg; 4170 break; 4171 case 'F': 4172 mcore_elf_linker_flags = optarg; 4173 break; 4174 #endif 4175 case 'C': 4176 create_compat_implib = 1; 4177 break; 4178 case 'y': 4179 delayimp_name = optarg; 4180 break; 4181 default: 4182 usage (stderr, 1); 4183 break; 4184 } 4185 } 4186 4187 if (!tmp_prefix) 4188 tmp_prefix = prefix_encode ("d", getpid ()); 4189 4190 for (i = 0; mtable[i].type; i++) 4191 if (strcmp (mtable[i].type, mname) == 0) 4192 break; 4193 4194 if (!mtable[i].type) 4195 /* xgettext:c-format */ 4196 fatal (_("Machine '%s' not supported"), mname); 4197 4198 machine = i; 4199 4200 /* Check if we generated PE+. */ 4201 create_for_pep = strcmp (mname, "i386:x86-64") == 0; 4202 4203 { 4204 /* Check the default underscore */ 4205 int u = leading_underscore; /* Underscoring mode. -1 for use default. */ 4206 if (u == -1) 4207 bfd_get_target_info (mtable[machine].how_bfd_target, NULL, 4208 NULL, &u, NULL); 4209 if (u != -1) 4210 leading_underscore = (u != 0 ? TRUE : FALSE); 4211 } 4212 4213 if (!dll_name && exp_name) 4214 { 4215 /* If we are inferring dll_name from exp_name, 4216 strip off any path components, without emitting 4217 a warning. */ 4218 const char* exp_basename = lbasename (exp_name); 4219 const int len = strlen (exp_basename) + 5; 4220 dll_name = xmalloc (len); 4221 strcpy (dll_name, exp_basename); 4222 strcat (dll_name, ".dll"); 4223 dll_name_set_by_exp_name = 1; 4224 } 4225 4226 if (as_name == NULL) 4227 as_name = deduce_name ("as"); 4228 4229 /* Don't use the default exclude list if we're reading only the 4230 symbols in the .drectve section. The default excludes are meant 4231 to avoid exporting DLL entry point and Cygwin32 impure_ptr. */ 4232 if (! export_all_symbols) 4233 do_default_excludes = FALSE; 4234 4235 if (do_default_excludes) 4236 set_default_excludes (); 4237 4238 if (def_file) 4239 process_def_file (def_file); 4240 4241 while (optind < ac) 4242 { 4243 if (!firstarg) 4244 firstarg = av[optind]; 4245 scan_obj_file (av[optind]); 4246 optind++; 4247 } 4248 4249 mangle_defs (); 4250 4251 if (exp_name) 4252 gen_exp_file (); 4253 4254 if (imp_name) 4255 { 4256 /* Make imp_name safe for use as a label. */ 4257 char *p; 4258 4259 imp_name_lab = xstrdup (imp_name); 4260 for (p = imp_name_lab; *p; p++) 4261 { 4262 if (!ISALNUM (*p)) 4263 *p = '_'; 4264 } 4265 head_label = make_label("_head_", imp_name_lab); 4266 gen_lib_file (0); 4267 } 4268 4269 if (delayimp_name) 4270 { 4271 /* Make delayimp_name safe for use as a label. */ 4272 char *p; 4273 4274 if (mtable[machine].how_dljtab == 0) 4275 { 4276 inform (_("Warning, machine type (%d) not supported for " 4277 "delayimport."), machine); 4278 } 4279 else 4280 { 4281 killat = 1; 4282 imp_name = delayimp_name; 4283 imp_name_lab = xstrdup (imp_name); 4284 for (p = imp_name_lab; *p; p++) 4285 { 4286 if (!ISALNUM (*p)) 4287 *p = '_'; 4288 } 4289 head_label = make_label("__tailMerge_", imp_name_lab); 4290 gen_lib_file (1); 4291 } 4292 } 4293 4294 if (output_def) 4295 gen_def_file (); 4296 4297 if (identify_imp_name) 4298 { 4299 identify_dll_for_implib (); 4300 } 4301 4302 #ifdef DLLTOOL_MCORE_ELF 4303 if (mcore_elf_out_file) 4304 mcore_elf_gen_out_file (); 4305 #endif 4306 4307 return 0; 4308 } 4309 4310 /* Look for the program formed by concatenating PROG_NAME and the 4311 string running from PREFIX to END_PREFIX. If the concatenated 4312 string contains a '/', try appending EXECUTABLE_SUFFIX if it is 4313 appropriate. */ 4314 4315 static char * 4316 look_for_prog (const char *prog_name, const char *prefix, int end_prefix) 4317 { 4318 struct stat s; 4319 char *cmd; 4320 4321 cmd = xmalloc (strlen (prefix) 4322 + strlen (prog_name) 4323 #ifdef HAVE_EXECUTABLE_SUFFIX 4324 + strlen (EXECUTABLE_SUFFIX) 4325 #endif 4326 + 10); 4327 strcpy (cmd, prefix); 4328 4329 sprintf (cmd + end_prefix, "%s", prog_name); 4330 4331 if (strchr (cmd, '/') != NULL) 4332 { 4333 int found; 4334 4335 found = (stat (cmd, &s) == 0 4336 #ifdef HAVE_EXECUTABLE_SUFFIX 4337 || stat (strcat (cmd, EXECUTABLE_SUFFIX), &s) == 0 4338 #endif 4339 ); 4340 4341 if (! found) 4342 { 4343 /* xgettext:c-format */ 4344 inform (_("Tried file: %s"), cmd); 4345 free (cmd); 4346 return NULL; 4347 } 4348 } 4349 4350 /* xgettext:c-format */ 4351 inform (_("Using file: %s"), cmd); 4352 4353 return cmd; 4354 } 4355 4356 /* Deduce the name of the program we are want to invoke. 4357 PROG_NAME is the basic name of the program we want to run, 4358 eg "as" or "ld". The catch is that we might want actually 4359 run "i386-pe-as" or "ppc-pe-ld". 4360 4361 If argv[0] contains the full path, then try to find the program 4362 in the same place, with and then without a target-like prefix. 4363 4364 Given, argv[0] = /usr/local/bin/i586-cygwin32-dlltool, 4365 deduce_name("as") uses the following search order: 4366 4367 /usr/local/bin/i586-cygwin32-as 4368 /usr/local/bin/as 4369 as 4370 4371 If there's an EXECUTABLE_SUFFIX, it'll use that as well; for each 4372 name, it'll try without and then with EXECUTABLE_SUFFIX. 4373 4374 Given, argv[0] = i586-cygwin32-dlltool, it will not even try "as" 4375 as the fallback, but rather return i586-cygwin32-as. 4376 4377 Oh, and given, argv[0] = dlltool, it'll return "as". 4378 4379 Returns a dynamically allocated string. */ 4380 4381 static char * 4382 deduce_name (const char *prog_name) 4383 { 4384 char *cmd; 4385 char *dash, *slash, *cp; 4386 4387 dash = NULL; 4388 slash = NULL; 4389 for (cp = program_name; *cp != '\0'; ++cp) 4390 { 4391 if (*cp == '-') 4392 dash = cp; 4393 if ( 4394 #if defined(__DJGPP__) || defined (__CYGWIN__) || defined(__WIN32__) 4395 *cp == ':' || *cp == '\\' || 4396 #endif 4397 *cp == '/') 4398 { 4399 slash = cp; 4400 dash = NULL; 4401 } 4402 } 4403 4404 cmd = NULL; 4405 4406 if (dash != NULL) 4407 { 4408 /* First, try looking for a prefixed PROG_NAME in the 4409 PROGRAM_NAME directory, with the same prefix as PROGRAM_NAME. */ 4410 cmd = look_for_prog (prog_name, program_name, dash - program_name + 1); 4411 } 4412 4413 if (slash != NULL && cmd == NULL) 4414 { 4415 /* Next, try looking for a PROG_NAME in the same directory as 4416 that of this program. */ 4417 cmd = look_for_prog (prog_name, program_name, slash - program_name + 1); 4418 } 4419 4420 if (cmd == NULL) 4421 { 4422 /* Just return PROG_NAME as is. */ 4423 cmd = xstrdup (prog_name); 4424 } 4425 4426 return cmd; 4427 } 4428 4429 #ifdef DLLTOOL_MCORE_ELF 4430 typedef struct fname_cache 4431 { 4432 const char * filename; 4433 struct fname_cache * next; 4434 } 4435 fname_cache; 4436 4437 static fname_cache fnames; 4438 4439 static void 4440 mcore_elf_cache_filename (const char * filename) 4441 { 4442 fname_cache * ptr; 4443 4444 ptr = & fnames; 4445 4446 while (ptr->next != NULL) 4447 ptr = ptr->next; 4448 4449 ptr->filename = filename; 4450 ptr->next = (fname_cache *) malloc (sizeof (fname_cache)); 4451 if (ptr->next != NULL) 4452 ptr->next->next = NULL; 4453 } 4454 4455 #define MCORE_ELF_TMP_OBJ "mcoreelf.o" 4456 #define MCORE_ELF_TMP_EXP "mcoreelf.exp" 4457 #define MCORE_ELF_TMP_LIB "mcoreelf.lib" 4458 4459 static void 4460 mcore_elf_gen_out_file (void) 4461 { 4462 fname_cache * ptr; 4463 dyn_string_t ds; 4464 4465 /* Step one. Run 'ld -r' on the input object files in order to resolve 4466 any internal references and to generate a single .exports section. */ 4467 ptr = & fnames; 4468 4469 ds = dyn_string_new (100); 4470 dyn_string_append_cstr (ds, "-r "); 4471 4472 if (mcore_elf_linker_flags != NULL) 4473 dyn_string_append_cstr (ds, mcore_elf_linker_flags); 4474 4475 while (ptr->next != NULL) 4476 { 4477 dyn_string_append_cstr (ds, ptr->filename); 4478 dyn_string_append_cstr (ds, " "); 4479 4480 ptr = ptr->next; 4481 } 4482 4483 dyn_string_append_cstr (ds, "-o "); 4484 dyn_string_append_cstr (ds, MCORE_ELF_TMP_OBJ); 4485 4486 if (mcore_elf_linker == NULL) 4487 mcore_elf_linker = deduce_name ("ld"); 4488 4489 run (mcore_elf_linker, ds->s); 4490 4491 dyn_string_delete (ds); 4492 4493 /* Step two. Create a .exp file and a .lib file from the temporary file. 4494 Do this by recursively invoking dlltool... */ 4495 ds = dyn_string_new (100); 4496 4497 dyn_string_append_cstr (ds, "-S "); 4498 dyn_string_append_cstr (ds, as_name); 4499 4500 dyn_string_append_cstr (ds, " -e "); 4501 dyn_string_append_cstr (ds, MCORE_ELF_TMP_EXP); 4502 dyn_string_append_cstr (ds, " -l "); 4503 dyn_string_append_cstr (ds, MCORE_ELF_TMP_LIB); 4504 dyn_string_append_cstr (ds, " " ); 4505 dyn_string_append_cstr (ds, MCORE_ELF_TMP_OBJ); 4506 4507 if (verbose) 4508 dyn_string_append_cstr (ds, " -v"); 4509 4510 if (dontdeltemps) 4511 { 4512 dyn_string_append_cstr (ds, " -n"); 4513 4514 if (dontdeltemps > 1) 4515 dyn_string_append_cstr (ds, " -n"); 4516 } 4517 4518 /* XXX - FIME: ought to check/copy other command line options as well. */ 4519 run (program_name, ds->s); 4520 4521 dyn_string_delete (ds); 4522 4523 /* Step four. Feed the .exp and object files to ld -shared to create the dll. */ 4524 ds = dyn_string_new (100); 4525 4526 dyn_string_append_cstr (ds, "-shared "); 4527 4528 if (mcore_elf_linker_flags) 4529 dyn_string_append_cstr (ds, mcore_elf_linker_flags); 4530 4531 dyn_string_append_cstr (ds, " "); 4532 dyn_string_append_cstr (ds, MCORE_ELF_TMP_EXP); 4533 dyn_string_append_cstr (ds, " "); 4534 dyn_string_append_cstr (ds, MCORE_ELF_TMP_OBJ); 4535 dyn_string_append_cstr (ds, " -o "); 4536 dyn_string_append_cstr (ds, mcore_elf_out_file); 4537 4538 run (mcore_elf_linker, ds->s); 4539 4540 dyn_string_delete (ds); 4541 4542 if (dontdeltemps == 0) 4543 unlink (MCORE_ELF_TMP_EXP); 4544 4545 if (dontdeltemps < 2) 4546 unlink (MCORE_ELF_TMP_OBJ); 4547 } 4548 #endif /* DLLTOOL_MCORE_ELF */ 4549
