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
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.
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.
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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
26 #include "wine/port.h"
33 #define NE_FFLAGS_SINGLEDATA 0x0001
34 #define NE_FFLAGS_LIBMODULE 0x8000
36 /* argument type flags for relay debugging */
39 ARG16_NONE
= 0, /* indicates end of arg list */
40 ARG16_WORD
, /* unsigned word */
41 ARG16_SWORD
, /* signed word */
42 ARG16_LONG
, /* long or segmented pointer */
43 ARG16_PTR
, /* linear pointer */
44 ARG16_STR
, /* linear pointer to null-terminated string */
45 ARG16_SEGSTR
, /* segmented pointer to null-terminated string */
46 ARG16_VARARG
/* start of varargs */
49 /* sequences of nops to fill a certain number of words */
50 static const char * const nop_sequence
[4] =
52 ".byte 0x89,0xf6", /* mov %esi,%esi */
53 ".byte 0x8d,0x74,0x26,0x00", /* lea 0x00(%esi),%esi */
54 ".byte 0x8d,0xb6,0x00,0x00,0x00,0x00", /* lea 0x00000000(%esi),%esi */
55 ".byte 0x8d,0x74,0x26,0x00,0x8d,0x74,0x26,0x00" /* lea 0x00(%esi),%esi; lea 0x00(%esi),%esi */
58 static inline int is_function( const ORDDEF
*odp
)
60 if (odp
->flags
& FLAG_EXPORT32
) return 0;
61 return (odp
->type
== TYPE_CDECL
||
62 odp
->type
== TYPE_PASCAL
||
63 odp
->type
== TYPE_VARARGS
||
64 odp
->type
== TYPE_STUB
);
67 static const char *get_args_str( const ORDDEF
*odp
)
69 static char buffer
[MAX_ARGUMENTS
*2+1];
73 for (i
= 0; i
< odp
->u
.func
.nb_args
; i
++)
75 switch (odp
->u
.func
.args
[i
])
77 case ARG_WORD
: strcat( buffer
, "w" ); break;
78 case ARG_SWORD
: strcat( buffer
, "s" ); break;
79 case ARG_SEGSTR
: strcat( buffer
, "T" ); break;
80 case ARG_STR
: strcat( buffer
, "t" ); break;
83 case ARG_SEGPTR
: strcat( buffer
, "l" ); break;
86 case ARG_INT128
: strcat( buffer
, "p" ); break;
88 case ARG_DOUBLE
: strcat( buffer
, "ll" ); break;
94 /*******************************************************************
97 * Output entries for individual symbols in the entry table.
99 static void output_entries( DLLSPEC
*spec
, int first
, int count
)
103 for (i
= 0; i
< count
; i
++)
105 ORDDEF
*odp
= spec
->ordinals
[first
+ i
];
106 output( "\t.byte 0x03\n" ); /* flags: exported & public data */
113 output( "\t.short .L__wine_%s_%u-.L__wine_spec_code_segment\n", spec
->c_name
, first
+ i
);
116 output( "\t.short .L__wine_%s_%u-.L__wine_spec_data_segment\n", spec
->c_name
, first
+ i
);
119 output( "\t.short 0x%04x /* %s */\n",
120 odp
->u
.abs
.value
, odp
->name
);
129 /*******************************************************************
132 static void output_entry_table( DLLSPEC
*spec
)
134 int i
, prev
= 0, prev_sel
= -1, bundle_count
= 0;
136 for (i
= 1; i
<= spec
->limit
; i
++)
139 ORDDEF
*odp
= spec
->ordinals
[i
];
141 if (odp
->flags
& FLAG_EXPORT32
) continue;
149 selector
= 1; /* Code selector */
152 selector
= 2; /* Data selector */
155 selector
= 0xfe; /* Constant selector */
161 if (prev
+ 1 != i
|| prev_sel
!= selector
|| bundle_count
== 255)
163 /* need to start a new bundle */
165 /* flush previous bundle */
168 output( "\t/* %s.%d - %s.%d */\n",
169 spec
->dll_name
, prev
- bundle_count
+ 1, spec
->dll_name
, prev
);
170 output( "\t.byte 0x%02x,0x%02x\n", bundle_count
, prev_sel
);
171 output_entries( spec
, prev
- bundle_count
+ 1, bundle_count
);
176 int skip
= i
- (prev
+ 1);
179 output( "\t.byte 0xff,0x00\n" );
182 output( "\t.byte 0x%02x,0x00\n", skip
);
192 /* flush last bundle */
195 output( "\t.byte 0x%02x,0x%02x\n", bundle_count
, prev_sel
);
196 output_entries( spec
, prev
- bundle_count
+ 1, bundle_count
);
198 output( "\t.byte 0x00\n" );
202 /*******************************************************************
203 * output_resident_name
205 static void output_resident_name( const char *string
, int ordinal
)
207 unsigned int i
, len
= strlen(string
);
209 output( "\t.byte 0x%02x", len
);
210 for (i
= 0; i
< len
; i
++) output( ",0x%02x", (unsigned char)toupper(string
[i
]) );
211 output( " /* %s */\n", string
);
212 output( "\t.short %u\n", ordinal
);
216 /*******************************************************************
217 * get_callfrom16_name
219 static const char *get_callfrom16_name( const ORDDEF
*odp
)
224 buffer
= strmake( "%s_%s_%s",
225 (odp
->type
== TYPE_PASCAL
) ? "p" :
226 (odp
->type
== TYPE_VARARGS
) ? "v" : "c",
227 (odp
->flags
& FLAG_REGISTER
) ? "regs" :
228 (odp
->flags
& FLAG_RET16
) ? "word" : "long",
234 /*******************************************************************
237 static const char *get_relay_name( const ORDDEF
*odp
)
239 static char buffer
[80];
245 strcpy( buffer
, "p_" );
248 strcpy( buffer
, "v_" );
252 strcpy( buffer
, "c_" );
257 strcat( buffer
, get_args_str(odp
) );
258 for (p
= buffer
+ 2; *p
; p
++)
260 /* map string types to the corresponding plain pointer type */
261 if (*p
== 't') *p
= 'p';
262 else if (*p
== 'T') *p
= 'l';
264 if (odp
->flags
& FLAG_REGISTER
) strcat( buffer
, "_regs" );
269 /*******************************************************************
270 * get_function_argsize
272 static int get_function_argsize( const ORDDEF
*odp
)
276 for (i
= 0; i
< odp
->u
.func
.nb_args
; i
++)
278 switch (odp
->u
.func
.args
[i
])
304 /*******************************************************************
305 * output_call16_function
307 * Build a 16-bit-to-Wine callback glue function.
309 * The generated routines are intended to be used as argument conversion
310 * routines to be called by the CallFrom16... core. Thus, the prototypes of
311 * the generated routines are (see also CallFrom16):
313 * extern WORD WINAPI __wine_spec_call16_C_xxx( FARPROC func, LPBYTE args );
314 * extern LONG WINAPI __wine_spec_call16_C_xxx( FARPROC func, LPBYTE args );
315 * extern void WINAPI __wine_spec_call16_C_xxx_regs( FARPROC func, LPBYTE args, CONTEXT86 *context );
317 * where 'C' is the calling convention ('p' for pascal or 'c' for cdecl),
318 * and each 'x' is an argument ('w'=word, 's'=signed word, 'l'=long,
319 * 'p'=linear pointer, 't'=linear pointer to null-terminated string,
320 * 'T'=segmented pointer to null-terminated string).
322 * The generated routines fetch the arguments from the 16-bit stack (pointed
323 * to by 'args'); the offsets of the single argument values are computed
324 * according to the calling convention and the argument types. Then, the
325 * 32-bit entry point is called with these arguments.
327 * For register functions, the arguments (if present) are converted just
328 * the same as for normal functions, but in addition the CONTEXT86 pointer
329 * filled with the current register values is passed to the 32-bit routine.
331 static void output_call16_function( ORDDEF
*odp
)
334 int i
, pos
, stack_words
;
335 int argsize
= get_function_argsize( odp
);
336 int needs_ldt
= (strpbrk( get_args_str( odp
), "pt" ) != NULL
);
338 name
= strmake( ".L__wine_spec_call16_%s", get_relay_name(odp
) );
340 output( "\t.align %d\n", get_alignment(4) );
341 output( "\t%s\n", func_declaration(name
) );
342 output( "%s:\n", name
);
343 output_cfi( ".cfi_startproc" );
344 output( "\tpushl %%ebp\n" );
345 output_cfi( ".cfi_adjust_cfa_offset 4" );
346 output_cfi( ".cfi_rel_offset %%ebp,0" );
347 output( "\tmovl %%esp,%%ebp\n" );
348 output_cfi( ".cfi_def_cfa_register %%ebp" );
352 output( "\tpushl %%esi\n" );
353 output_cfi( ".cfi_rel_offset %%esi,-4" );
357 output( "\tcall %s\n", asm_name("__wine_spec_get_pc_thunk_eax") );
358 output( "1:\tmovl wine_ldt_copy_ptr-1b(%%eax),%%esi\n" );
359 needs_get_pc_thunk
= 1;
362 output( "\tmovl $%s,%%esi\n", asm_name("wine_ldt_copy") );
365 /* preserve 16-byte stack alignment */
366 stack_words
+= odp
->u
.func
.nb_args
;
367 for (i
= 0; i
< odp
->u
.func
.nb_args
; i
++)
368 if (odp
->u
.func
.args
[i
] == ARG_DOUBLE
|| odp
->u
.func
.args
[i
] == ARG_INT64
) stack_words
++;
369 if ((odp
->flags
& FLAG_REGISTER
) || (odp
->type
== TYPE_VARARGS
)) stack_words
++;
370 if (stack_words
% 4) output( "\tsubl $%d,%%esp\n", 16 - 4 * (stack_words
% 4) );
372 if (odp
->u
.func
.nb_args
|| odp
->type
== TYPE_VARARGS
)
373 output( "\tmovl 12(%%ebp),%%ecx\n" ); /* args */
375 if (odp
->flags
& FLAG_REGISTER
)
377 output( "\tpushl 16(%%ebp)\n" ); /* context */
379 else if (odp
->type
== TYPE_VARARGS
)
381 output( "\tleal %d(%%ecx),%%eax\n", argsize
);
382 output( "\tpushl %%eax\n" ); /* va_list16 */
385 pos
= (odp
->type
== TYPE_PASCAL
) ? 0 : argsize
;
386 for (i
= odp
->u
.func
.nb_args
- 1; i
>= 0; i
--)
388 switch (odp
->u
.func
.args
[i
])
391 if (odp
->type
!= TYPE_PASCAL
) pos
-= 2;
392 output( "\tmovzwl %d(%%ecx),%%eax\n", pos
);
393 output( "\tpushl %%eax\n" );
394 if (odp
->type
== TYPE_PASCAL
) pos
+= 2;
398 if (odp
->type
!= TYPE_PASCAL
) pos
-= 2;
399 output( "\tmovswl %d(%%ecx),%%eax\n", pos
);
400 output( "\tpushl %%eax\n" );
401 if (odp
->type
== TYPE_PASCAL
) pos
+= 2;
406 if (odp
->type
!= TYPE_PASCAL
) pos
-= 4;
407 output( "\tpushl %d(%%ecx)\n", pos
);
408 if (odp
->type
== TYPE_PASCAL
) pos
+= 4;
414 if (odp
->type
!= TYPE_PASCAL
) pos
-= 4;
415 output( "\tpushl %d(%%ecx)\n", pos
);
416 if (odp
->type
== TYPE_PASCAL
) pos
+= 4;
423 if (odp
->type
!= TYPE_PASCAL
) pos
-= 4;
424 output( "\tmovzwl %d(%%ecx),%%edx\n", pos
+ 2 ); /* sel */
425 output( "\tshr $3,%%edx\n" );
426 output( "\tmovzwl %d(%%ecx),%%eax\n", pos
); /* offset */
427 output( "\taddl (%%esi,%%edx,4),%%eax\n" );
428 output( "\tpushl %%eax\n" );
429 if (odp
->type
== TYPE_PASCAL
) pos
+= 4;
434 output( "\tcall *8(%%ebp)\n" );
438 output( "\tmovl -4(%%ebp),%%esi\n" );
439 output_cfi( ".cfi_same_value %%esi" );
441 output( "\tleave\n" );
442 output_cfi( ".cfi_def_cfa %%esp,4" );
443 output_cfi( ".cfi_same_value %%ebp" );
445 output_cfi( ".cfi_endproc" );
446 output_function_size( name
);
451 /*******************************************************************
452 * callfrom16_type_compare
454 * Compare two callfrom16 sequences.
456 static int callfrom16_type_compare( const void *e1
, const void *e2
)
458 const ORDDEF
*odp1
= *(const ORDDEF
* const *)e1
;
459 const ORDDEF
*odp2
= *(const ORDDEF
* const *)e2
;
461 int type1
= odp1
->type
;
462 int type2
= odp2
->type
;
465 if (type1
== TYPE_STUB
) type1
= TYPE_CDECL
;
466 if (type2
== TYPE_STUB
) type2
= TYPE_CDECL
;
468 if ((retval
= type1
- type2
) != 0) return retval
;
470 type1
= odp1
->flags
& (FLAG_RET16
|FLAG_REGISTER
);
471 type2
= odp2
->flags
& (FLAG_RET16
|FLAG_REGISTER
);
473 if ((retval
= type1
- type2
) != 0) return retval
;
475 strcpy( args1
, get_args_str( odp1
));
476 return strcmp( args1
, get_args_str( odp2
));
480 /*******************************************************************
483 * Same as callfrom16_type_compare but ignores differences that don't affect the resulting relay function.
485 static int relay_type_compare( const void *e1
, const void *e2
)
487 const ORDDEF
*odp1
= *(const ORDDEF
* const *)e1
;
488 const ORDDEF
*odp2
= *(const ORDDEF
* const *)e2
;
491 strcpy( name1
, get_relay_name(odp1
) );
492 return strcmp( name1
, get_relay_name(odp2
) );
496 /*******************************************************************
499 * Sort a list of functions, removing duplicates.
501 static int sort_func_list( ORDDEF
**list
, int count
,
502 int (*compare
)(const void *, const void *) )
506 if (!count
) return 0;
507 qsort( list
, count
, sizeof(*list
), compare
);
509 for (i
= j
= 0; i
< count
; i
++)
511 if (compare( &list
[j
], &list
[i
] )) list
[++j
] = list
[i
];
517 /*******************************************************************
520 * Output code for a 16-bit module.
522 static void output_module16( DLLSPEC
*spec
)
525 ORDDEF
*entry_point
= NULL
;
528 /* store the main entry point as ordinal 0 */
532 assert(spec
->limit
== 0);
533 spec
->ordinals
= xmalloc( sizeof(spec
->ordinals
[0]) );
534 spec
->ordinals
[0] = NULL
;
536 if (spec
->init_func
&& !(spec
->characteristics
& IMAGE_FILE_DLL
))
538 entry_point
= xmalloc( sizeof(*entry_point
) );
539 entry_point
->type
= TYPE_PASCAL
;
540 entry_point
->ordinal
= 0;
541 entry_point
->lineno
= 0;
542 entry_point
->flags
= FLAG_REGISTER
;
543 entry_point
->name
= NULL
;
544 entry_point
->link_name
= xstrdup( spec
->init_func
);
545 entry_point
->export_name
= NULL
;
546 entry_point
->u
.func
.nb_args
= 0;
547 assert( !spec
->ordinals
[0] );
548 spec
->ordinals
[0] = entry_point
;
551 /* Build sorted list of all argument types, without duplicates */
553 typelist
= xmalloc( (spec
->limit
+ 1) * sizeof(*typelist
) );
555 for (i
= nb_funcs
= 0; i
<= spec
->limit
; i
++)
557 ORDDEF
*odp
= spec
->ordinals
[i
];
559 if (is_function( odp
)) typelist
[nb_funcs
++] = odp
;
562 nb_funcs
= sort_func_list( typelist
, nb_funcs
, callfrom16_type_compare
);
564 /* Output the module structure */
566 output( "\n/* module data */\n\n" );
567 output( "\t.data\n" );
568 output( "\t.align %d\n", get_alignment(4) );
569 output( ".L__wine_spec_dos_header:\n" );
570 output( "\t.short 0x5a4d\n" ); /* e_magic */
571 output( "\t.short 0\n" ); /* e_cblp */
572 output( "\t.short 0\n" ); /* e_cp */
573 output( "\t.short 0\n" ); /* e_crlc */
574 output( "\t.short 0\n" ); /* e_cparhdr */
575 output( "\t.short 0\n" ); /* e_minalloc */
576 output( "\t.short 0\n" ); /* e_maxalloc */
577 output( "\t.short 0\n" ); /* e_ss */
578 output( "\t.short 0\n" ); /* e_sp */
579 output( "\t.short 0\n" ); /* e_csum */
580 output( "\t.short 0\n" ); /* e_ip */
581 output( "\t.short 0\n" ); /* e_cs */
582 output( "\t.short 0\n" ); /* e_lfarlc */
583 output( "\t.short 0\n" ); /* e_ovno */
584 output( "\t.short 0,0,0,0\n" ); /* e_res */
585 output( "\t.short 0\n" ); /* e_oemid */
586 output( "\t.short 0\n" ); /* e_oeminfo */
587 output( "\t.short 0,0,0,0,0,0,0,0,0,0\n" ); /* e_res2 */
588 output( "\t.long .L__wine_spec_ne_header-.L__wine_spec_dos_header\n" );/* e_lfanew */
590 output( ".L__wine_spec_ne_header:\n" );
591 output( "\t.short 0x454e\n" ); /* ne_magic */
592 output( "\t.byte 0\n" ); /* ne_ver */
593 output( "\t.byte 0\n" ); /* ne_rev */
594 output( "\t.short .L__wine_spec_ne_enttab-.L__wine_spec_ne_header\n" );/* ne_enttab */
595 output( "\t.short .L__wine_spec_ne_enttab_end-.L__wine_spec_ne_enttab\n" );/* ne_cbenttab */
596 output( "\t.long 0\n" ); /* ne_crc */
597 output( "\t.short 0x%04x\n", NE_FFLAGS_SINGLEDATA
| /* ne_flags */
598 ((spec
->characteristics
& IMAGE_FILE_DLL
) ? NE_FFLAGS_LIBMODULE
: 0) );
599 output( "\t.short 2\n" ); /* ne_autodata */
600 output( "\t.short %u\n", spec
->heap_size
); /* ne_heap */
601 output( "\t.short 0\n" ); /* ne_stack */
602 if (!entry_point
) output( "\t.long 0\n" ); /* ne_csip */
603 else output( "\t.short .L__wine_%s_0-.L__wine_spec_code_segment,1\n", spec
->c_name
);
604 output( "\t.short 0,2\n" ); /* ne_sssp */
605 output( "\t.short 2\n" ); /* ne_cseg */
606 output( "\t.short 0\n" ); /* ne_cmod */
607 output( "\t.short 0\n" ); /* ne_cbnrestab */
608 output( "\t.short .L__wine_spec_ne_segtab-.L__wine_spec_ne_header\n" );/* ne_segtab */
609 output( "\t.short .L__wine_spec_ne_rsrctab-.L__wine_spec_ne_header\n" ); /* ne_rsrctab */
610 output( "\t.short .L__wine_spec_ne_restab-.L__wine_spec_ne_header\n" ); /* ne_restab */
611 output( "\t.short .L__wine_spec_ne_modtab-.L__wine_spec_ne_header\n" ); /* ne_modtab */
612 output( "\t.short .L__wine_spec_ne_imptab-.L__wine_spec_ne_header\n" ); /* ne_imptab */
613 output( "\t.long 0\n" ); /* ne_nrestab */
614 output( "\t.short 0\n" ); /* ne_cmovent */
615 output( "\t.short 0\n" ); /* ne_align */
616 output( "\t.short 0\n" ); /* ne_cres */
617 output( "\t.byte 0x02\n" ); /* ne_exetyp = NE_OSFLAGS_WINDOWS */
618 output( "\t.byte 0x08\n" ); /* ne_flagsothers = NE_AFLAGS_FASTLOAD */
619 output( "\t.short 0\n" ); /* ne_pretthunks */
620 output( "\t.short 0\n" ); /* ne_psegrefbytes */
621 output( "\t.short 0\n" ); /* ne_swaparea */
622 output( "\t.short 0\n" ); /* ne_expver */
626 output( "\n.L__wine_spec_ne_segtab:\n" );
628 /* code segment entry */
630 output( "\t.short .L__wine_spec_code_segment-.L__wine_spec_dos_header\n" ); /* filepos */
631 output( "\t.short .L__wine_spec_code_segment_end-.L__wine_spec_code_segment\n" ); /* size */
632 output( "\t.short 0x2000\n" ); /* flags = NE_SEGFLAGS_32BIT */
633 output( "\t.short .L__wine_spec_code_segment_end-.L__wine_spec_code_segment\n" ); /* minsize */
635 /* data segment entry */
637 output( "\t.short .L__wine_spec_data_segment-.L__wine_spec_dos_header\n" ); /* filepos */
638 output( "\t.short .L__wine_spec_data_segment_end-.L__wine_spec_data_segment\n" ); /* size */
639 output( "\t.short 0x0001\n" ); /* flags = NE_SEGFLAGS_DATA */
640 output( "\t.short .L__wine_spec_data_segment_end-.L__wine_spec_data_segment\n" ); /* minsize */
642 /* resource directory */
644 output_res16_directory( spec
);
646 /* resident names table */
648 output( "\n\t.align %d\n", get_alignment(2) );
649 output( ".L__wine_spec_ne_restab:\n" );
650 output_resident_name( spec
->dll_name
, 0 );
651 for (i
= 1; i
<= spec
->limit
; i
++)
653 ORDDEF
*odp
= spec
->ordinals
[i
];
654 if (!odp
|| !odp
->name
[0]) continue;
655 if (odp
->flags
& FLAG_EXPORT32
) continue;
656 output_resident_name( odp
->name
, i
);
658 output( "\t.byte 0\n" );
660 /* imported names table */
662 output( "\n\t.align %d\n", get_alignment(2) );
663 output( ".L__wine_spec_ne_modtab:\n" );
664 output( ".L__wine_spec_ne_imptab:\n" );
665 output( "\t.byte 0,0\n" );
669 output( "\n.L__wine_spec_ne_enttab:\n" );
670 output_entry_table( spec
);
671 output( ".L__wine_spec_ne_enttab_end:\n" );
675 output( "\n\t.align %d\n", get_alignment(2) );
676 output( ".L__wine_spec_code_segment:\n" );
678 for ( i
= 0; i
< nb_funcs
; i
++ )
680 unsigned int arg_types
[2];
681 int nop_words
, pos
, argsize
= 0;
683 if ( typelist
[i
]->type
== TYPE_PASCAL
)
684 argsize
= get_function_argsize( typelist
[i
] );
686 /* build the arg types bit fields */
687 arg_types
[0] = arg_types
[1] = 0;
688 for (j
= pos
= 0; j
< typelist
[i
]->u
.func
.nb_args
&& pos
< 20; j
++, pos
++)
691 switch (typelist
[i
]->u
.func
.args
[j
])
693 case ARG_WORD
: type
= ARG16_WORD
; break;
694 case ARG_SWORD
: type
= ARG16_SWORD
; break;
695 case ARG_SEGPTR
: type
= ARG16_LONG
; break;
696 case ARG_SEGSTR
: type
= ARG16_SEGSTR
; break;
697 case ARG_LONG
: type
= ARG16_LONG
; break;
698 case ARG_PTR
: type
= ARG16_PTR
; break;
699 case ARG_STR
: type
= ARG16_STR
; break;
700 case ARG_WSTR
: type
= ARG16_PTR
; break;
701 case ARG_FLOAT
: type
= ARG16_LONG
; break;
702 case ARG_INT128
: type
= ARG16_PTR
; break;
706 arg_types
[pos
/ 10] |= type
<< (3 * (pos
% 10));
710 if (pos
< 20) arg_types
[pos
/ 10] |= type
<< (3 * (pos
% 10));
712 if (typelist
[i
]->type
== TYPE_VARARGS
&& pos
< 20)
713 arg_types
[pos
/ 10] |= ARG16_VARARG
<< (3 * (pos
% 10));
715 output( ".L__wine_spec_callfrom16_%s:\n", get_callfrom16_name(typelist
[i
]) );
716 output( "\tpushl $.L__wine_spec_call16_%s\n", get_relay_name(typelist
[i
]) );
717 output( "\tlcall $0,$0\n" );
719 if (typelist
[i
]->flags
& FLAG_REGISTER
)
723 else if (typelist
[i
]->flags
& FLAG_RET16
)
725 output( "\torw %%ax,%%ax\n" );
726 output( "\tnop\n" ); /* so that the lretw is aligned */
731 output( "\tshld $16,%%eax,%%edx\n" );
732 output( "\torl %%eax,%%eax\n" );
738 output( "\tlretw $%u\n", argsize
);
741 else output( "\tlretw\n" );
743 if (nop_words
) output( "\t%s\n", nop_sequence
[nop_words
-1] );
745 /* the movl is here so that the code contains only valid instructions, */
746 /* it's never actually executed, we only care about the arg_types[] values */
747 output( "\t.short 0x86c7\n" );
748 output( "\t.long 0x%08x,0x%08x\n", arg_types
[0], arg_types
[1] );
751 for (i
= 0; i
<= spec
->limit
; i
++)
753 ORDDEF
*odp
= spec
->ordinals
[i
];
754 if (!odp
|| !is_function( odp
)) continue;
755 output( ".L__wine_%s_%u:\n", spec
->c_name
, i
);
756 output( "\tpushw %%bp\n" );
757 output( "\tpushl $%s\n",
758 asm_name( odp
->type
== TYPE_STUB
? get_stub_name( odp
, spec
) : odp
->link_name
));
759 output( "\tcallw .L__wine_spec_callfrom16_%s\n", get_callfrom16_name( odp
) );
761 output( ".L__wine_spec_code_segment_end:\n" );
765 output( "\n.L__wine_spec_data_segment:\n" );
766 output( "\t.byte 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0\n" ); /* instance data */
767 for (i
= 0; i
<= spec
->limit
; i
++)
769 ORDDEF
*odp
= spec
->ordinals
[i
];
770 if (!odp
|| odp
->type
!= TYPE_VARIABLE
) continue;
771 output( ".L__wine_%s_%u:\n", spec
->c_name
, i
);
772 output( "\t.long " );
773 for (j
= 0; j
< odp
->u
.var
.n_values
-1; j
++)
774 output( "0x%08x,", odp
->u
.var
.values
[j
] );
775 output( "0x%08x\n", odp
->u
.var
.values
[j
] );
777 output( ".L__wine_spec_data_segment_end:\n" );
781 if (spec
->nb_resources
)
783 output( "\n.L__wine_spec_resource_data:\n" );
784 output_res16_data( spec
);
787 output( "\t.byte 0\n" ); /* make sure the last symbol points to something */
789 /* relay functions */
791 nb_funcs
= sort_func_list( typelist
, nb_funcs
, relay_type_compare
);
794 output( "\n/* relay functions */\n\n" );
795 output( "\t.text\n" );
796 for ( i
= 0; i
< nb_funcs
; i
++ ) output_call16_function( typelist
[i
] );
797 output( "\t.data\n" );
798 output( "wine_ldt_copy_ptr:\n" );
799 output( "\t.long %s\n", asm_name("wine_ldt_copy") );
806 /*******************************************************************
809 * Output the complete data for a spec 16-bit file.
811 void output_spec16_file( DLLSPEC
*spec16
)
813 DLLSPEC
*spec32
= alloc_dll_spec();
815 resolve_imports( spec16
);
816 add_16bit_exports( spec32
, spec16
);
818 needs_get_pc_thunk
= 0;
819 output_standard_file_header();
820 output_module( spec32
);
821 output_module16( spec16
);
822 output_stubs( spec16
);
823 output_exports( spec32
);
824 output_imports( spec16
);
825 if (is_undefined( "__wine_call_from_16" )) output_asm_relays16();
826 if (needs_get_pc_thunk
) output_get_pc_thunk();
827 if (spec16
->main_module
)
829 output( "\n\t%s\n", get_asm_string_section() );
830 output( ".L__wine_spec_main_module:\n" );
831 output( "\t%s \"%s\"\n", get_asm_string_keyword(), spec16
->main_module
);
833 output_gnu_stack_note();
834 free_dll_spec( spec32
);
837 /*******************************************************************
838 * output_fake_module16
840 * Create a fake 16-bit binary module.
842 void output_fake_module16( DLLSPEC
*spec
)
844 static const unsigned char code_segment
[] = { 0x90, 0xc3 };
845 static const unsigned char data_segment
[16] = { 0 };
846 static const char fakedll_signature
[] = "Wine placeholder DLL";
847 const unsigned int cseg
= 2;
848 const unsigned int lfanew
= (0x40 + sizeof(fakedll_signature
) + 15) & ~15;
849 const unsigned int segtab
= lfanew
+ 0x40;
851 unsigned int i
, rsrctab
, restab
, namelen
, modtab
, imptab
, enttab
, cbenttab
, codeseg
, dataseg
, rsrcdata
;
853 init_output_buffer();
856 restab
= segtab
+ 8 * cseg
;
857 if (spec
->nb_resources
)
859 output_bin_res16_directory( spec
, 0 );
862 restab
+= output_buffer_pos
;
863 free( output_buffer
);
864 init_output_buffer();
867 namelen
= strlen( spec
->dll_name
);
868 modtab
= restab
+ ((namelen
+ 3) & ~1);
872 codeseg
= (enttab
+ cbenttab
+ 1) & ~1;
873 dataseg
= codeseg
+ sizeof(code_segment
);
874 rsrcdata
= dataseg
+ sizeof(data_segment
);
876 init_output_buffer();
878 put_word( 0x5a4d ); /* e_magic */
879 put_word( 0x40 ); /* e_cblp */
880 put_word( 0x01 ); /* e_cp */
881 put_word( 0 ); /* e_crlc */
882 put_word( lfanew
/ 16 ); /* e_cparhdr */
883 put_word( 0x0000 ); /* e_minalloc */
884 put_word( 0xffff ); /* e_maxalloc */
885 put_word( 0x0000 ); /* e_ss */
886 put_word( 0x00b8 ); /* e_sp */
887 put_word( 0 ); /* e_csum */
888 put_word( 0 ); /* e_ip */
889 put_word( 0 ); /* e_cs */
890 put_word( lfanew
); /* e_lfarlc */
891 put_word( 0 ); /* e_ovno */
892 put_dword( 0 ); /* e_res */
894 put_word( 0 ); /* e_oemid */
895 put_word( 0 ); /* e_oeminfo */
896 put_dword( 0 ); /* e_res2 */
903 put_data( fakedll_signature
, sizeof(fakedll_signature
) );
906 put_word( 0x454e ); /* ne_magic */
907 put_byte( 0 ); /* ne_ver */
908 put_byte( 0 ); /* ne_rev */
909 put_word( enttab
- lfanew
); /* ne_enttab */
910 put_word( cbenttab
); /* ne_cbenttab */
911 put_dword( 0 ); /* ne_crc */
912 put_word( NE_FFLAGS_SINGLEDATA
| /* ne_flags */
913 ((spec
->characteristics
& IMAGE_FILE_DLL
) ? NE_FFLAGS_LIBMODULE
: 0) );
914 put_word( 2 ); /* ne_autodata */
915 put_word( spec
->heap_size
); /* ne_heap */
916 put_word( 0 ); /* ne_stack */
917 put_word( 0 ); put_word( 0 ); /* ne_csip */
918 put_word( 0 ); put_word( 2 ); /* ne_sssp */
919 put_word( cseg
); /* ne_cseg */
920 put_word( 0 ); /* ne_cmod */
921 put_word( 0 ); /* ne_cbnrestab */
922 put_word( segtab
- lfanew
); /* ne_segtab */
923 put_word( rsrctab
- lfanew
); /* ne_rsrctab */
924 put_word( restab
- lfanew
); /* ne_restab */
925 put_word( modtab
- lfanew
); /* ne_modtab */
926 put_word( imptab
- lfanew
); /* ne_imptab */
927 put_dword( 0 ); /* ne_nrestab */
928 put_word( 0 ); /* ne_cmovent */
929 put_word( 0 ); /* ne_align */
930 put_word( 0 ); /* ne_cres */
931 put_byte( 2 /*NE_OSFLAGS_WINDOWS*/ ); /* ne_exetyp */
932 put_byte( 8 /*NE_AFLAGS_FASTLOAD*/ ); /* ne_flagsothers */
933 put_word( 0 ); /* ne_pretthunks */
934 put_word( 0 ); /* ne_psegrefbytes */
935 put_word( 0 ); /* ne_swaparea */
936 put_word( 0 ); /* ne_expver */
940 put_word( sizeof(code_segment
) );
941 put_word( 0x2000 /* NE_SEGFLAGS_32BIT */ );
942 put_word( sizeof(code_segment
) );
944 put_word( sizeof(data_segment
) );
945 put_word( 0x0001 /* NE_SEGFLAGS_DATA */ );
946 put_word( sizeof(data_segment
) );
948 /* resource directory */
949 if (spec
->nb_resources
)
951 output_bin_res16_directory( spec
, rsrcdata
);
955 /* resident names table */
957 for (i
= 0; i
< namelen
; i
++) put_byte( toupper(spec
->dll_name
[i
]) );
961 /* imported names table */
969 put_data( code_segment
, sizeof(code_segment
) );
972 put_data( data_segment
, sizeof(data_segment
) );
975 output_bin_res16_data( spec
);
977 flush_output_buffer();