git.oblomov.eu Git - wine/blob - tools/winebuild/import.c

   1 /*
   2  * DLL imports support
   3  *
   4  * Copyright 2000, 2004 Alexandre Julliard
   5  * Copyright 2000 Eric Pouech
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  20  */
  21
  22 #include "config.h"
  23 #include "wine/port.h"
  24
  25 #include <ctype.h>
  26 #include <fcntl.h>
  27 #include <stdio.h>
  28 #include <string.h>
  29 #include <stdarg.h>
  30 #ifdef HAVE_UNISTD_H
  31 # include <unistd.h>
  32 #endif
  33
  34 #include "windef.h"
  35 #include "winbase.h"
  36 #include "build.h"
  37
  38 struct import
  39 {
  40     DLLSPEC     *spec;         /* description of the imported dll */
  41     int          delay;       /* delay or not dll loading ? */
  42     ORDDEF     **exports;     /* functions exported from this dll */
  43     int          nb_exports;  /* number of exported functions */
  44     ORDDEF     **imports;     /* functions we want to import from this dll */
  45     int          nb_imports;  /* number of imported functions */
  46 };
  47
  48 static char **undef_symbols;  /* list of undefined symbols */
  49 static int nb_undef_symbols = -1;
  50 static int undef_size;
  51
  52 static char **ignore_symbols; /* list of symbols to ignore */
  53 static int nb_ignore_symbols;
  54 static int ignore_size;
  55
  56 static char *ld_tmp_file;  /* ld temp file name */
  57
  58 static struct import **dll_imports = NULL;
  59 static int nb_imports = 0;      /* number of imported dlls (delayed or not) */
  60 static int nb_delayed = 0;      /* number of delayed dlls */
  61 static int total_imports = 0;   /* total number of imported functions */
  62 static int total_delayed = 0;   /* total number of imported functions in delayed DLLs */
  63
  64 /* list of symbols that are ignored by default */
  65 static const char * const default_ignored_symbols[] =
  66 {
  67     "abs",
  68     "acos",
  69     "asin",
  70     "atan",
  71     "atan2",
  72     "atof",
  73     "atoi",
  74     "atol",
  75     "bsearch",
  76     "ceil",
  77     "cos",
  78     "cosh",
  79     "exp",
  80     "fabs",
  81     "floor",
  82     "fmod",
  83     "frexp",
  84     "labs",
  85     "log",
  86     "log10",
  87     "memchr",
  88     "memcmp",
  89     "memcpy",
  90     "memmove",
  91     "memset",
  92     "modf",
  93     "pow",
  94     "qsort",
  95     "sin",
  96     "sinh",
  97     "sqrt",
  98     "strcat",
  99     "strchr",
 100     "strcmp",
 101     "strcpy",
 102     "strcspn",
 103     "strlen",
 104     "strncat",
 105     "strncmp",
 106     "strncpy",
 107     "strpbrk",
 108     "strrchr",
 109     "strspn",
 110     "strstr",
 111     "tan",
 112     "tanh"
 113 };
 114
 115 #ifdef __powerpc__
 116 # ifdef __APPLE__
 117 # define ppc_high(mem) "ha16(" mem ")"
 118 # define ppc_low(mem)  "lo16(" mem ")"
 119 static const char * const ppc_reg[32] = { "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
 120                                           "r8", "r9", "r10","r11","r12","r13","r14","r15",
 121                                           "r16","r17","r18","r19","r20","r21","r22","r23",
 122                                           "r24","r25","r26","r27","r28","r29","r30","r31" };
 123 # else  /* __APPLE__ */
 124 # define ppc_high(mem) "(" mem ")@hi"
 125 # define ppc_low(mem)  "(" mem ")@l"
 126 static const char * const ppc_reg[32] = { "0", "1", "2", "3", "4", "5", "6", "7",
 127                                           "8", "9", "10","11","12","13","14","15",
 128                                           "16","17","18","19","20","21","22","23",
 129                                           "24","25","26","27","28","29","30","31" };
 130 # endif  /* __APPLE__ */
 131 #endif  /* __powerpc__ */
 132
 133 /* compare function names; helper for resolve_imports */
 134 static int name_cmp( const void *name, const void *entry )
 135 {
 136     return strcmp( *(char **)name, *(char **)entry );
 137 }
 138
 139 /* compare function names; helper for resolve_imports */
 140 static int func_cmp( const void *func1, const void *func2 )
 141 {
 142     const ORDDEF *odp1 = *(const ORDDEF **)func1;
 143     const ORDDEF *odp2 = *(const ORDDEF **)func2;
 144     return strcmp( odp1->name ? odp1->name : odp1->export_name,
 145                    odp2->name ? odp2->name : odp2->export_name );
 146 }
 147
 148 /* locate a symbol in a (sorted) list */
 149 inline static const char *find_symbol( const char *name, char **table, int size )
 150 {
 151     char **res = NULL;
 152
 153     if (table) {
 154         res = bsearch( &name, table, size, sizeof(*table), name_cmp );
 155     }
 156
 157     return res ? *res : NULL;
 158 }
 159
 160 /* locate an export in a (sorted) export list */
 161 inline static ORDDEF *find_export( const char *name, ORDDEF **table, int size )
 162 {
 163     ORDDEF func, *odp, **res = NULL;
 164
 165     func.name = (char *)name;
 166     func.ordinal = -1;
 167     odp = &func;
 168     if (table) res = bsearch( &odp, table, size, sizeof(*table), func_cmp );
 169     return res ? *res : NULL;
 170 }
 171
 172 /* sort a symbol table */
 173 inline static void sort_symbols( char **table, int size )
 174 {
 175     if (table )
 176         qsort( table, size, sizeof(*table), name_cmp );
 177 }
 178
 179 /* free an import structure */
 180 static void free_imports( struct import *imp )
 181 {
 182     free( imp->exports );
 183     free( imp->imports );
 184     free_dll_spec( imp->spec );
 185     free( imp );
 186 }
 187
 188 /* remove the temp file at exit */
 189 static void remove_ld_tmp_file(void)
 190 {
 191     if (ld_tmp_file) unlink( ld_tmp_file );
 192 }
 193
 194 /* check whether a given dll has already been imported */
 195 static int is_already_imported( const char *name )
 196 {
 197     int i;
 198
 199     for (i = 0; i < nb_imports; i++)
 200     {
 201         if (!strcmp( dll_imports[i]->spec->file_name, name )) return 1;
 202     }
 203     return 0;
 204 }
 205
 206 /* open the .so library for a given dll in a specified path */
 207 static char *try_library_path( const char *path, const char *name )
 208 {
 209     char *buffer;
 210     int fd;
 211
 212     buffer = xmalloc( strlen(path) + strlen(name) + 9 );
 213     sprintf( buffer, "%s/lib%s.def", path, name );
 214
 215     /* check if the file exists */
 216     if ((fd = open( buffer, O_RDONLY )) != -1)
 217     {
 218         close( fd );
 219         return buffer;
 220     }
 221     free( buffer );
 222     return NULL;
 223 }
 224
 225 /* open the .so library for a given dll */
 226 static char *open_library( const char *name )
 227 {
 228     char *fullname;
 229     int i;
 230
 231     for (i = 0; i < nb_lib_paths; i++)
 232     {
 233         if ((fullname = try_library_path( lib_path[i], name ))) return fullname;
 234     }
 235     fatal_error( "could not open .def file for %s\n", name );
 236     return NULL;
 237 }
 238
 239 /* read in the list of exported symbols of an import library */
 240 static int read_import_lib( const char *name, struct import *imp )
 241 {
 242     FILE *f;
 243     char *fullname;
 244     int i, ret;
 245     DLLSPEC *spec = imp->spec;
 246
 247     imp->exports    = NULL;
 248     imp->nb_exports = 0;
 249
 250     fullname = open_library( name );
 251     f = open_input_file( NULL, fullname );
 252     free( fullname );
 253
 254     ret = parse_def_file( f, spec );
 255     close_input_file( f );
 256     if (!ret) return 0;
 257     if (is_already_imported( spec->file_name )) return 0;
 258
 259     imp->exports = xmalloc( spec->nb_entry_points * sizeof(*imp->exports) );
 260
 261     for (i = 0; i < spec->nb_entry_points; i++)
 262     {
 263         ORDDEF *odp = &spec->entry_points[i];
 264
 265         if (odp->type != TYPE_STDCALL && odp->type != TYPE_CDECL) continue;
 266         if (odp->flags & FLAG_PRIVATE) continue;
 267         imp->exports[imp->nb_exports++] = odp;
 268     }
 269     imp->exports = xrealloc( imp->exports, imp->nb_exports * sizeof(*imp->exports) );
 270     if (imp->nb_exports)
 271         qsort( imp->exports, imp->nb_exports, sizeof(*imp->exports), func_cmp );
 272     return 1;
 273 }
 274
 275 /* add a dll to the list of imports */
 276 void add_import_dll( const char *name, int delay )
 277 {
 278     struct import *imp;
 279     char *fullname;
 280
 281     fullname = xmalloc( strlen(name) + 5 );
 282     strcpy( fullname, name );
 283     if (!strchr( fullname, '.' )) strcat( fullname, ".dll" );
 284
 285     /* check if we already imported it */
 286     if (is_already_imported( fullname ))
 287     {
 288         free( fullname );
 289         return;
 290     }
 291
 292     imp = xmalloc( sizeof(*imp) );
 293     imp->spec            = alloc_dll_spec();
 294     imp->spec->file_name = fullname;
 295     imp->delay           = delay;
 296     imp->imports         = NULL;
 297     imp->nb_imports      = 0;
 298     if (delay) nb_delayed++;
 299
 300     if (read_import_lib( name, imp ))
 301     {
 302         dll_imports = xrealloc( dll_imports, (nb_imports+1) * sizeof(*dll_imports) );
 303         dll_imports[nb_imports++] = imp;
 304     }
 305     else
 306     {
 307         free_imports( imp );
 308         if (nb_errors) exit(1);
 309     }
 310 }
 311
 312 /* remove an imported dll, based on its index in the dll_imports array */
 313 static void remove_import_dll( int index )
 314 {
 315     struct import *imp = dll_imports[index];
 316
 317     memmove( &dll_imports[index], &dll_imports[index+1], sizeof(imp) * (nb_imports - index - 1) );
 318     nb_imports--;
 319     if (imp->delay) nb_delayed--;
 320     free_imports( imp );
 321 }
 322
 323 /* initialize the list of ignored symbols */
 324 static void init_ignored_symbols(void)
 325 {
 326     int i;
 327
 328     nb_ignore_symbols = sizeof(default_ignored_symbols)/sizeof(default_ignored_symbols[0]);
 329     ignore_size = nb_ignore_symbols + 32;
 330     ignore_symbols = xmalloc( ignore_size * sizeof(*ignore_symbols) );
 331     for (i = 0; i < nb_ignore_symbols; i++)
 332         ignore_symbols[i] = xstrdup( default_ignored_symbols[i] );
 333 }
 334
 335 /* add a symbol to the ignored symbol list */
 336 /* if the name starts with '-' the symbol is removed instead */
 337 void add_ignore_symbol( const char *name )
 338 {
 339     int i;
 340
 341     if (!ignore_symbols) init_ignored_symbols();  /* first time around, fill list with defaults */
 342
 343     if (name[0] == '-')  /* remove it */
 344     {
 345         if (!name[1])  /* remove everything */
 346         {
 347             for (i = 0; i < nb_ignore_symbols; i++) free( ignore_symbols[i] );
 348             nb_ignore_symbols = 0;
 349         }
 350         else
 351         {
 352             for (i = 0; i < nb_ignore_symbols; i++)
 353             {
 354                 if (!strcmp( ignore_symbols[i], name+1 ))
 355                 {
 356                     free( ignore_symbols[i] );
 357                     memmove( &ignore_symbols[i], &ignore_symbols[i+1], nb_ignore_symbols - i - 1 );
 358                     nb_ignore_symbols--;
 359                 }
 360             }
 361         }
 362     }
 363     else
 364     {
 365         if (nb_ignore_symbols == ignore_size)
 366         {
 367             ignore_size += 32;
 368             ignore_symbols = xrealloc( ignore_symbols, ignore_size * sizeof(*ignore_symbols) );
 369         }
 370         ignore_symbols[nb_ignore_symbols++] = xstrdup( name );
 371     }
 372 }
 373
 374 /* add a function to the list of imports from a given dll */
 375 static void add_import_func( struct import *imp, ORDDEF *func )
 376 {
 377     imp->imports = xrealloc( imp->imports, (imp->nb_imports+1) * sizeof(*imp->imports) );
 378     imp->imports[imp->nb_imports++] = func;
 379     total_imports++;
 380     if (imp->delay) total_delayed++;
 381 }
 382
 383 /* add a symbol to the undef list */
 384 inline static void add_undef_symbol( const char *name )
 385 {
 386     if (nb_undef_symbols == undef_size)
 387     {
 388         undef_size += 128;
 389         undef_symbols = xrealloc( undef_symbols, undef_size * sizeof(*undef_symbols) );
 390     }
 391     undef_symbols[nb_undef_symbols++] = xstrdup( name );
 392 }
 393
 394 /* remove all the holes in the undefined symbol list; return the number of removed symbols */
 395 static int remove_symbol_holes(void)
 396 {
 397     int i, off;
 398     for (i = off = 0; i < nb_undef_symbols; i++)
 399     {
 400         if (!undef_symbols[i]) off++;
 401         else undef_symbols[i - off] = undef_symbols[i];
 402     }
 403     nb_undef_symbols -= off;
 404     return off;
 405 }
 406
 407 /* add a symbol to the extra list, but only if needed */
 408 static int add_extra_symbol( const char **extras, int *count, const char *name, const DLLSPEC *spec )
 409 {
 410     int i;
 411
 412     if (!find_symbol( name, undef_symbols, nb_undef_symbols ))
 413     {
 414         /* check if the symbol is being exported by this dll */
 415         for (i = 0; i < spec->nb_entry_points; i++)
 416         {
 417             ORDDEF *odp = &spec->entry_points[i];
 418             if (odp->type == TYPE_STDCALL ||
 419                 odp->type == TYPE_CDECL ||
 420                 odp->type == TYPE_VARARGS ||
 421                 odp->type == TYPE_EXTERN)
 422             {
 423                 if (odp->name && !strcmp( odp->name, name )) return 0;
 424             }
 425         }
 426         extras[*count] = name;
 427         (*count)++;
 428     }
 429     return 1;
 430 }
 431
 432 /* add the extra undefined symbols that will be contained in the generated spec file itself */
 433 static void add_extra_undef_symbols( const DLLSPEC *spec )
 434 {
 435     const char *extras[10];
 436     int i, count = 0, nb_stubs = 0, nb_regs = 0;
 437     int kernel_imports = 0, ntdll_imports = 0;
 438
 439     sort_symbols( undef_symbols, nb_undef_symbols );
 440
 441     for (i = 0; i < spec->nb_entry_points; i++)
 442     {
 443         ORDDEF *odp = &spec->entry_points[i];
 444         if (odp->type == TYPE_STUB) nb_stubs++;
 445         if (odp->flags & FLAG_REGISTER) nb_regs++;
 446     }
 447
 448     /* add symbols that will be contained in the spec file itself */
 449     if (!(spec->characteristics & IMAGE_FILE_DLL))
 450     {
 451         switch (spec->subsystem)
 452         {
 453         case IMAGE_SUBSYSTEM_WINDOWS_GUI:
 454             kernel_imports += add_extra_symbol( extras, &count, "GetCommandLineA", spec );
 455             kernel_imports += add_extra_symbol( extras, &count, "GetStartupInfoA", spec );
 456             kernel_imports += add_extra_symbol( extras, &count, "GetModuleHandleA", spec );
 457             /* fall through */
 458         case IMAGE_SUBSYSTEM_WINDOWS_CUI:
 459             kernel_imports += add_extra_symbol( extras, &count, "ExitProcess", spec );
 460             break;
 461         }
 462     }
 463     if (nb_delayed)
 464     {
 465         kernel_imports += add_extra_symbol( extras, &count, "LoadLibraryA", spec );
 466         kernel_imports += add_extra_symbol( extras, &count, "GetProcAddress", spec );
 467     }
 468     if (nb_regs)
 469         ntdll_imports += add_extra_symbol( extras, &count, "__wine_call_from_32_regs", spec );
 470     if (nb_delayed || nb_stubs)
 471         ntdll_imports += add_extra_symbol( extras, &count, "RtlRaiseException", spec );
 472
 473     /* make sure we import the dlls that contain these functions */
 474     if (kernel_imports) add_import_dll( "kernel32", 0 );
 475     if (ntdll_imports) add_import_dll( "ntdll", 0 );
 476
 477     if (count)
 478     {
 479         for (i = 0; i < count; i++) add_undef_symbol( extras[i] );
 480         sort_symbols( undef_symbols, nb_undef_symbols );
 481     }
 482 }
 483
 484 /* check if a given imported dll is not needed, taking forwards into account */
 485 static int check_unused( const struct import* imp, const DLLSPEC *spec )
 486 {
 487     int i;
 488     const char *file_name = imp->spec->file_name;
 489     size_t len = strlen( file_name );
 490     const char *p = strchr( file_name, '.' );
 491     if (p && !strcasecmp( p, ".dll" )) len = p - file_name;
 492
 493     for (i = spec->base; i <= spec->limit; i++)
 494     {
 495         ORDDEF *odp = spec->ordinals[i];
 496         if (!odp || !(odp->flags & FLAG_FORWARD)) continue;
 497         if (!strncasecmp( odp->link_name, file_name, len ) &&
 498             odp->link_name[len] == '.')
 499             return 0;  /* found a forward, it is used */
 500     }
 501     return 1;
 502 }
 503
 504 /* combine a list of object files with ld into a single object file */
 505 /* returns the name of the combined file */
 506 static const char *ldcombine_files( char **argv )
 507 {
 508     int i, len = 0;
 509     char *cmd;
 510     int fd, err;
 511
 512     if (output_file_name && output_file_name[0])
 513     {
 514         ld_tmp_file = xmalloc( strlen(output_file_name) + 10 );
 515         strcpy( ld_tmp_file, output_file_name );
 516         strcat( ld_tmp_file, ".XXXXXX.o" );
 517     }
 518     else ld_tmp_file = xstrdup( "/tmp/winebuild.tmp.XXXXXX.o" );
 519
 520     if ((fd = mkstemps( ld_tmp_file, 2 ) == -1)) fatal_error( "could not generate a temp file\n" );
 521     close( fd );
 522     atexit( remove_ld_tmp_file );
 523
 524     for (i = 0; argv[i]; i++) len += strlen(argv[i]) + 1;
 525     cmd = xmalloc( len + strlen(ld_tmp_file) + 10 );
 526     sprintf( cmd, "ld -r -o %s", ld_tmp_file );
 527     for (i = 0; argv[i]; i++) sprintf( cmd + strlen(cmd), " %s", argv[i] );
 528     err = system( cmd );
 529     if (err) fatal_error( "ld -r failed with status %d\n", err );
 530     free( cmd );
 531     return ld_tmp_file;
 532 }
 533
 534 /* read in the list of undefined symbols */
 535 void read_undef_symbols( char **argv )
 536 {
 537     FILE *f;
 538     char buffer[1024];
 539     int err;
 540     const char *name;
 541
 542     if (!argv[0]) return;
 543
 544     undef_size = nb_undef_symbols = 0;
 545
 546     /* if we have multiple object files, link them together */
 547     if (argv[1]) name = ldcombine_files( argv );
 548     else name = argv[0];
 549
 550     sprintf( buffer, "nm -u %s", name );
 551     if (!(f = popen( buffer, "r" )))
 552         fatal_error( "Cannot execute '%s'\n", buffer );
 553
 554     while (fgets( buffer, sizeof(buffer), f ))
 555     {
 556         char *p = buffer + strlen(buffer) - 1;
 557         if (p < buffer) continue;
 558         if (*p == '\n') *p-- = 0;
 559         p = buffer;
 560         while (*p == ' ') p++;
 561         if (p[0] == 'U' && p[1] == ' ' && p[2]) p += 2;
 562         add_undef_symbol( p );
 563     }
 564     if ((err = pclose( f ))) warning( "nm -u %s error %d\n", name, err );
 565 }
 566
 567 static void remove_ignored_symbols(void)
 568 {
 569     int i;
 570
 571     if (!ignore_symbols) init_ignored_symbols();
 572     sort_symbols( ignore_symbols, nb_ignore_symbols );
 573     for (i = 0; i < nb_undef_symbols; i++)
 574     {
 575         if (find_symbol( undef_symbols[i], ignore_symbols, nb_ignore_symbols ))
 576         {
 577             free( undef_symbols[i] );
 578             undef_symbols[i] = NULL;
 579         }
 580     }
 581     remove_symbol_holes();
 582 }
 583
 584 /* resolve the imports for a Win32 module */
 585 int resolve_imports( DLLSPEC *spec )
 586 {
 587     int i, j;
 588
 589     if (nb_undef_symbols == -1) return 0; /* no symbol file specified */
 590
 591     add_extra_undef_symbols( spec );
 592     remove_ignored_symbols();
 593
 594     for (i = 0; i < nb_imports; i++)
 595     {
 596         struct import *imp = dll_imports[i];
 597
 598         for (j = 0; j < nb_undef_symbols; j++)
 599         {
 600             ORDDEF *odp = find_export( undef_symbols[j], imp->exports, imp->nb_exports );
 601             if (odp)
 602             {
 603                 add_import_func( imp, odp );
 604                 free( undef_symbols[j] );
 605                 undef_symbols[j] = NULL;
 606             }
 607         }
 608         /* remove all the holes in the undef symbols list */
 609         if (!remove_symbol_holes() && check_unused( imp, spec ))
 610         {
 611             /* the dll is not used, get rid of it */
 612             warning( "%s imported but no symbols used\n", imp->spec->file_name );
 613             remove_import_dll( i );
 614             i--;
 615         }
 616     }
 617     return 1;
 618 }
 619
 620 /* output the import table of a Win32 module */
 621 static int output_immediate_imports( FILE *outfile )
 622 {
 623     int i, j, pos;
 624     int nb_imm = nb_imports - nb_delayed;
 625
 626     if (!nb_imm) goto done;
 627
 628     /* main import header */
 629
 630     fprintf( outfile, "\nstatic struct {\n" );
 631     fprintf( outfile, "  struct {\n" );
 632     fprintf( outfile, "    void        *OriginalFirstThunk;\n" );
 633     fprintf( outfile, "    unsigned int TimeDateStamp;\n" );
 634     fprintf( outfile, "    unsigned int ForwarderChain;\n" );
 635     fprintf( outfile, "    const char  *Name;\n" );
 636     fprintf( outfile, "    void        *FirstThunk;\n" );
 637     fprintf( outfile, "  } imp[%d];\n", nb_imm+1 );
 638     fprintf( outfile, "  const char *data[%d];\n",
 639              total_imports - total_delayed + nb_imm );
 640     fprintf( outfile, "} imports = {\n  {\n" );
 641
 642     /* list of dlls */
 643
 644     for (i = j = 0; i < nb_imports; i++)
 645     {
 646         if (dll_imports[i]->delay) continue;
 647         fprintf( outfile, "    { 0, 0, 0, \"%s\", &imports.data[%d] },\n",
 648                  dll_imports[i]->spec->file_name, j );
 649         j += dll_imports[i]->nb_imports + 1;
 650     }
 651
 652     fprintf( outfile, "    { 0, 0, 0, 0, 0 },\n" );
 653     fprintf( outfile, "  },\n  {\n" );
 654
 655     /* list of imported functions */
 656
 657     for (i = 0; i < nb_imports; i++)
 658     {
 659         if (dll_imports[i]->delay) continue;
 660         fprintf( outfile, "    /* %s */\n", dll_imports[i]->spec->file_name );
 661         for (j = 0; j < dll_imports[i]->nb_imports; j++)
 662         {
 663             ORDDEF *odp = dll_imports[i]->imports[j];
 664             if (!(odp->flags & FLAG_NONAME))
 665             {
 666                 unsigned short ord = odp->ordinal;
 667                 fprintf( outfile, "    \"\\%03o\\%03o%s\",\n",
 668                          *(unsigned char *)&ord, *((unsigned char *)&ord + 1), odp->name );
 669             }
 670             else
 671                 fprintf( outfile, "    (char *)%d,\n", odp->ordinal );
 672         }
 673         fprintf( outfile, "    0,\n" );
 674     }
 675     fprintf( outfile, "  }\n};\n\n" );
 676
 677     /* thunks for imported functions */
 678
 679     fprintf( outfile, "#ifndef __GNUC__\nstatic void __asm__dummy_import(void) {\n#endif\n\n" );
 680     pos = 20 * (nb_imm + 1);  /* offset of imports.data from start of imports */
 681     fprintf( outfile, "asm(\".data\\n\\t.align %d\\n\"\n", get_alignment(8) );
 682     for (i = 0; i < nb_imports; i++)
 683     {
 684         if (dll_imports[i]->delay) continue;
 685         for (j = 0; j < dll_imports[i]->nb_imports; j++, pos += 4)
 686         {
 687             ORDDEF *odp = dll_imports[i]->imports[j];
 688             const char *name = odp->name ? odp->name : odp->export_name;
 689             fprintf( outfile, "    \"\\t" __ASM_FUNC("%s") "\\n\"\n", name );
 690             fprintf( outfile, "    \"\\t.globl " __ASM_NAME("%s") "\\n\"\n", name );
 691             fprintf( outfile, "    \"" __ASM_NAME("%s") ":\\n\\t", name);
 692
 693 #if defined(__i386__)
 694             if (strstr( name, "__wine_call_from_16" ))
 695                 fprintf( outfile, ".byte 0x2e\\n\\tjmp *(imports+%d)\\n\\tnop\\n", pos );
 696             else
 697                 fprintf( outfile, "jmp *(imports+%d)\\n\\tmovl %%esi,%%esi\\n", pos );
 698 #elif defined(__sparc__)
 699             if ( !UsePIC )
 700             {
 701                 fprintf( outfile, "sethi %%hi(imports+%d), %%g1\\n\\t", pos );
 702                 fprintf( outfile, "ld [%%g1+%%lo(imports+%d)], %%g1\\n\\t", pos );
 703                 fprintf( outfile, "jmp %%g1\\n\\tnop\\n" );
 704             }
 705             else
 706             {
 707                 /* Hmpf.  Stupid sparc assembler always interprets global variable
 708                    names as GOT offsets, so we have to do it the long way ... */
 709                 fprintf( outfile, "save %%sp, -96, %%sp\\n" );
 710                 fprintf( outfile, "0:\\tcall 1f\\n\\tnop\\n" );
 711                 fprintf( outfile, "1:\\tsethi %%hi(imports+%d-0b), %%g1\\n\\t", pos );
 712                 fprintf( outfile, "or %%g1, %%lo(imports+%d-0b), %%g1\\n\\t", pos );
 713                 fprintf( outfile, "ld [%%g1+%%o7], %%g1\\n\\t" );
 714                 fprintf( outfile, "jmp %%g1\\n\\trestore\\n" );
 715             }
 716
 717 #elif defined(__powerpc__)
 718             fprintf(outfile, "\taddi %s, %s, -0x4\\n\"\n", ppc_reg[1], ppc_reg[1]);
 719             fprintf(outfile, "\t\"\\tstw  %s, 0(%s)\\n\"\n",    ppc_reg[9], ppc_reg[1]);
 720             fprintf(outfile, "\t\"\\taddi %s, %s, -0x4\\n\"\n", ppc_reg[1], ppc_reg[1]);
 721             fprintf(outfile, "\t\"\\tstw  %s, 0(%s)\\n\"\n",    ppc_reg[8], ppc_reg[1]);
 722             fprintf(outfile, "\t\"\\taddi %s, %s, -0x4\\n\"\n", ppc_reg[1], ppc_reg[1]);
 723             fprintf(outfile, "\t\"\\tstw  %s, 0(%s)\\n\"\n",    ppc_reg[7], ppc_reg[1]);
 724
 725             fprintf(outfile, "\t\"\\tlis %s, " ppc_high(__ASM_NAME("imports") "+ %d")  "\\n\"\n", ppc_reg[9], pos);
 726             fprintf(outfile, "\t\"\\tla  %s, " ppc_low (__ASM_NAME("imports") "+ %d") "(%s)\\n\"\n", ppc_reg[8], pos, ppc_reg[9]);
 727             fprintf(outfile, "\t\"\\tlwz  %s, 0(%s)\\n\"\n", ppc_reg[7], ppc_reg[8]);
 728             fprintf(outfile, "\t\"\\tmtctr %s\\n\"\n", ppc_reg[7]);
 729
 730             fprintf(outfile, "\t\"\\tlwz  %s, 0(%s)\\n\"\n",   ppc_reg[7], ppc_reg[1]);
 731             fprintf(outfile, "\t\"\\taddi %s, %s, 0x4\\n\"\n", ppc_reg[1], ppc_reg[1]);
 732             fprintf(outfile, "\t\"\\tlwz  %s, 0(%s)\\n\"\n",   ppc_reg[8], ppc_reg[1]);
 733             fprintf(outfile, "\t\"\\taddi %s, %s, 0x4\\n\"\n", ppc_reg[1], ppc_reg[1]);
 734             fprintf(outfile, "\t\"\\tlwz  %s, 0(%s)\\n\"\n",   ppc_reg[9], ppc_reg[1]);
 735             fprintf(outfile, "\t\"\\taddi %s, %s, 0x4\\n\"\n", ppc_reg[1], ppc_reg[1]);
 736             fprintf(outfile, "\t\"\\tbctr\\n");
 737 #else
 738 #error You need to define import thunks for your architecture!
 739 #endif
 740             fprintf( outfile, "\"\n" );
 741         }
 742         pos += 4;
 743     }
 744     fprintf( outfile, "\".text\");\n#ifndef __GNUC__\n}\n#endif\n\n" );
 745
 746  done:
 747     return nb_imm;
 748 }
 749
 750 /* output the delayed import table of a Win32 module */
 751 static int output_delayed_imports( FILE *outfile, const DLLSPEC *spec )
 752 {
 753     int i, idx, j, pos;
 754
 755     if (!nb_delayed) goto done;
 756
 757     for (i = 0; i < nb_imports; i++)
 758     {
 759         if (!dll_imports[i]->delay) continue;
 760         fprintf( outfile, "static void *__wine_delay_imp_%d_hmod;\n", i);
 761         for (j = 0; j < dll_imports[i]->nb_imports; j++)
 762         {
 763             ORDDEF *odp = dll_imports[i]->imports[j];
 764             const char *name = odp->name ? odp->name : odp->export_name;
 765             fprintf( outfile, "void __wine_delay_imp_%d_%s();\n", i, name );
 766         }
 767     }
 768     fprintf( outfile, "\n" );
 769     fprintf( outfile, "static struct {\n" );
 770     fprintf( outfile, "  struct ImgDelayDescr {\n" );
 771     fprintf( outfile, "    unsigned int  grAttrs;\n" );
 772     fprintf( outfile, "    const char   *szName;\n" );
 773     fprintf( outfile, "    void        **phmod;\n" );
 774     fprintf( outfile, "    void        **pIAT;\n" );
 775     fprintf( outfile, "    const char  **pINT;\n" );
 776     fprintf( outfile, "    void*         pBoundIAT;\n" );
 777     fprintf( outfile, "    void*         pUnloadIAT;\n" );
 778     fprintf( outfile, "    unsigned long dwTimeStamp;\n" );
 779     fprintf( outfile, "  } imp[%d];\n", nb_delayed );
 780     fprintf( outfile, "  void         *IAT[%d];\n", total_delayed );
 781     fprintf( outfile, "  const char   *INT[%d];\n", total_delayed );
 782     fprintf( outfile, "} delay_imports = {\n" );
 783     fprintf( outfile, "  {\n" );
 784     for (i = j = 0; i < nb_imports; i++)
 785     {
 786         if (!dll_imports[i]->delay) continue;
 787         fprintf( outfile, "    { 0, \"%s\", &__wine_delay_imp_%d_hmod, &delay_imports.IAT[%d], &delay_imports.INT[%d], 0, 0, 0 },\n",
 788                  dll_imports[i]->spec->file_name, i, j, j );
 789         j += dll_imports[i]->nb_imports;
 790     }
 791     fprintf( outfile, "  },\n  {\n" );
 792     for (i = 0; i < nb_imports; i++)
 793     {
 794         if (!dll_imports[i]->delay) continue;
 795         fprintf( outfile, "    /* %s */\n", dll_imports[i]->spec->file_name );
 796         for (j = 0; j < dll_imports[i]->nb_imports; j++)
 797         {
 798             ORDDEF *odp = dll_imports[i]->imports[j];
 799             const char *name = odp->name ? odp->name : odp->export_name;
 800             fprintf( outfile, "    &__wine_delay_imp_%d_%s,\n", i, name );
 801         }
 802     }
 803     fprintf( outfile, "  },\n  {\n" );
 804     for (i = 0; i < nb_imports; i++)
 805     {
 806         if (!dll_imports[i]->delay) continue;
 807         fprintf( outfile, "    /* %s */\n", dll_imports[i]->spec->file_name );
 808         for (j = 0; j < dll_imports[i]->nb_imports; j++)
 809         {
 810             ORDDEF *odp = dll_imports[i]->imports[j];
 811             if (!odp->name)
 812                 fprintf( outfile, "    (char *)%d,\n", odp->ordinal );
 813             else
 814                 fprintf( outfile, "    \"%s\",\n", odp->name );
 815         }
 816     }
 817     fprintf( outfile, "  }\n};\n\n" );
 818
 819     /* check if there's some stub defined. if so, exception struct
 820      *  is already defined, so don't emit it twice
 821      */
 822     for (i = 0; i < spec->nb_entry_points; i++) if (spec->entry_points[i].type == TYPE_STUB) break;
 823
 824     if (i == spec->nb_entry_points) {
 825        fprintf( outfile, "struct exc_record {\n" );
 826        fprintf( outfile, "  unsigned int code, flags;\n" );
 827        fprintf( outfile, "  void *rec, *addr;\n" );
 828        fprintf( outfile, "  unsigned int params;\n" );
 829        fprintf( outfile, "  const void *info[15];\n" );
 830        fprintf( outfile, "};\n\n" );
 831        fprintf( outfile, "extern void __stdcall RtlRaiseException( struct exc_record * );\n" );
 832     }
 833
 834     fprintf( outfile, "extern void * __stdcall LoadLibraryA(const char*);\n");
 835     fprintf( outfile, "extern void * __stdcall GetProcAddress(void *, const char*);\n");
 836     fprintf( outfile, "\n" );
 837
 838     fprintf( outfile, "void *__stdcall __wine_delay_load( int idx_nr )\n" );
 839     fprintf( outfile, "{\n" );
 840     fprintf( outfile, "  int idx = idx_nr >> 16, nr = idx_nr & 0xffff;\n" );
 841     fprintf( outfile, "  struct ImgDelayDescr *imd = delay_imports.imp + idx;\n" );
 842     fprintf( outfile, "  void **pIAT = imd->pIAT + nr;\n" );
 843     fprintf( outfile, "  const char** pINT = imd->pINT + nr;\n" );
 844     fprintf( outfile, "  void *fn;\n\n" );
 845
 846     fprintf( outfile, "  if (!*imd->phmod) *imd->phmod = LoadLibraryA(imd->szName);\n" );
 847     fprintf( outfile, "  if (*imd->phmod && (fn = GetProcAddress(*imd->phmod, *pINT)))\n");
 848     fprintf( outfile, "    /* patch IAT with final value */\n" );
 849     fprintf( outfile, "    return *pIAT = fn;\n" );
 850     fprintf( outfile, "  else {\n");
 851     fprintf( outfile, "    struct exc_record rec;\n" );
 852     fprintf( outfile, "    rec.code    = 0x80000100;\n" );
 853     fprintf( outfile, "    rec.flags   = 1;\n" );
 854     fprintf( outfile, "    rec.rec     = 0;\n" );
 855     fprintf( outfile, "    rec.params  = 2;\n" );
 856     fprintf( outfile, "    rec.info[0] = imd->szName;\n" );
 857     fprintf( outfile, "    rec.info[1] = *pINT;\n" );
 858     fprintf( outfile, "#ifdef __GNUC__\n" );
 859     fprintf( outfile, "    rec.addr = __builtin_return_address(1);\n" );
 860     fprintf( outfile, "#else\n" );
 861     fprintf( outfile, "    rec.addr = 0;\n" );
 862     fprintf( outfile, "#endif\n" );
 863     fprintf( outfile, "    for (;;) RtlRaiseException( &rec );\n" );
 864     fprintf( outfile, "    return 0; /* shouldn't go here */\n" );
 865     fprintf( outfile, "  }\n}\n\n" );
 866
 867     fprintf( outfile, "#ifndef __GNUC__\n" );
 868     fprintf( outfile, "static void __asm__dummy_delay_import(void) {\n" );
 869     fprintf( outfile, "#endif\n" );
 870
 871     fprintf( outfile, "asm(\".align %d\\n\"\n", get_alignment(8) );
 872     fprintf( outfile, "    \"\\t" __ASM_FUNC("__wine_delay_load_asm") "\\n\"\n" );
 873     fprintf( outfile, "    \"" __ASM_NAME("__wine_delay_load_asm") ":\\n\"\n" );
 874 #if defined(__i386__)
 875     fprintf( outfile, "    \"\\tpushl %%ecx\\n\\tpushl %%edx\\n\\tpushl %%eax\\n\"\n" );
 876     fprintf( outfile, "    \"\\tcall __wine_delay_load\\n\"\n" );
 877     fprintf( outfile, "    \"\\tpopl %%edx\\n\\tpopl %%ecx\\n\\tjmp *%%eax\\n\"\n" );
 878 #elif defined(__sparc__)
 879     fprintf( outfile, "    \"\\tsave %%sp, -96, %%sp\\n\"\n" );
 880     fprintf( outfile, "    \"\\tcall __wine_delay_load\\n\"\n" );
 881     fprintf( outfile, "    \"\\tmov %%g1, %%o0\\n\"\n" );
 882     fprintf( outfile, "    \"\\tjmp %%o0\\n\\trestore\\n\"\n" );
 883 #elif defined(__powerpc__)
 884     /* Save all callee saved registers into a stackframe. */
 885     fprintf( outfile, "    \"\\tstwu %s, -48(%s)\\n\"\n", ppc_reg[1], ppc_reg[1]);
 886     fprintf( outfile, "    \"\\tstw  %s,   4(%s)\\n\"\n", ppc_reg[3], ppc_reg[1]);
 887     fprintf( outfile, "    \"\\tstw  %s,   8(%s)\\n\"\n", ppc_reg[4], ppc_reg[1]);
 888     fprintf( outfile, "    \"\\tstw  %s,  12(%s)\\n\"\n", ppc_reg[5], ppc_reg[1]);
 889     fprintf( outfile, "    \"\\tstw  %s,  16(%s)\\n\"\n", ppc_reg[6], ppc_reg[1]);
 890     fprintf( outfile, "    \"\\tstw  %s,  20(%s)\\n\"\n", ppc_reg[7], ppc_reg[1]);
 891     fprintf( outfile, "    \"\\tstw  %s,  24(%s)\\n\"\n", ppc_reg[8], ppc_reg[1]);
 892     fprintf( outfile, "    \"\\tstw  %s,  28(%s)\\n\"\n", ppc_reg[9], ppc_reg[1]);
 893     fprintf( outfile, "    \"\\tstw  %s,  32(%s)\\n\"\n", ppc_reg[10], ppc_reg[1]);
 894     fprintf( outfile, "    \"\\tstw  %s,  36(%s)\\n\"\n", ppc_reg[11], ppc_reg[1]);
 895     fprintf( outfile, "    \"\\tstw  %s,  40(%s)\\n\"\n", ppc_reg[12], ppc_reg[1]);
 896
 897     /* r0 -> r3 (arg1) */
 898     fprintf( outfile, "    \"\\tmr %s, %s\\n\"\n", ppc_reg[3], ppc_reg[0]);
 899
 900     /* save return address */
 901     fprintf( outfile, "    \"\\tmflr %s\\n\"\n", ppc_reg[0]);
 902     fprintf( outfile, "    \"\\tstw  %s, 44(%s)\\n\"\n", ppc_reg[0], ppc_reg[1]);
 903
 904     /* Call the __wine_delay_load function, arg1 is arg1. */
 905     fprintf( outfile, "    \"\\tbl " __ASM_NAME("__wine_delay_load") "\\n\"\n");
 906
 907     /* Load return value from call into ctr register */
 908     fprintf( outfile, "    \"\\tmtctr %s\\n\"\n", ppc_reg[3]);
 909
 910     /* restore all saved registers and drop stackframe. */
 911     fprintf( outfile, "    \"\\tlwz  %s,   4(%s)\\n\"\n", ppc_reg[3], ppc_reg[1]);
 912     fprintf( outfile, "    \"\\tlwz  %s,   8(%s)\\n\"\n", ppc_reg[4], ppc_reg[1]);
 913     fprintf( outfile, "    \"\\tlwz  %s,  12(%s)\\n\"\n", ppc_reg[5], ppc_reg[1]);
 914     fprintf( outfile, "    \"\\tlwz  %s,  16(%s)\\n\"\n", ppc_reg[6], ppc_reg[1]);
 915     fprintf( outfile, "    \"\\tlwz  %s,  20(%s)\\n\"\n", ppc_reg[7], ppc_reg[1]);
 916     fprintf( outfile, "    \"\\tlwz  %s,  24(%s)\\n\"\n", ppc_reg[8], ppc_reg[1]);
 917     fprintf( outfile, "    \"\\tlwz  %s,  28(%s)\\n\"\n", ppc_reg[9], ppc_reg[1]);
 918     fprintf( outfile, "    \"\\tlwz  %s,  32(%s)\\n\"\n", ppc_reg[10], ppc_reg[1]);
 919     fprintf( outfile, "    \"\\tlwz  %s,  36(%s)\\n\"\n", ppc_reg[11], ppc_reg[1]);
 920     fprintf( outfile, "    \"\\tlwz  %s,  40(%s)\\n\"\n", ppc_reg[12], ppc_reg[1]);
 921
 922     /* Load return value from call into return register */
 923     fprintf( outfile, "    \"\\tlwz  %s,  44(%s)\\n\"\n", ppc_reg[0], ppc_reg[1]);
 924     fprintf( outfile, "    \"\\tmtlr %s\\n\"\n", ppc_reg[0]);
 925     fprintf( outfile, "    \"\\taddi %s, %s, 48\\n\"\n", ppc_reg[1], ppc_reg[1]);
 926
 927     /* branch to ctr register. */
 928     fprintf( outfile, "\"bctr\\n\"\n");
 929 #else
 930 #error You need to defined delayed import thunks for your architecture!
 931 #endif
 932
 933     for (i = idx = 0; i < nb_imports; i++)
 934     {
 935         if (!dll_imports[i]->delay) continue;
 936         for (j = 0; j < dll_imports[i]->nb_imports; j++)
 937         {
 938             char buffer[128];
 939             ORDDEF *odp = dll_imports[i]->imports[j];
 940             const char *name = odp->name ? odp->name : odp->export_name;
 941
 942             sprintf( buffer, "__wine_delay_imp_%d_%s", i, name );
 943             fprintf( outfile, "    \"\\t" __ASM_FUNC("%s") "\\n\"\n", buffer );
 944             fprintf( outfile, "    \"" __ASM_NAME("%s") ":\\n\"\n", buffer );
 945 #if defined(__i386__)
 946             fprintf( outfile, "    \"\\tmovl $%d, %%eax\\n\"\n", (idx << 16) | j );
 947             fprintf( outfile, "    \"\\tjmp __wine_delay_load_asm\\n\"\n" );
 948 #elif defined(__sparc__)
 949             fprintf( outfile, "    \"\\tset %d, %%g1\\n\"\n", (idx << 16) | j );
 950             fprintf( outfile, "    \"\\tb,a __wine_delay_load_asm\\n\"\n" );
 951 #elif defined(__powerpc__)
 952             /* g0 is a function scratch register or so I understand. */
 953             /* First load the upper half-word, and then the lower part */
 954             fprintf( outfile, "    \"\\tlis %s, %d\\n\"\n", ppc_reg[0], idx);
 955             fprintf( outfile, "    \"\\tli %s, %d\\n\"\n", ppc_reg[0], j);
 956             fprintf( outfile, "    \"\\tb " __ASM_NAME("__wine_delay_load_asm") "\\n\"\n");
 957 #else
 958 #error You need to defined delayed import thunks for your architecture!
 959 #endif
 960         }
 961         idx++;
 962     }
 963
 964     fprintf( outfile, "\n    \".data\\n\\t.align %d\\n\"\n", get_alignment(8) );
 965     pos = nb_delayed * 32;
 966     for (i = 0; i < nb_imports; i++)
 967     {
 968         if (!dll_imports[i]->delay) continue;
 969         for (j = 0; j < dll_imports[i]->nb_imports; j++, pos += 4)
 970         {
 971             ORDDEF *odp = dll_imports[i]->imports[j];
 972             const char *name = odp->name ? odp->name : odp->export_name;
 973
 974             fprintf( outfile, "    \"\\t" __ASM_FUNC("%s") "\\n\"\n", name );
 975             fprintf( outfile, "    \"\\t.globl " __ASM_NAME("%s") "\\n\"\n", name );
 976             fprintf( outfile, "    \"" __ASM_NAME("%s") ":\\n\\t\"", name );
 977 #if defined(__i386__)
 978             if (strstr( name, "__wine_call_from_16" ))
 979                 fprintf( outfile, "\".byte 0x2e\\n\\tjmp *(delay_imports+%d)\\n\\tnop\\n\"", pos );
 980             else
 981                 fprintf( outfile, "\"jmp *(delay_imports+%d)\\n\\tmovl %%esi,%%esi\\n\"", pos );
 982 #elif defined(__sparc__)
 983             if ( !UsePIC )
 984             {
 985                 fprintf( outfile, "\"sethi %%hi(delay_imports+%d), %%g1\\n\\t\"", pos );
 986                 fprintf( outfile, "\"ld [%%g1+%%lo(delay_imports+%d)], %%g1\\n\\t\"", pos );
 987                 fprintf( outfile, "\"jmp %%g1\\n\\tnop\\n\"" );
 988             }
 989             else
 990             {
 991                 /* Hmpf.  Stupid sparc assembler always interprets global variable
 992                    names as GOT offsets, so we have to do it the long way ... */
 993                 fprintf( outfile, "\"save %%sp, -96, %%sp\\n\"" );
 994                 fprintf( outfile, "\"0:\\tcall 1f\\n\\tnop\\n\"" );
 995                 fprintf( outfile, "\"1:\\tsethi %%hi(delay_imports+%d-0b), %%g1\\n\\t\"", pos );
 996                 fprintf( outfile, "\"or %%g1, %%lo(delay_imports+%d-0b), %%g1\\n\\t\"", pos );
 997                 fprintf( outfile, "\"ld [%%g1+%%o7], %%g1\\n\\t\"" );
 998                 fprintf( outfile, "\"jmp %%g1\\n\\trestore\\n\"" );
 999             }
1000
1001 #elif defined(__powerpc__)
1002             fprintf( outfile, "\t\"addi %s, %s, -0x4\\n\"\n", ppc_reg[1], ppc_reg[1]);
1003             fprintf( outfile, "\t\"\\tstw  %s, 0(%s)\\n\"\n",    ppc_reg[9], ppc_reg[1]);
1004             fprintf( outfile, "\t\"\\taddi %s, %s, -0x4\\n\"\n", ppc_reg[1], ppc_reg[1]);
1005             fprintf( outfile, "\t\"\\tstw  %s, 0(%s)\\n\"\n",    ppc_reg[8], ppc_reg[1]);
1006             fprintf( outfile, "\t\"\\taddi %s, %s, -0x4\\n\"\n", ppc_reg[1], ppc_reg[1]);
1007             fprintf( outfile, "\t\"\\tstw  %s, 0(%s)\\n\"\n",    ppc_reg[7], ppc_reg[1]);
1008             fprintf( outfile, "\t\"\\tlis %s, " ppc_high(__ASM_NAME("imports") "+ %d") "\\n\"\n", ppc_reg[9], pos);
1009             fprintf( outfile, "\t\"\\tla  %s, " ppc_low (__ASM_NAME("imports") "+ %d") "(%s)\\n\"\n", ppc_reg[8], pos, ppc_reg[9]);
1010             fprintf( outfile, "\t\"\\tlwz  %s, 0(%s)\\n\"\n", ppc_reg[7], ppc_reg[8]);
1011             fprintf( outfile, "\t\"\\tmtctr %s\\n\"\n", ppc_reg[7]);
1012
1013             fprintf( outfile, "\t\"\\tlwz  %s, 0(%s)\\n\"\n",   ppc_reg[7], ppc_reg[1]);
1014             fprintf( outfile, "\t\"\\taddi %s, %s, 0x4\\n\"\n", ppc_reg[1], ppc_reg[1]);
1015             fprintf( outfile, "\t\"\\tlwz  %s, 0(%s)\\n\"\n",   ppc_reg[8], ppc_reg[1]);
1016             fprintf( outfile, "\t\"\\taddi %s, %s, 0x4\\n\"\n", ppc_reg[1], ppc_reg[1]);
1017             fprintf( outfile, "\t\"\\tlwz  %s, 0(%s)\\n\"\n",   ppc_reg[9], ppc_reg[1]);
1018             fprintf( outfile, "\t\"\\taddi %s, %s, 0x4\\n\"\n", ppc_reg[1], ppc_reg[1]);
1019             fprintf( outfile, "\t\"\\tbctr\\n\"");
1020 #else
1021 #error You need to define delayed import thunks for your architecture!
1022 #endif
1023             fprintf( outfile, "\n" );
1024         }
1025     }
1026     fprintf( outfile, "\".text\");\n" );
1027     fprintf( outfile, "#ifndef __GNUC__\n" );
1028     fprintf( outfile, "}\n" );
1029     fprintf( outfile, "#endif\n" );
1030     fprintf( outfile, "\n" );
1031
1032  done:
1033     return nb_delayed;
1034 }
1035
1036 /* output the import and delayed import tables of a Win32 module
1037  * returns number of DLLs exported in 'immediate' mode
1038  */
1039 int output_imports( FILE *outfile, DLLSPEC *spec )
1040 {
1041    output_delayed_imports( outfile, spec );
1042    return output_immediate_imports( outfile );
1043 }