tools/winebuild/spec16.c

   1 /*
   2  * 16-bit spec files
   3  *
   4  * Copyright 1993 Robert J. Amstadt
   5  * Copyright 1995 Martin von Loewis
   6  * Copyright 1995, 1996, 1997 Alexandre Julliard
   7  * Copyright 1997 Eric Youngdale
   8  * Copyright 1999 Ulrich Weigand
   9  *
  10  * This library is free software; you can redistribute it and/or
  11  * modify it under the terms of the GNU Lesser General Public
  12  * License as published by the Free Software Foundation; either
  13  * version 2.1 of the License, or (at your option) any later version.
  14  *
  15  * This library is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18  * Lesser General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU Lesser General Public
  21  * License along with this library; if not, write to the Free Software
  22  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  23  */
  24
  25 #include "config.h"
  26 #include "wine/port.h"
  27
  28 #include <assert.h>
  29 #include <ctype.h>
  30
  31 #include "wine/winbase16.h"
  32
  33 #include "build.h"
  34
  35 /* sequences of nops to fill a certain number of words */
  36 static const char * const nop_sequence[4] =
  37 {
  38     ".byte 0x89,0xf6",  /* mov %esi,%esi */
  39     ".byte 0x8d,0x74,0x26,0x00",  /* lea 0x00(%esi),%esi */
  40     ".byte 0x8d,0xb6,0x00,0x00,0x00,0x00",  /* lea 0x00000000(%esi),%esi */
  41     ".byte 0x8d,0x74,0x26,0x00,0x8d,0x74,0x26,0x00" /* lea 0x00(%esi),%esi; lea 0x00(%esi),%esi */
  42 };
  43
  44 static inline int is_function( const ORDDEF *odp )
  45 {
  46     return (odp->type == TYPE_CDECL ||
  47             odp->type == TYPE_PASCAL ||
  48             odp->type == TYPE_VARARGS ||
  49             odp->type == TYPE_STUB);
  50 }
  51
  52 /*******************************************************************
  53  *         output_entries
  54  *
  55  * Output entries for individual symbols in the entry table.
  56  */
  57 static void output_entries( FILE *outfile, DLLSPEC *spec, int first, int count )
  58 {
  59     int i;
  60
  61     for (i = 0; i < count; i++)
  62     {
  63         ORDDEF *odp = spec->ordinals[first + i];
  64         fprintf( outfile, "\t.byte 0x03\n" );  /* flags: exported & public data */
  65         switch (odp->type)
  66         {
  67         case TYPE_CDECL:
  68         case TYPE_PASCAL:
  69         case TYPE_VARARGS:
  70         case TYPE_STUB:
  71             fprintf( outfile, "\t%s .L__wine_%s_%u-.L__wine_spec_code_segment\n",
  72                      get_asm_short_keyword(),
  73                      make_c_identifier(spec->dll_name), first + i );
  74             break;
  75         case TYPE_VARIABLE:
  76             fprintf( outfile, "\t%s .L__wine_%s_%u-.L__wine_spec_data_segment\n",
  77                      get_asm_short_keyword(),
  78                      make_c_identifier(spec->dll_name), first + i );
  79             break;
  80         case TYPE_ABS:
  81             fprintf( outfile, "\t%s 0x%04x  /* %s */\n",
  82                      get_asm_short_keyword(), odp->u.abs.value, odp->name );
  83             break;
  84         default:
  85             assert(0);
  86         }
  87     }
  88 }
  89
  90
  91 /*******************************************************************
  92  *         output_entry_table
  93  */
  94 static void output_entry_table( FILE *outfile, DLLSPEC *spec )
  95 {
  96     int i, prev = 0, prev_sel = -1, bundle_count = 0;
  97
  98     for (i = 1; i <= spec->limit; i++)
  99     {
 100         int selector = 0;
 101         ORDDEF *odp = spec->ordinals[i];
 102         if (!odp) continue;
 103
 104         switch (odp->type)
 105         {
 106         case TYPE_CDECL:
 107         case TYPE_PASCAL:
 108         case TYPE_VARARGS:
 109         case TYPE_STUB:
 110             selector = 1;  /* Code selector */
 111             break;
 112         case TYPE_VARIABLE:
 113             selector = 2;  /* Data selector */
 114             break;
 115         case TYPE_ABS:
 116             selector = 0xfe;  /* Constant selector */
 117             break;
 118         default:
 119             continue;
 120         }
 121
 122         if (prev + 1 != i || prev_sel != selector || bundle_count == 255)
 123         {
 124             /* need to start a new bundle */
 125
 126             /* flush previous bundle */
 127             if (bundle_count)
 128             {
 129                 fprintf( outfile, "\t/* %s.%d - %s.%d */\n",
 130                          spec->dll_name, prev - bundle_count + 1, spec->dll_name, prev );
 131                 fprintf( outfile, "\t.byte 0x%02x,0x%02x\n", bundle_count, prev_sel );
 132                 output_entries( outfile, spec, prev - bundle_count + 1, bundle_count );
 133             }
 134
 135             if (prev + 1 != i)
 136             {
 137                 int skip = i - (prev + 1);
 138                 while (skip > 255)
 139                 {
 140                     fprintf( outfile, "\t.byte 0xff,0x00\n" );
 141                     skip -= 255;
 142                 }
 143                 fprintf( outfile, "\t.byte 0x%02x,0x00\n", skip );
 144             }
 145
 146             bundle_count = 0;
 147             prev_sel = selector;
 148         }
 149         bundle_count++;
 150         prev = i;
 151     }
 152
 153     /* flush last bundle */
 154     if (bundle_count)
 155     {
 156         fprintf( outfile, "\t.byte 0x%02x,0x%02x\n", bundle_count, prev_sel );
 157         output_entries( outfile, spec, prev - bundle_count + 1, bundle_count );
 158     }
 159     fprintf( outfile, "\t.byte 0x00\n" );
 160 }
 161
 162
 163 /*******************************************************************
 164  *         output_resident_name
 165  */
 166 static void output_resident_name( FILE *outfile, const char *string, int ordinal )
 167 {
 168     unsigned int i, len = strlen(string);
 169
 170     fprintf( outfile, "\t.byte 0x%02x", len );
 171     for (i = 0; i < len; i++) fprintf( outfile, ",0x%02x", (unsigned char)toupper(string[i]) );
 172     fprintf( outfile, " /* %s */\n", string );
 173     fprintf( outfile, "\t%s %u\n", get_asm_short_keyword(), ordinal );
 174 }
 175
 176
 177 /*******************************************************************
 178  *         get_callfrom16_name
 179  */
 180 static const char *get_callfrom16_name( const ORDDEF *odp )
 181 {
 182     static char buffer[80];
 183
 184     sprintf( buffer, "%s_%s_%s",
 185              (odp->type == TYPE_PASCAL) ? "p" :
 186              (odp->type == TYPE_VARARGS) ? "v" : "c",
 187              (odp->flags & FLAG_REGISTER) ? "regs" :
 188              (odp->flags & FLAG_RET16) ? "word" : "long",
 189              odp->u.func.arg_types );
 190     return buffer;
 191 }
 192
 193
 194 /*******************************************************************
 195  *         get_relay_name
 196  */
 197 static const char *get_relay_name( const ORDDEF *odp )
 198 {
 199     static char buffer[80];
 200     char *p;
 201
 202     switch(odp->type)
 203     {
 204     case TYPE_PASCAL:
 205         strcpy( buffer, "p_" );
 206         break;
 207     case TYPE_VARARGS:
 208         strcpy( buffer, "v_" );
 209         break;
 210     case TYPE_CDECL:
 211     case TYPE_STUB:
 212         strcpy( buffer, "c_" );
 213         break;
 214     default:
 215         assert(0);
 216     }
 217     strcat( buffer, odp->u.func.arg_types );
 218     for (p = buffer + 2; *p; p++)
 219     {
 220         /* map string types to the corresponding plain pointer type */
 221         if (*p == 't') *p = 'p';
 222         else if (*p == 'T') *p = 'l';
 223     }
 224     if (odp->flags & FLAG_REGISTER) strcat( buffer, "_regs" );
 225     return buffer;
 226 }
 227
 228
 229 /*******************************************************************
 230  *         get_function_argsize
 231  */
 232 static int get_function_argsize( const ORDDEF *odp )
 233 {
 234     const char *args;
 235     int argsize = 0;
 236
 237     for (args = odp->u.func.arg_types; *args; args++)
 238     {
 239         switch (*args)
 240         {
 241         case 'w':  /* word */
 242         case 's':  /* s_word */
 243             argsize += 2;
 244             break;
 245         case 'l':  /* long or segmented pointer */
 246         case 'T':  /* segmented pointer to null-terminated string */
 247         case 'p':  /* linear pointer */
 248         case 't':  /* linear pointer to null-terminated string */
 249             argsize += 4;
 250             break;
 251         default:
 252             assert(0);
 253         }
 254     }
 255     return argsize;
 256 }
 257
 258
 259 /*******************************************************************
 260  *         output_call16_function
 261  *
 262  * Build a 16-bit-to-Wine callback glue function.
 263  *
 264  * The generated routines are intended to be used as argument conversion
 265  * routines to be called by the CallFrom16... core. Thus, the prototypes of
 266  * the generated routines are (see also CallFrom16):
 267  *
 268  *  extern WORD WINAPI __wine_spec_call16_C_xxx( FARPROC func, LPBYTE args );
 269  *  extern LONG WINAPI __wine_spec_call16_C_xxx( FARPROC func, LPBYTE args );
 270  *  extern void WINAPI __wine_spec_call16_C_xxx_regs( FARPROC func, LPBYTE args, CONTEXT86 *context );
 271  *
 272  * where 'C' is the calling convention ('p' for pascal or 'c' for cdecl),
 273  * and each 'x' is an argument  ('w'=word, 's'=signed word, 'l'=long,
 274  * 'p'=linear pointer, 't'=linear pointer to null-terminated string,
 275  * 'T'=segmented pointer to null-terminated string).
 276  *
 277  * The generated routines fetch the arguments from the 16-bit stack (pointed
 278  * to by 'args'); the offsets of the single argument values are computed
 279  * according to the calling convention and the argument types.  Then, the
 280  * 32-bit entry point is called with these arguments.
 281  *
 282  * For register functions, the arguments (if present) are converted just
 283  * the same as for normal functions, but in addition the CONTEXT86 pointer
 284  * filled with the current register values is passed to the 32-bit routine.
 285  */
 286 static void output_call16_function( FILE *outfile, ORDDEF *odp )
 287 {
 288     char name[256];
 289     int i, pos, stack_words;
 290     const char *args = odp->u.func.arg_types;
 291     int argsize = get_function_argsize( odp );
 292     int needs_ldt = strchr( args, 'p' ) || strchr( args, 't' );
 293
 294     sprintf( name, ".L__wine_spec_call16_%s", get_relay_name(odp) );
 295
 296     fprintf( outfile, "\t.align %d\n", get_alignment(4) );
 297     fprintf( outfile, "\t%s\n", func_declaration(name) );
 298     fprintf( outfile, "%s:\n", name );
 299     fprintf( outfile, "\tpushl %%ebp\n" );
 300     fprintf( outfile, "\tmovl %%esp,%%ebp\n" );
 301     stack_words = 2;
 302     if (needs_ldt)
 303     {
 304         fprintf( outfile, "\tpushl %%esi\n" );
 305         stack_words++;
 306         if (UsePIC)
 307         {
 308             fprintf( outfile, "\tcall %s\n", asm_name("__wine_spec_get_pc_thunk_eax") );
 309             fprintf( outfile, "1:\tmovl wine_ldt_copy_ptr-1b(%%eax),%%esi\n" );
 310         }
 311         else
 312             fprintf( outfile, "\tmovl $%s,%%esi\n", asm_name("wine_ldt_copy") );
 313     }
 314
 315     /* preserve 16-byte stack alignment */
 316     stack_words += strlen(args);
 317     if ((odp->flags & FLAG_REGISTER) || (odp->type == TYPE_VARARGS)) stack_words++;
 318     if (stack_words % 4) fprintf( outfile, "\tsubl $%d,%%esp\n", 16 - 4 * (stack_words % 4) );
 319
 320     if (args[0] || odp->type == TYPE_VARARGS)
 321         fprintf( outfile, "\tmovl 12(%%ebp),%%ecx\n" );  /* args */
 322
 323     if (odp->flags & FLAG_REGISTER)
 324     {
 325         fprintf( outfile, "\tpushl 16(%%ebp)\n" );  /* context */
 326     }
 327     else if (odp->type == TYPE_VARARGS)
 328     {
 329         fprintf( outfile, "\tleal %d(%%ecx),%%eax\n", argsize );
 330         fprintf( outfile, "\tpushl %%eax\n" );  /* va_list16 */
 331     }
 332
 333     pos = (odp->type == TYPE_PASCAL) ? 0 : argsize;
 334     for (i = strlen(args) - 1; i >= 0; i--)
 335     {
 336         switch (args[i])
 337         {
 338         case 'w':  /* word */
 339             if (odp->type != TYPE_PASCAL) pos -= 2;
 340             fprintf( outfile, "\tmovzwl %d(%%ecx),%%eax\n", pos );
 341             fprintf( outfile, "\tpushl %%eax\n" );
 342             if (odp->type == TYPE_PASCAL) pos += 2;
 343             break;
 344
 345         case 's':  /* s_word */
 346             if (odp->type != TYPE_PASCAL) pos -= 2;
 347             fprintf( outfile, "\tmovswl %d(%%ecx),%%eax\n", pos );
 348             fprintf( outfile, "\tpushl %%eax\n" );
 349             if (odp->type == TYPE_PASCAL) pos += 2;
 350             break;
 351
 352         case 'l':  /* long or segmented pointer */
 353         case 'T':  /* segmented pointer to null-terminated string */
 354             if (odp->type != TYPE_PASCAL) pos -= 4;
 355             fprintf( outfile, "\tpushl %d(%%ecx)\n", pos );
 356             if (odp->type == TYPE_PASCAL) pos += 4;
 357             break;
 358
 359         case 'p':  /* linear pointer */
 360         case 't':  /* linear pointer to null-terminated string */
 361             if (odp->type != TYPE_PASCAL) pos -= 4;
 362             fprintf( outfile, "\tmovzwl %d(%%ecx),%%edx\n", pos + 2 ); /* sel */
 363             fprintf( outfile, "\tshr $3,%%edx\n" );
 364             fprintf( outfile, "\tmovzwl %d(%%ecx),%%eax\n", pos ); /* offset */
 365             fprintf( outfile, "\taddl (%%esi,%%edx,4),%%eax\n" );
 366             fprintf( outfile, "\tpushl %%eax\n" );
 367             if (odp->type == TYPE_PASCAL) pos += 4;
 368             break;
 369
 370         default:
 371             assert(0);
 372         }
 373     }
 374
 375     fprintf( outfile, "\tcall *8(%%ebp)\n" );
 376
 377     if (needs_ldt) fprintf( outfile, "\tmovl -4(%%ebp),%%esi\n" );
 378     if (odp->flags & FLAG_RET16) fprintf( outfile, "\tmovzwl %%ax,%%eax\n" );
 379
 380     fprintf( outfile, "\tleave\n" );
 381     fprintf( outfile, "\tret\n" );
 382     output_function_size( outfile, name );
 383 }
 384
 385
 386 /*******************************************************************
 387  *         callfrom16_type_compare
 388  *
 389  * Compare two callfrom16 sequences.
 390  */
 391 static int callfrom16_type_compare( const void *e1, const void *e2 )
 392 {
 393     const ORDDEF *odp1 = *(const ORDDEF * const *)e1;
 394     const ORDDEF *odp2 = *(const ORDDEF * const *)e2;
 395     int retval;
 396     int type1 = odp1->type;
 397     int type2 = odp2->type;
 398
 399     if (type1 == TYPE_STUB) type1 = TYPE_CDECL;
 400     if (type2 == TYPE_STUB) type2 = TYPE_CDECL;
 401
 402     if ((retval = type1 - type2) != 0) return retval;
 403
 404     type1 = odp1->flags & (FLAG_RET16|FLAG_REGISTER);
 405     type2 = odp2->flags & (FLAG_RET16|FLAG_REGISTER);
 406
 407     if ((retval = type1 - type2) != 0) return retval;
 408
 409     return strcmp( odp1->u.func.arg_types, odp2->u.func.arg_types );
 410 }
 411
 412
 413 /*******************************************************************
 414  *         relay_type_compare
 415  *
 416  * Same as callfrom16_type_compare but ignores differences that don't affect the resulting relay function.
 417  */
 418 static int relay_type_compare( const void *e1, const void *e2 )
 419 {
 420     const ORDDEF *odp1 = *(const ORDDEF * const *)e1;
 421     const ORDDEF *odp2 = *(const ORDDEF * const *)e2;
 422     char name1[80];
 423
 424     strcpy( name1, get_relay_name(odp1) );
 425     return strcmp( name1, get_relay_name(odp2) );
 426 }
 427
 428
 429 /*******************************************************************
 430  *         sort_func_list
 431  *
 432  * Sort a list of functions, removing duplicates.
 433  */
 434 static int sort_func_list( ORDDEF **list, int count,
 435                            int (*compare)(const void *, const void *) )
 436 {
 437     int i, j;
 438
 439     qsort( list, count, sizeof(*list), compare );
 440
 441     for (i = j = 0; i < count; i++)
 442     {
 443         if (compare( &list[j], &list[i] )) list[++j] = list[i];
 444     }
 445     return j + 1;
 446 }
 447
 448
 449 /*******************************************************************
 450  *         output_init_code
 451  *
 452  * Output the dll initialization code.
 453  */
 454 static void output_init_code( FILE *outfile, const DLLSPEC *spec, const char *header_name )
 455 {
 456     char name[80];
 457
 458     sprintf( name, ".L__wine_spec_%s_init", make_c_identifier(spec->dll_name) );
 459
 460     fprintf( outfile, "\n/* dll initialization code */\n\n" );
 461     fprintf( outfile, "\t.text\n" );
 462     fprintf( outfile, "\t.align 4\n" );
 463     fprintf( outfile, "\t%s\n", func_declaration(name) );
 464     fprintf( outfile, "%s:\n", name );
 465     fprintf( outfile, "subl $4,%%esp\n" );
 466     if (UsePIC)
 467     {
 468         fprintf( outfile, "\tcall %s\n", asm_name("__wine_spec_get_pc_thunk_eax") );
 469         fprintf( outfile, "1:\tleal .L__wine_spec_file_name-1b(%%eax),%%ecx\n" );
 470         fprintf( outfile, "\tpushl %%ecx\n" );
 471         fprintf( outfile, "\tleal %s-1b(%%eax),%%ecx\n", header_name );
 472         fprintf( outfile, "\tpushl %%ecx\n" );
 473     }
 474     else
 475     {
 476         fprintf( outfile, "\tpushl $.L__wine_spec_file_name\n" );
 477         fprintf( outfile, "\tpushl $%s\n", header_name );
 478     }
 479     fprintf( outfile, "\tcall %s\n", asm_name("__wine_dll_register_16") );
 480     fprintf( outfile, "\taddl $12,%%esp\n" );
 481     fprintf( outfile, "\tret\n" );
 482     output_function_size( outfile, name );
 483
 484     sprintf( name, ".L__wine_spec_%s_fini", make_c_identifier(spec->dll_name) );
 485
 486     fprintf( outfile, "\t.align 4\n" );
 487     fprintf( outfile, "\t%s\n", func_declaration(name) );
 488     fprintf( outfile, "%s:\n", name );
 489     fprintf( outfile, "subl $8,%%esp\n" );
 490     if (UsePIC)
 491     {
 492         fprintf( outfile, "\tcall %s\n", asm_name("__wine_spec_get_pc_thunk_eax") );
 493         fprintf( outfile, "1:\tleal %s-1b(%%eax),%%ecx\n", header_name );
 494         fprintf( outfile, "\tpushl %%ecx\n" );
 495     }
 496     else
 497     {
 498         fprintf( outfile, "\tpushl $%s\n", header_name );
 499     }
 500     fprintf( outfile, "\tcall %s\n", asm_name("__wine_dll_unregister_16") );
 501     fprintf( outfile, "\taddl $12,%%esp\n" );
 502     fprintf( outfile, "\tret\n" );
 503     output_function_size( outfile, name );
 504
 505     if (target_platform == PLATFORM_APPLE)
 506     {
 507         fprintf( outfile, "\t.mod_init_func\n" );
 508         fprintf( outfile, "\t.align %d\n", get_alignment(4) );
 509         fprintf( outfile, "\t.long .L__wine_spec_%s_init\n", make_c_identifier(spec->dll_name) );
 510         fprintf( outfile, "\t.mod_term_func\n" );
 511         fprintf( outfile, "\t.align %d\n", get_alignment(4) );
 512         fprintf( outfile, "\t.long .L__wine_spec_%s_fini\n", make_c_identifier(spec->dll_name) );
 513     }
 514     else
 515     {
 516         fprintf( outfile, "\t.section \".init\",\"ax\"\n" );
 517         fprintf( outfile, "\tcall .L__wine_spec_%s_init\n", make_c_identifier(spec->dll_name) );
 518         fprintf( outfile, "\t.section \".fini\",\"ax\"\n" );
 519         fprintf( outfile, "\tcall .L__wine_spec_%s_fini\n", make_c_identifier(spec->dll_name) );
 520     }
 521 }
 522
 523
 524 /*******************************************************************
 525  *         BuildSpec16File
 526  *
 527  * Build a Win16 assembly file from a spec file.
 528  */
 529 void BuildSpec16File( FILE *outfile, DLLSPEC *spec )
 530 {
 531     ORDDEF **typelist;
 532     int i, j, nb_funcs;
 533     char header_name[256];
 534
 535     /* File header */
 536
 537     output_standard_file_header( outfile );
 538
 539     if (!spec->dll_name)  /* set default name from file name */
 540     {
 541         char *p;
 542         spec->dll_name = xstrdup( spec->file_name );
 543         if ((p = strrchr( spec->dll_name, '.' ))) *p = 0;
 544     }
 545
 546     /* Build sorted list of all argument types, without duplicates */
 547
 548     typelist = xmalloc( (spec->limit + 1) * sizeof(*typelist) );
 549
 550     for (i = nb_funcs = 0; i <= spec->limit; i++)
 551     {
 552         ORDDEF *odp = spec->ordinals[i];
 553         if (!odp) continue;
 554         if (is_function( odp )) typelist[nb_funcs++] = odp;
 555     }
 556
 557     nb_funcs = sort_func_list( typelist, nb_funcs, callfrom16_type_compare );
 558
 559     /* Output the module structure */
 560
 561     sprintf( header_name, "__wine_spec_%s_dos_header", make_c_identifier(spec->dll_name) );
 562     fprintf( outfile, "\n/* module data */\n\n" );
 563     fprintf( outfile, "\t.data\n" );
 564     fprintf( outfile, "\t.align %d\n", get_alignment(4) );
 565     fprintf( outfile, "%s:\n", header_name );
 566     fprintf( outfile, "\t%s 0x%04x\n", get_asm_short_keyword(),                      /* e_magic */
 567              IMAGE_DOS_SIGNATURE );
 568     fprintf( outfile, "\t%s 0\n", get_asm_short_keyword() );                         /* e_cblp */
 569     fprintf( outfile, "\t%s 0\n", get_asm_short_keyword() );                         /* e_cp */
 570     fprintf( outfile, "\t%s 0\n", get_asm_short_keyword() );                         /* e_crlc */
 571     fprintf( outfile, "\t%s 0\n", get_asm_short_keyword() );                         /* e_cparhdr */
 572     fprintf( outfile, "\t%s 0\n", get_asm_short_keyword() );                         /* e_minalloc */
 573     fprintf( outfile, "\t%s 0\n", get_asm_short_keyword() );                         /* e_maxalloc */
 574     fprintf( outfile, "\t%s 0\n", get_asm_short_keyword() );                         /* e_ss */
 575     fprintf( outfile, "\t%s 0\n", get_asm_short_keyword() );                         /* e_sp */
 576     fprintf( outfile, "\t%s 0\n", get_asm_short_keyword() );                         /* e_csum */
 577     fprintf( outfile, "\t%s 0\n", get_asm_short_keyword() );                         /* e_ip */
 578     fprintf( outfile, "\t%s 0\n", get_asm_short_keyword() );                         /* e_cs */
 579     fprintf( outfile, "\t%s 0\n", get_asm_short_keyword() );                         /* e_lfarlc */
 580     fprintf( outfile, "\t%s 0\n", get_asm_short_keyword() );                         /* e_ovno */
 581     fprintf( outfile, "\t%s 0,0,0,0\n", get_asm_short_keyword() );                   /* e_res */
 582     fprintf( outfile, "\t%s 0\n", get_asm_short_keyword() );                         /* e_oemid */
 583     fprintf( outfile, "\t%s 0\n", get_asm_short_keyword() );                         /* e_oeminfo */
 584     fprintf( outfile, "\t%s 0,0,0,0,0,0,0,0,0,0\n", get_asm_short_keyword() );       /* e_res2 */
 585     fprintf( outfile, "\t.long .L__wine_spec_ne_header-%s\n", header_name );         /* e_lfanew */
 586
 587     fprintf( outfile, ".L__wine_spec_ne_header:\n" );
 588     fprintf( outfile, "\t%s 0x%04x\n", get_asm_short_keyword(),                      /* ne_magic */
 589              IMAGE_OS2_SIGNATURE );
 590     fprintf( outfile, "\t.byte 0\n" );                                               /* ne_ver */
 591     fprintf( outfile, "\t.byte 0\n" );                                               /* ne_rev */
 592     fprintf( outfile, "\t%s .L__wine_spec_ne_enttab-.L__wine_spec_ne_header\n",      /* ne_enttab */
 593              get_asm_short_keyword() );
 594     fprintf( outfile, "\t%s .L__wine_spec_ne_enttab_end-.L__wine_spec_ne_enttab\n",  /* ne_cbenttab */
 595              get_asm_short_keyword() );
 596     fprintf( outfile, "\t.long 0\n" );                                               /* ne_crc */
 597     fprintf( outfile, "\t%s 0x%04x\n", get_asm_short_keyword(),                      /* ne_flags */
 598              NE_FFLAGS_SINGLEDATA | NE_FFLAGS_LIBMODULE );
 599     fprintf( outfile, "\t%s 2\n", get_asm_short_keyword() );                         /* ne_autodata */
 600     fprintf( outfile, "\t%s %u\n", get_asm_short_keyword(), spec->heap_size );       /* ne_heap */
 601     fprintf( outfile, "\t%s 0\n", get_asm_short_keyword() );                         /* ne_stack */
 602     fprintf( outfile, "\t.long 0\n" );                                               /* ne_csip */
 603     fprintf( outfile, "\t.long 0\n" );                                               /* ne_sssp */
 604     fprintf( outfile, "\t%s 2\n", get_asm_short_keyword() );                         /* ne_cseg */
 605     fprintf( outfile, "\t%s 0\n", get_asm_short_keyword() );                         /* ne_cmod */
 606     fprintf( outfile, "\t%s 0\n", get_asm_short_keyword() );                         /* ne_cbnrestab */
 607     fprintf( outfile, "\t%s .L__wine_spec_ne_segtab-.L__wine_spec_ne_header\n",      /* ne_segtab */
 608              get_asm_short_keyword() );
 609     fprintf( outfile, "\t%s .L__wine_spec_ne_rsrctab-.L__wine_spec_ne_header\n",     /* ne_rsrctab */
 610              get_asm_short_keyword() );
 611     fprintf( outfile, "\t%s .L__wine_spec_ne_restab-.L__wine_spec_ne_header\n",      /* ne_restab */
 612              get_asm_short_keyword() );
 613     fprintf( outfile, "\t%s .L__wine_spec_ne_modtab-.L__wine_spec_ne_header\n",      /* ne_modtab */
 614              get_asm_short_keyword() );
 615     fprintf( outfile, "\t%s .L__wine_spec_ne_imptab-.L__wine_spec_ne_header\n",      /* ne_imptab */
 616              get_asm_short_keyword() );
 617     fprintf( outfile, "\t.long 0\n" );                                   /* ne_nrestab */
 618     fprintf( outfile, "\t%s 0\n", get_asm_short_keyword() );             /* ne_cmovent */
 619     fprintf( outfile, "\t%s 0\n", get_asm_short_keyword() );             /* ne_align */
 620     fprintf( outfile, "\t%s 0\n", get_asm_short_keyword() );             /* ne_cres */
 621     fprintf( outfile, "\t.byte 0x%02x\n", NE_OSFLAGS_WINDOWS );          /* ne_exetyp */
 622     fprintf( outfile, "\t.byte 0x%02x\n", NE_AFLAGS_FASTLOAD );          /* ne_flagsothers */
 623     fprintf( outfile, "\t%s 0\n", get_asm_short_keyword() );             /* ne_pretthunks */
 624     fprintf( outfile, "\t%s 0\n", get_asm_short_keyword() );             /* ne_psegrefbytes */
 625     fprintf( outfile, "\t%s 0\n", get_asm_short_keyword() );             /* ne_swaparea */
 626     fprintf( outfile, "\t%s 0\n", get_asm_short_keyword() );             /* ne_expver */
 627
 628     /* segment table */
 629
 630     fprintf( outfile, "\n.L__wine_spec_ne_segtab:\n" );
 631
 632     /* code segment entry */
 633
 634     fprintf( outfile, "\t%s .L__wine_spec_code_segment-%s\n",  /* filepos */
 635              get_asm_short_keyword(), header_name );
 636     fprintf( outfile, "\t%s .L__wine_spec_code_segment_end-.L__wine_spec_code_segment\n", /* size */
 637              get_asm_short_keyword() );
 638     fprintf( outfile, "\t%s 0x%04x\n", get_asm_short_keyword(), NE_SEGFLAGS_32BIT );      /* flags */
 639     fprintf( outfile, "\t%s .L__wine_spec_code_segment_end-.L__wine_spec_code_segment\n", /* minsize */
 640              get_asm_short_keyword() );
 641
 642     /* data segment entry */
 643
 644     fprintf( outfile, "\t%s .L__wine_spec_data_segment-%s\n",  /* filepos */
 645              get_asm_short_keyword(), header_name );
 646     fprintf( outfile, "\t%s .L__wine_spec_data_segment_end-.L__wine_spec_data_segment\n", /* size */
 647              get_asm_short_keyword() );
 648     fprintf( outfile, "\t%s 0x%04x\n", get_asm_short_keyword(), NE_SEGFLAGS_DATA );      /* flags */
 649     fprintf( outfile, "\t%s .L__wine_spec_data_segment_end-.L__wine_spec_data_segment\n", /* minsize */
 650              get_asm_short_keyword() );
 651
 652     /* resource directory */
 653
 654     output_res16_directory( outfile, spec, header_name );
 655
 656     /* resident names table */
 657
 658     fprintf( outfile, "\n\t.align %d\n", get_alignment(2) );
 659     fprintf( outfile, ".L__wine_spec_ne_restab:\n" );
 660     output_resident_name( outfile, spec->dll_name, 0 );
 661     for (i = 1; i <= spec->limit; i++)
 662     {
 663         ORDDEF *odp = spec->ordinals[i];
 664         if (!odp || !odp->name[0]) continue;
 665         output_resident_name( outfile, odp->name, i );
 666     }
 667     fprintf( outfile, "\t.byte 0\n" );
 668
 669     /* imported names table */
 670
 671     fprintf( outfile, "\n\t.align %d\n", get_alignment(2) );
 672     fprintf( outfile, ".L__wine_spec_ne_modtab:\n" );
 673     fprintf( outfile, ".L__wine_spec_ne_imptab:\n" );
 674     fprintf( outfile, "\t.byte 0,0\n" );
 675
 676     /* entry table */
 677
 678     fprintf( outfile, "\n.L__wine_spec_ne_enttab:\n" );
 679     output_entry_table( outfile, spec );
 680     fprintf( outfile, ".L__wine_spec_ne_enttab_end:\n" );
 681
 682     /* code segment */
 683
 684     fprintf( outfile, "\n\t.align %d\n", get_alignment(2) );
 685     fprintf( outfile, ".L__wine_spec_code_segment:\n" );
 686
 687     for ( i = 0; i < nb_funcs; i++ )
 688     {
 689         unsigned int arg_types[2];
 690         int j, nop_words, argsize = 0;
 691
 692         if ( typelist[i]->type == TYPE_PASCAL )
 693             argsize = get_function_argsize( typelist[i] );
 694
 695         /* build the arg types bit fields */
 696         arg_types[0] = arg_types[1] = 0;
 697         for (j = 0; typelist[i]->u.func.arg_types[j]; j++)
 698         {
 699             int type = 0;
 700             switch(typelist[i]->u.func.arg_types[j])
 701             {
 702             case 'w': type = ARG_WORD; break;
 703             case 's': type = ARG_SWORD; break;
 704             case 'l': type = ARG_LONG; break;
 705             case 'p': type = ARG_PTR; break;
 706             case 't': type = ARG_STR; break;
 707             case 'T': type = ARG_SEGSTR; break;
 708             }
 709             arg_types[j / 10] |= type << (3 * (j % 10));
 710         }
 711         if (typelist[i]->type == TYPE_VARARGS) arg_types[j / 10] |= ARG_VARARG << (3 * (j % 10));
 712
 713         fprintf( outfile, ".L__wine_spec_callfrom16_%s:\n", get_callfrom16_name(typelist[i]) );
 714         fprintf( outfile, "\tpushl $.L__wine_spec_call16_%s\n", get_relay_name(typelist[i]) );
 715         fprintf( outfile, "\tlcall $0,$0\n" );
 716
 717         if (typelist[i]->flags & FLAG_REGISTER)
 718         {
 719             nop_words = 4;
 720         }
 721         else if (typelist[i]->flags & FLAG_RET16)
 722         {
 723             fprintf( outfile, "\torw %%ax,%%ax\n" );
 724             fprintf( outfile, "\tnop\n" );  /* so that the lretw is aligned */
 725             nop_words = 2;
 726         }
 727         else
 728         {
 729             fprintf( outfile, "shld $16,%%eax,%%edx\n" );
 730             fprintf( outfile, "orl %%eax,%%eax\n" );
 731             nop_words = 1;
 732         }
 733
 734         if (argsize)
 735         {
 736             fprintf( outfile, "lretw $%u\n", argsize );
 737             nop_words--;
 738         }
 739         else fprintf( outfile, "lretw\n" );
 740
 741         if (nop_words) fprintf( outfile, "\t%s\n", nop_sequence[nop_words-1] );
 742
 743         /* the movl is here so that the code contains only valid instructions, */
 744         /* it's never actually executed, we only care about the arg_types[] values */
 745         fprintf( outfile, "\t%s 0x86c7\n", get_asm_short_keyword() );
 746         fprintf( outfile, "\t.long 0x%08x,0x%08x\n", arg_types[0], arg_types[1] );
 747     }
 748
 749     for (i = 0; i <= spec->limit; i++)
 750     {
 751         ORDDEF *odp = spec->ordinals[i];
 752         if (!odp || !is_function( odp )) continue;
 753         fprintf( outfile, ".L__wine_%s_%u:\n", make_c_identifier(spec->dll_name), i );
 754         fprintf( outfile, "\tpushw %%bp\n" );
 755         fprintf( outfile, "\tpushl $%s\n",
 756                  asm_name( odp->type == TYPE_STUB ? get_stub_name( odp, spec ) : odp->link_name ));
 757         fprintf( outfile, "\tcallw .L__wine_spec_callfrom16_%s\n", get_callfrom16_name( odp ) );
 758     }
 759     fprintf( outfile, ".L__wine_spec_code_segment_end:\n" );
 760
 761     /* data segment */
 762
 763     fprintf( outfile, "\n.L__wine_spec_data_segment:\n" );
 764     fprintf( outfile, "\t.byte 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0\n" );  /* instance data */
 765     for (i = 0; i <= spec->limit; i++)
 766     {
 767         ORDDEF *odp = spec->ordinals[i];
 768         if (!odp || odp->type != TYPE_VARIABLE) continue;
 769         fprintf( outfile, ".L__wine_%s_%u:\n", make_c_identifier(spec->dll_name), i );
 770         fprintf( outfile, "\t.long " );
 771         for (j = 0; j < odp->u.var.n_values-1; j++)
 772             fprintf( outfile, "0x%08x,", odp->u.var.values[j] );
 773         fprintf( outfile, "0x%08x\n", odp->u.var.values[j] );
 774     }
 775     fprintf( outfile, ".L__wine_spec_data_segment_end:\n" );
 776
 777     /* resource data */
 778
 779     if (spec->nb_resources)
 780     {
 781         fprintf( outfile, "\n.L__wine_spec_resource_data:\n" );
 782         output_res16_data( outfile, spec );
 783     }
 784
 785     fprintf( outfile, "\t.byte 0\n" );  /* make sure the last symbol points to something */
 786
 787     /* relay functions */
 788
 789     nb_funcs = sort_func_list( typelist, nb_funcs, relay_type_compare );
 790     if (nb_funcs)
 791     {
 792         fprintf( outfile, "\n/* relay functions */\n\n" );
 793         fprintf( outfile, "\t.text\n" );
 794         for ( i = 0; i < nb_funcs; i++ ) output_call16_function( outfile, typelist[i] );
 795         fprintf( outfile, "\t.data\n" );
 796         fprintf( outfile, "wine_ldt_copy_ptr:\n" );
 797         fprintf( outfile, "\t.long %s\n", asm_name("wine_ldt_copy") );
 798     }
 799
 800     fprintf( outfile, "\n\t%s\n", get_asm_string_section() );
 801     fprintf( outfile, ".L__wine_spec_file_name:\n" );
 802     fprintf( outfile, "\t%s \"%s\"\n", get_asm_string_keyword(), spec->file_name );
 803
 804     output_stubs( outfile, spec );
 805     output_get_pc_thunk( outfile );
 806     output_init_code( outfile, spec, header_name );
 807
 808     free( typelist );
 809 }