| /* |
| * 16-bit spec files |
| * |
| * Copyright 1993 Robert J. Amstadt |
| * Copyright 1995 Martin von Loewis |
| * Copyright 1995, 1996, 1997 Alexandre Julliard |
| * Copyright 1997 Eric Youngdale |
| * Copyright 1999 Ulrich Weigand |
| * |
| * This library is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU Lesser General Public |
| * License as published by the Free Software Foundation; either |
| * version 2.1 of the License, or (at your option) any later version. |
| * |
| * This library is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| * Lesser General Public License for more details. |
| * |
| * You should have received a copy of the GNU Lesser General Public |
| * License along with this library; if not, write to the Free Software |
| * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA |
| */ |
| |
| #include "config.h" |
| #include "wine/port.h" |
| |
| #include <assert.h> |
| #include <ctype.h> |
| |
| #include "build.h" |
| |
| #define NE_FFLAGS_SINGLEDATA 0x0001 |
| #define NE_FFLAGS_LIBMODULE 0x8000 |
| |
| /* argument type flags for relay debugging */ |
| enum arg_types |
| { |
| ARG16_NONE = 0, /* indicates end of arg list */ |
| ARG16_WORD, /* unsigned word */ |
| ARG16_SWORD, /* signed word */ |
| ARG16_LONG, /* long or segmented pointer */ |
| ARG16_PTR, /* linear pointer */ |
| ARG16_STR, /* linear pointer to null-terminated string */ |
| ARG16_SEGSTR, /* segmented pointer to null-terminated string */ |
| ARG16_VARARG /* start of varargs */ |
| }; |
| |
| /* sequences of nops to fill a certain number of words */ |
| static const char * const nop_sequence[4] = |
| { |
| ".byte 0x89,0xf6", /* mov %esi,%esi */ |
| ".byte 0x8d,0x74,0x26,0x00", /* lea 0x00(%esi),%esi */ |
| ".byte 0x8d,0xb6,0x00,0x00,0x00,0x00", /* lea 0x00000000(%esi),%esi */ |
| ".byte 0x8d,0x74,0x26,0x00,0x8d,0x74,0x26,0x00" /* lea 0x00(%esi),%esi; lea 0x00(%esi),%esi */ |
| }; |
| |
| static inline int is_function( const ORDDEF *odp ) |
| { |
| if (odp->flags & FLAG_EXPORT32) return 0; |
| return (odp->type == TYPE_CDECL || |
| odp->type == TYPE_PASCAL || |
| odp->type == TYPE_VARARGS || |
| odp->type == TYPE_STUB); |
| } |
| |
| static const char *get_args_str( const ORDDEF *odp ) |
| { |
| static char buffer[MAX_ARGUMENTS*2+1]; |
| int i; |
| |
| buffer[0] = 0; |
| for (i = 0; i < odp->u.func.nb_args; i++) |
| { |
| switch (odp->u.func.args[i]) |
| { |
| case ARG_WORD: strcat( buffer, "w" ); break; |
| case ARG_SWORD: strcat( buffer, "s" ); break; |
| case ARG_SEGSTR: strcat( buffer, "T" ); break; |
| case ARG_STR: strcat( buffer, "t" ); break; |
| case ARG_LONG: |
| case ARG_FLOAT: |
| case ARG_SEGPTR: strcat( buffer, "l" ); break; |
| case ARG_PTR: |
| case ARG_WSTR: |
| case ARG_INT128: strcat( buffer, "p" ); break; |
| case ARG_INT64: |
| case ARG_DOUBLE: strcat( buffer, "ll" ); break; |
| } |
| } |
| return buffer; |
| } |
| |
| /******************************************************************* |
| * output_entries |
| * |
| * Output entries for individual symbols in the entry table. |
| */ |
| static void output_entries( DLLSPEC *spec, int first, int count ) |
| { |
| int i; |
| |
| for (i = 0; i < count; i++) |
| { |
| ORDDEF *odp = spec->ordinals[first + i]; |
| output( "\t.byte 0x03\n" ); /* flags: exported & public data */ |
| switch (odp->type) |
| { |
| case TYPE_CDECL: |
| case TYPE_PASCAL: |
| case TYPE_VARARGS: |
| case TYPE_STUB: |
| output( "\t.short .L__wine_%s_%u-.L__wine_spec_code_segment\n", |
| make_c_identifier(spec->dll_name), first + i ); |
| break; |
| case TYPE_VARIABLE: |
| output( "\t.short .L__wine_%s_%u-.L__wine_spec_data_segment\n", |
| make_c_identifier(spec->dll_name), first + i ); |
| break; |
| case TYPE_ABS: |
| output( "\t.short 0x%04x /* %s */\n", |
| odp->u.abs.value, odp->name ); |
| break; |
| default: |
| assert(0); |
| } |
| } |
| } |
| |
| |
| /******************************************************************* |
| * output_entry_table |
| */ |
| static void output_entry_table( DLLSPEC *spec ) |
| { |
| int i, prev = 0, prev_sel = -1, bundle_count = 0; |
| |
| for (i = 1; i <= spec->limit; i++) |
| { |
| int selector = 0; |
| ORDDEF *odp = spec->ordinals[i]; |
| if (!odp) continue; |
| if (odp->flags & FLAG_EXPORT32) continue; |
| |
| switch (odp->type) |
| { |
| case TYPE_CDECL: |
| case TYPE_PASCAL: |
| case TYPE_VARARGS: |
| case TYPE_STUB: |
| selector = 1; /* Code selector */ |
| break; |
| case TYPE_VARIABLE: |
| selector = 2; /* Data selector */ |
| break; |
| case TYPE_ABS: |
| selector = 0xfe; /* Constant selector */ |
| break; |
| default: |
| continue; |
| } |
| |
| if (prev + 1 != i || prev_sel != selector || bundle_count == 255) |
| { |
| /* need to start a new bundle */ |
| |
| /* flush previous bundle */ |
| if (bundle_count) |
| { |
| output( "\t/* %s.%d - %s.%d */\n", |
| spec->dll_name, prev - bundle_count + 1, spec->dll_name, prev ); |
| output( "\t.byte 0x%02x,0x%02x\n", bundle_count, prev_sel ); |
| output_entries( spec, prev - bundle_count + 1, bundle_count ); |
| } |
| |
| if (prev + 1 != i) |
| { |
| int skip = i - (prev + 1); |
| while (skip > 255) |
| { |
| output( "\t.byte 0xff,0x00\n" ); |
| skip -= 255; |
| } |
| output( "\t.byte 0x%02x,0x00\n", skip ); |
| } |
| |
| bundle_count = 0; |
| prev_sel = selector; |
| } |
| bundle_count++; |
| prev = i; |
| } |
| |
| /* flush last bundle */ |
| if (bundle_count) |
| { |
| output( "\t.byte 0x%02x,0x%02x\n", bundle_count, prev_sel ); |
| output_entries( spec, prev - bundle_count + 1, bundle_count ); |
| } |
| output( "\t.byte 0x00\n" ); |
| } |
| |
| |
| /******************************************************************* |
| * output_resident_name |
| */ |
| static void output_resident_name( const char *string, int ordinal ) |
| { |
| unsigned int i, len = strlen(string); |
| |
| output( "\t.byte 0x%02x", len ); |
| for (i = 0; i < len; i++) output( ",0x%02x", (unsigned char)toupper(string[i]) ); |
| output( " /* %s */\n", string ); |
| output( "\t.short %u\n", ordinal ); |
| } |
| |
| |
| /******************************************************************* |
| * get_callfrom16_name |
| */ |
| static const char *get_callfrom16_name( const ORDDEF *odp ) |
| { |
| static char *buffer; |
| |
| free( buffer ); |
| buffer = strmake( "%s_%s_%s", |
| (odp->type == TYPE_PASCAL) ? "p" : |
| (odp->type == TYPE_VARARGS) ? "v" : "c", |
| (odp->flags & FLAG_REGISTER) ? "regs" : |
| (odp->flags & FLAG_RET16) ? "word" : "long", |
| get_args_str(odp) ); |
| return buffer; |
| } |
| |
| |
| /******************************************************************* |
| * get_relay_name |
| */ |
| static const char *get_relay_name( const ORDDEF *odp ) |
| { |
| static char buffer[80]; |
| char *p; |
| |
| switch(odp->type) |
| { |
| case TYPE_PASCAL: |
| strcpy( buffer, "p_" ); |
| break; |
| case TYPE_VARARGS: |
| strcpy( buffer, "v_" ); |
| break; |
| case TYPE_CDECL: |
| case TYPE_STUB: |
| strcpy( buffer, "c_" ); |
| break; |
| default: |
| assert(0); |
| } |
| strcat( buffer, get_args_str(odp) ); |
| for (p = buffer + 2; *p; p++) |
| { |
| /* map string types to the corresponding plain pointer type */ |
| if (*p == 't') *p = 'p'; |
| else if (*p == 'T') *p = 'l'; |
| } |
| if (odp->flags & FLAG_REGISTER) strcat( buffer, "_regs" ); |
| return buffer; |
| } |
| |
| |
| /******************************************************************* |
| * get_function_argsize |
| */ |
| static int get_function_argsize( const ORDDEF *odp ) |
| { |
| int i, argsize = 0; |
| |
| for (i = 0; i < odp->u.func.nb_args; i++) |
| { |
| switch (odp->u.func.args[i]) |
| { |
| case ARG_WORD: |
| case ARG_SWORD: |
| argsize += 2; |
| break; |
| case ARG_SEGPTR: |
| case ARG_SEGSTR: |
| case ARG_LONG: |
| case ARG_PTR: |
| case ARG_STR: |
| case ARG_WSTR: |
| case ARG_FLOAT: |
| case ARG_INT128: |
| argsize += 4; |
| break; |
| case ARG_INT64: |
| case ARG_DOUBLE: |
| argsize += 8; |
| break; |
| } |
| } |
| return argsize; |
| } |
| |
| |
| /******************************************************************* |
| * output_call16_function |
| * |
| * Build a 16-bit-to-Wine callback glue function. |
| * |
| * The generated routines are intended to be used as argument conversion |
| * routines to be called by the CallFrom16... core. Thus, the prototypes of |
| * the generated routines are (see also CallFrom16): |
| * |
| * extern WORD WINAPI __wine_spec_call16_C_xxx( FARPROC func, LPBYTE args ); |
| * extern LONG WINAPI __wine_spec_call16_C_xxx( FARPROC func, LPBYTE args ); |
| * extern void WINAPI __wine_spec_call16_C_xxx_regs( FARPROC func, LPBYTE args, CONTEXT86 *context ); |
| * |
| * where 'C' is the calling convention ('p' for pascal or 'c' for cdecl), |
| * and each 'x' is an argument ('w'=word, 's'=signed word, 'l'=long, |
| * 'p'=linear pointer, 't'=linear pointer to null-terminated string, |
| * 'T'=segmented pointer to null-terminated string). |
| * |
| * The generated routines fetch the arguments from the 16-bit stack (pointed |
| * to by 'args'); the offsets of the single argument values are computed |
| * according to the calling convention and the argument types. Then, the |
| * 32-bit entry point is called with these arguments. |
| * |
| * For register functions, the arguments (if present) are converted just |
| * the same as for normal functions, but in addition the CONTEXT86 pointer |
| * filled with the current register values is passed to the 32-bit routine. |
| */ |
| static void output_call16_function( ORDDEF *odp ) |
| { |
| char *name; |
| int i, pos, stack_words; |
| int argsize = get_function_argsize( odp ); |
| int needs_ldt = (strpbrk( get_args_str( odp ), "pt" ) != NULL); |
| |
| name = strmake( ".L__wine_spec_call16_%s", get_relay_name(odp) ); |
| |
| output( "\t.align %d\n", get_alignment(4) ); |
| output( "\t%s\n", func_declaration(name) ); |
| output( "%s:\n", name ); |
| output_cfi( ".cfi_startproc" ); |
| output( "\tpushl %%ebp\n" ); |
| output_cfi( ".cfi_adjust_cfa_offset 4" ); |
| output_cfi( ".cfi_rel_offset %%ebp,0" ); |
| output( "\tmovl %%esp,%%ebp\n" ); |
| output_cfi( ".cfi_def_cfa_register %%ebp" ); |
| stack_words = 2; |
| if (needs_ldt) |
| { |
| output( "\tpushl %%esi\n" ); |
| output_cfi( ".cfi_rel_offset %%esi,-4" ); |
| stack_words++; |
| if (UsePIC) |
| { |
| output( "\tcall %s\n", asm_name("__wine_spec_get_pc_thunk_eax") ); |
| output( "1:\tmovl wine_ldt_copy_ptr-1b(%%eax),%%esi\n" ); |
| } |
| else |
| output( "\tmovl $%s,%%esi\n", asm_name("wine_ldt_copy") ); |
| } |
| |
| /* preserve 16-byte stack alignment */ |
| stack_words += odp->u.func.nb_args; |
| for (i = 0; i < odp->u.func.nb_args; i++) |
| if (odp->u.func.args[i] == ARG_DOUBLE || odp->u.func.args[i] == ARG_INT64) stack_words++; |
| if ((odp->flags & FLAG_REGISTER) || (odp->type == TYPE_VARARGS)) stack_words++; |
| if (stack_words % 4) output( "\tsubl $%d,%%esp\n", 16 - 4 * (stack_words % 4) ); |
| |
| if (odp->u.func.nb_args || odp->type == TYPE_VARARGS) |
| output( "\tmovl 12(%%ebp),%%ecx\n" ); /* args */ |
| |
| if (odp->flags & FLAG_REGISTER) |
| { |
| output( "\tpushl 16(%%ebp)\n" ); /* context */ |
| } |
| else if (odp->type == TYPE_VARARGS) |
| { |
| output( "\tleal %d(%%ecx),%%eax\n", argsize ); |
| output( "\tpushl %%eax\n" ); /* va_list16 */ |
| } |
| |
| pos = (odp->type == TYPE_PASCAL) ? 0 : argsize; |
| for (i = odp->u.func.nb_args - 1; i >= 0; i--) |
| { |
| switch (odp->u.func.args[i]) |
| { |
| case ARG_WORD: |
| if (odp->type != TYPE_PASCAL) pos -= 2; |
| output( "\tmovzwl %d(%%ecx),%%eax\n", pos ); |
| output( "\tpushl %%eax\n" ); |
| if (odp->type == TYPE_PASCAL) pos += 2; |
| break; |
| |
| case ARG_SWORD: |
| if (odp->type != TYPE_PASCAL) pos -= 2; |
| output( "\tmovswl %d(%%ecx),%%eax\n", pos ); |
| output( "\tpushl %%eax\n" ); |
| if (odp->type == TYPE_PASCAL) pos += 2; |
| break; |
| |
| case ARG_INT64: |
| case ARG_DOUBLE: |
| if (odp->type != TYPE_PASCAL) pos -= 4; |
| output( "\tpushl %d(%%ecx)\n", pos ); |
| if (odp->type == TYPE_PASCAL) pos += 4; |
| /* fall through */ |
| case ARG_LONG: |
| case ARG_FLOAT: |
| case ARG_SEGPTR: |
| case ARG_SEGSTR: |
| if (odp->type != TYPE_PASCAL) pos -= 4; |
| output( "\tpushl %d(%%ecx)\n", pos ); |
| if (odp->type == TYPE_PASCAL) pos += 4; |
| break; |
| |
| case ARG_PTR: |
| case ARG_STR: |
| case ARG_WSTR: |
| case ARG_INT128: |
| if (odp->type != TYPE_PASCAL) pos -= 4; |
| output( "\tmovzwl %d(%%ecx),%%edx\n", pos + 2 ); /* sel */ |
| output( "\tshr $3,%%edx\n" ); |
| output( "\tmovzwl %d(%%ecx),%%eax\n", pos ); /* offset */ |
| output( "\taddl (%%esi,%%edx,4),%%eax\n" ); |
| output( "\tpushl %%eax\n" ); |
| if (odp->type == TYPE_PASCAL) pos += 4; |
| break; |
| } |
| } |
| |
| output( "\tcall *8(%%ebp)\n" ); |
| |
| if (needs_ldt) |
| { |
| output( "\tmovl -4(%%ebp),%%esi\n" ); |
| output_cfi( ".cfi_same_value %%esi" ); |
| } |
| output( "\tleave\n" ); |
| output_cfi( ".cfi_def_cfa %%esp,4" ); |
| output_cfi( ".cfi_same_value %%ebp" ); |
| output( "\tret\n" ); |
| output_cfi( ".cfi_endproc" ); |
| output_function_size( name ); |
| free( name ); |
| } |
| |
| |
| /******************************************************************* |
| * callfrom16_type_compare |
| * |
| * Compare two callfrom16 sequences. |
| */ |
| static int callfrom16_type_compare( const void *e1, const void *e2 ) |
| { |
| const ORDDEF *odp1 = *(const ORDDEF * const *)e1; |
| const ORDDEF *odp2 = *(const ORDDEF * const *)e2; |
| int retval; |
| int type1 = odp1->type; |
| int type2 = odp2->type; |
| char args1[80]; |
| |
| if (type1 == TYPE_STUB) type1 = TYPE_CDECL; |
| if (type2 == TYPE_STUB) type2 = TYPE_CDECL; |
| |
| if ((retval = type1 - type2) != 0) return retval; |
| |
| type1 = odp1->flags & (FLAG_RET16|FLAG_REGISTER); |
| type2 = odp2->flags & (FLAG_RET16|FLAG_REGISTER); |
| |
| if ((retval = type1 - type2) != 0) return retval; |
| |
| strcpy( args1, get_args_str( odp1 )); |
| return strcmp( args1, get_args_str( odp2 )); |
| } |
| |
| |
| /******************************************************************* |
| * relay_type_compare |
| * |
| * Same as callfrom16_type_compare but ignores differences that don't affect the resulting relay function. |
| */ |
| static int relay_type_compare( const void *e1, const void *e2 ) |
| { |
| const ORDDEF *odp1 = *(const ORDDEF * const *)e1; |
| const ORDDEF *odp2 = *(const ORDDEF * const *)e2; |
| char name1[80]; |
| |
| strcpy( name1, get_relay_name(odp1) ); |
| return strcmp( name1, get_relay_name(odp2) ); |
| } |
| |
| |
| /******************************************************************* |
| * sort_func_list |
| * |
| * Sort a list of functions, removing duplicates. |
| */ |
| static int sort_func_list( ORDDEF **list, int count, |
| int (*compare)(const void *, const void *) ) |
| { |
| int i, j; |
| |
| if (!count) return 0; |
| qsort( list, count, sizeof(*list), compare ); |
| |
| for (i = j = 0; i < count; i++) |
| { |
| if (compare( &list[j], &list[i] )) list[++j] = list[i]; |
| } |
| return j + 1; |
| } |
| |
| |
| /******************************************************************* |
| * output_module16 |
| * |
| * Output code for a 16-bit module. |
| */ |
| static void output_module16( DLLSPEC *spec ) |
| { |
| ORDDEF **typelist; |
| ORDDEF *entry_point = NULL; |
| int i, j, nb_funcs; |
| |
| /* store the main entry point as ordinal 0 */ |
| |
| if (!spec->ordinals) |
| { |
| assert(spec->limit == 0); |
| spec->ordinals = xmalloc( sizeof(spec->ordinals[0]) ); |
| spec->ordinals[0] = NULL; |
| } |
| if (spec->init_func && !(spec->characteristics & IMAGE_FILE_DLL)) |
| { |
| entry_point = xmalloc( sizeof(*entry_point) ); |
| entry_point->type = TYPE_PASCAL; |
| entry_point->ordinal = 0; |
| entry_point->lineno = 0; |
| entry_point->flags = FLAG_REGISTER; |
| entry_point->name = NULL; |
| entry_point->link_name = xstrdup( spec->init_func ); |
| entry_point->export_name = NULL; |
| entry_point->u.func.nb_args = 0; |
| assert( !spec->ordinals[0] ); |
| spec->ordinals[0] = entry_point; |
| } |
| |
| /* Build sorted list of all argument types, without duplicates */ |
| |
| typelist = xmalloc( (spec->limit + 1) * sizeof(*typelist) ); |
| |
| for (i = nb_funcs = 0; i <= spec->limit; i++) |
| { |
| ORDDEF *odp = spec->ordinals[i]; |
| if (!odp) continue; |
| if (is_function( odp )) typelist[nb_funcs++] = odp; |
| } |
| |
| nb_funcs = sort_func_list( typelist, nb_funcs, callfrom16_type_compare ); |
| |
| /* Output the module structure */ |
| |
| output( "\n/* module data */\n\n" ); |
| output( "\t.data\n" ); |
| output( "\t.align %d\n", get_alignment(4) ); |
| output( ".L__wine_spec_dos_header:\n" ); |
| output( "\t.short 0x5a4d\n" ); /* e_magic */ |
| output( "\t.short 0\n" ); /* e_cblp */ |
| output( "\t.short 0\n" ); /* e_cp */ |
| output( "\t.short 0\n" ); /* e_crlc */ |
| output( "\t.short 0\n" ); /* e_cparhdr */ |
| output( "\t.short 0\n" ); /* e_minalloc */ |
| output( "\t.short 0\n" ); /* e_maxalloc */ |
| output( "\t.short 0\n" ); /* e_ss */ |
| output( "\t.short 0\n" ); /* e_sp */ |
| output( "\t.short 0\n" ); /* e_csum */ |
| output( "\t.short 0\n" ); /* e_ip */ |
| output( "\t.short 0\n" ); /* e_cs */ |
| output( "\t.short 0\n" ); /* e_lfarlc */ |
| output( "\t.short 0\n" ); /* e_ovno */ |
| output( "\t.short 0,0,0,0\n" ); /* e_res */ |
| output( "\t.short 0\n" ); /* e_oemid */ |
| output( "\t.short 0\n" ); /* e_oeminfo */ |
| output( "\t.short 0,0,0,0,0,0,0,0,0,0\n" ); /* e_res2 */ |
| output( "\t.long .L__wine_spec_ne_header-.L__wine_spec_dos_header\n" );/* e_lfanew */ |
| |
| output( ".L__wine_spec_ne_header:\n" ); |
| output( "\t.short 0x454e\n" ); /* ne_magic */ |
| output( "\t.byte 0\n" ); /* ne_ver */ |
| output( "\t.byte 0\n" ); /* ne_rev */ |
| output( "\t.short .L__wine_spec_ne_enttab-.L__wine_spec_ne_header\n" );/* ne_enttab */ |
| output( "\t.short .L__wine_spec_ne_enttab_end-.L__wine_spec_ne_enttab\n" );/* ne_cbenttab */ |
| output( "\t.long 0\n" ); /* ne_crc */ |
| output( "\t.short 0x%04x\n", NE_FFLAGS_SINGLEDATA | /* ne_flags */ |
| ((spec->characteristics & IMAGE_FILE_DLL) ? NE_FFLAGS_LIBMODULE : 0) ); |
| output( "\t.short 2\n" ); /* ne_autodata */ |
| output( "\t.short %u\n", spec->heap_size ); /* ne_heap */ |
| output( "\t.short 0\n" ); /* ne_stack */ |
| if (!entry_point) output( "\t.long 0\n" ); /* ne_csip */ |
| else output( "\t.short .L__wine_%s_0-.L__wine_spec_code_segment,1\n", |
| make_c_identifier(spec->dll_name) ); |
| output( "\t.short 0,2\n" ); /* ne_sssp */ |
| output( "\t.short 2\n" ); /* ne_cseg */ |
| output( "\t.short 0\n" ); /* ne_cmod */ |
| output( "\t.short 0\n" ); /* ne_cbnrestab */ |
| output( "\t.short .L__wine_spec_ne_segtab-.L__wine_spec_ne_header\n" );/* ne_segtab */ |
| output( "\t.short .L__wine_spec_ne_rsrctab-.L__wine_spec_ne_header\n" ); /* ne_rsrctab */ |
| output( "\t.short .L__wine_spec_ne_restab-.L__wine_spec_ne_header\n" ); /* ne_restab */ |
| output( "\t.short .L__wine_spec_ne_modtab-.L__wine_spec_ne_header\n" ); /* ne_modtab */ |
| output( "\t.short .L__wine_spec_ne_imptab-.L__wine_spec_ne_header\n" ); /* ne_imptab */ |
| output( "\t.long 0\n" ); /* ne_nrestab */ |
| output( "\t.short 0\n" ); /* ne_cmovent */ |
| output( "\t.short 0\n" ); /* ne_align */ |
| output( "\t.short 0\n" ); /* ne_cres */ |
| output( "\t.byte 0x02\n" ); /* ne_exetyp = NE_OSFLAGS_WINDOWS */ |
| output( "\t.byte 0x08\n" ); /* ne_flagsothers = NE_AFLAGS_FASTLOAD */ |
| output( "\t.short 0\n" ); /* ne_pretthunks */ |
| output( "\t.short 0\n" ); /* ne_psegrefbytes */ |
| output( "\t.short 0\n" ); /* ne_swaparea */ |
| output( "\t.short 0\n" ); /* ne_expver */ |
| |
| /* segment table */ |
| |
| output( "\n.L__wine_spec_ne_segtab:\n" ); |
| |
| /* code segment entry */ |
| |
| output( "\t.short .L__wine_spec_code_segment-.L__wine_spec_dos_header\n" ); /* filepos */ |
| output( "\t.short .L__wine_spec_code_segment_end-.L__wine_spec_code_segment\n" ); /* size */ |
| output( "\t.short 0x2000\n" ); /* flags = NE_SEGFLAGS_32BIT */ |
| output( "\t.short .L__wine_spec_code_segment_end-.L__wine_spec_code_segment\n" ); /* minsize */ |
| |
| /* data segment entry */ |
| |
| output( "\t.short .L__wine_spec_data_segment-.L__wine_spec_dos_header\n" ); /* filepos */ |
| output( "\t.short .L__wine_spec_data_segment_end-.L__wine_spec_data_segment\n" ); /* size */ |
| output( "\t.short 0x0001\n" ); /* flags = NE_SEGFLAGS_DATA */ |
| output( "\t.short .L__wine_spec_data_segment_end-.L__wine_spec_data_segment\n" ); /* minsize */ |
| |
| /* resource directory */ |
| |
| output_res16_directory( spec ); |
| |
| /* resident names table */ |
| |
| output( "\n\t.align %d\n", get_alignment(2) ); |
| output( ".L__wine_spec_ne_restab:\n" ); |
| output_resident_name( spec->dll_name, 0 ); |
| for (i = 1; i <= spec->limit; i++) |
| { |
| ORDDEF *odp = spec->ordinals[i]; |
| if (!odp || !odp->name[0]) continue; |
| if (odp->flags & FLAG_EXPORT32) continue; |
| output_resident_name( odp->name, i ); |
| } |
| output( "\t.byte 0\n" ); |
| |
| /* imported names table */ |
| |
| output( "\n\t.align %d\n", get_alignment(2) ); |
| output( ".L__wine_spec_ne_modtab:\n" ); |
| output( ".L__wine_spec_ne_imptab:\n" ); |
| output( "\t.byte 0,0\n" ); |
| |
| /* entry table */ |
| |
| output( "\n.L__wine_spec_ne_enttab:\n" ); |
| output_entry_table( spec ); |
| output( ".L__wine_spec_ne_enttab_end:\n" ); |
| |
| /* code segment */ |
| |
| output( "\n\t.align %d\n", get_alignment(2) ); |
| output( ".L__wine_spec_code_segment:\n" ); |
| |
| for ( i = 0; i < nb_funcs; i++ ) |
| { |
| unsigned int arg_types[2]; |
| int nop_words, pos, argsize = 0; |
| |
| if ( typelist[i]->type == TYPE_PASCAL ) |
| argsize = get_function_argsize( typelist[i] ); |
| |
| /* build the arg types bit fields */ |
| arg_types[0] = arg_types[1] = 0; |
| for (j = pos = 0; j < typelist[i]->u.func.nb_args && pos < 20; j++, pos++) |
| { |
| int type = 0; |
| switch (typelist[i]->u.func.args[j]) |
| { |
| case ARG_WORD: type = ARG16_WORD; break; |
| case ARG_SWORD: type = ARG16_SWORD; break; |
| case ARG_SEGPTR: type = ARG16_LONG; break; |
| case ARG_SEGSTR: type = ARG16_SEGSTR; break; |
| case ARG_LONG: type = ARG16_LONG; break; |
| case ARG_PTR: type = ARG16_PTR; break; |
| case ARG_STR: type = ARG16_STR; break; |
| case ARG_WSTR: type = ARG16_PTR; break; |
| case ARG_FLOAT: type = ARG16_LONG; break; |
| case ARG_INT128: type = ARG16_PTR; break; |
| case ARG_INT64: |
| case ARG_DOUBLE: |
| type = ARG16_LONG; |
| arg_types[pos / 10] |= type << (3 * (pos % 10)); |
| pos++; |
| break; |
| } |
| if (pos < 20) arg_types[pos / 10] |= type << (3 * (pos % 10)); |
| } |
| if (typelist[i]->type == TYPE_VARARGS && pos < 20) |
| arg_types[pos / 10] |= ARG16_VARARG << (3 * (pos % 10)); |
| |
| output( ".L__wine_spec_callfrom16_%s:\n", get_callfrom16_name(typelist[i]) ); |
| output( "\tpushl $.L__wine_spec_call16_%s\n", get_relay_name(typelist[i]) ); |
| output( "\tlcall $0,$0\n" ); |
| |
| if (typelist[i]->flags & FLAG_REGISTER) |
| { |
| nop_words = 4; |
| } |
| else if (typelist[i]->flags & FLAG_RET16) |
| { |
| output( "\torw %%ax,%%ax\n" ); |
| output( "\tnop\n" ); /* so that the lretw is aligned */ |
| nop_words = 2; |
| } |
| else |
| { |
| output( "\tshld $16,%%eax,%%edx\n" ); |
| output( "\torl %%eax,%%eax\n" ); |
| nop_words = 1; |
| } |
| |
| if (argsize) |
| { |
| output( "\tlretw $%u\n", argsize ); |
| nop_words--; |
| } |
| else output( "\tlretw\n" ); |
| |
| if (nop_words) output( "\t%s\n", nop_sequence[nop_words-1] ); |
| |
| /* the movl is here so that the code contains only valid instructions, */ |
| /* it's never actually executed, we only care about the arg_types[] values */ |
| output( "\t.short 0x86c7\n" ); |
| output( "\t.long 0x%08x,0x%08x\n", arg_types[0], arg_types[1] ); |
| } |
| |
| for (i = 0; i <= spec->limit; i++) |
| { |
| ORDDEF *odp = spec->ordinals[i]; |
| if (!odp || !is_function( odp )) continue; |
| output( ".L__wine_%s_%u:\n", make_c_identifier(spec->dll_name), i ); |
| output( "\tpushw %%bp\n" ); |
| output( "\tpushl $%s\n", |
| asm_name( odp->type == TYPE_STUB ? get_stub_name( odp, spec ) : odp->link_name )); |
| output( "\tcallw .L__wine_spec_callfrom16_%s\n", get_callfrom16_name( odp ) ); |
| } |
| output( ".L__wine_spec_code_segment_end:\n" ); |
| |
| /* data segment */ |
| |
| output( "\n.L__wine_spec_data_segment:\n" ); |
| output( "\t.byte 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0\n" ); /* instance data */ |
| for (i = 0; i <= spec->limit; i++) |
| { |
| ORDDEF *odp = spec->ordinals[i]; |
| if (!odp || odp->type != TYPE_VARIABLE) continue; |
| output( ".L__wine_%s_%u:\n", make_c_identifier(spec->dll_name), i ); |
| output( "\t.long " ); |
| for (j = 0; j < odp->u.var.n_values-1; j++) |
| output( "0x%08x,", odp->u.var.values[j] ); |
| output( "0x%08x\n", odp->u.var.values[j] ); |
| } |
| output( ".L__wine_spec_data_segment_end:\n" ); |
| |
| /* resource data */ |
| |
| if (spec->nb_resources) |
| { |
| output( "\n.L__wine_spec_resource_data:\n" ); |
| output_res16_data( spec ); |
| } |
| |
| output( "\t.byte 0\n" ); /* make sure the last symbol points to something */ |
| |
| /* relay functions */ |
| |
| nb_funcs = sort_func_list( typelist, nb_funcs, relay_type_compare ); |
| if (nb_funcs) |
| { |
| output( "\n/* relay functions */\n\n" ); |
| output( "\t.text\n" ); |
| for ( i = 0; i < nb_funcs; i++ ) output_call16_function( typelist[i] ); |
| output( "\t.data\n" ); |
| output( "wine_ldt_copy_ptr:\n" ); |
| output( "\t.long %s\n", asm_name("wine_ldt_copy") ); |
| } |
| |
| free( typelist ); |
| } |
| |
| |
| /******************************************************************* |
| * output_spec16_file |
| * |
| * Output the complete data for a spec 16-bit file. |
| */ |
| void output_spec16_file( DLLSPEC *spec16 ) |
| { |
| DLLSPEC *spec32 = alloc_dll_spec(); |
| |
| resolve_imports( spec16 ); |
| add_16bit_exports( spec32, spec16 ); |
| |
| output_standard_file_header(); |
| output_module( spec32 ); |
| output_module16( spec16 ); |
| output_stubs( spec16 ); |
| output_exports( spec32 ); |
| output_imports( spec16 ); |
| if (is_undefined( "__wine_call_from_16" )) output_asm_relays16(); |
| if (spec16->main_module) |
| { |
| output( "\n\t%s\n", get_asm_string_section() ); |
| output( ".L__wine_spec_main_module:\n" ); |
| output( "\t%s \"%s\"\n", get_asm_string_keyword(), spec16->main_module ); |
| } |
| output_gnu_stack_note(); |
| free_dll_spec( spec32 ); |
| } |
| |
| /******************************************************************* |
| * output_fake_module16 |
| * |
| * Create a fake 16-bit binary module. |
| */ |
| void output_fake_module16( DLLSPEC *spec ) |
| { |
| static const unsigned char code_segment[] = { 0x90, 0xc3 }; |
| static const unsigned char data_segment[16] = { 0 }; |
| static const char fakedll_signature[] = "Wine placeholder DLL"; |
| const unsigned int cseg = 2; |
| const unsigned int lfanew = (0x40 + sizeof(fakedll_signature) + 15) & ~15; |
| const unsigned int segtab = lfanew + 0x40; |
| |
| unsigned int i, rsrctab, restab, namelen, modtab, imptab, enttab, cbenttab, codeseg, dataseg, rsrcdata; |
| |
| init_output_buffer(); |
| |
| rsrctab = lfanew; |
| restab = segtab + 8 * cseg; |
| if (spec->nb_resources) |
| { |
| output_bin_res16_directory( spec, 0 ); |
| align_output( 2 ); |
| rsrctab = restab; |
| restab += output_buffer_pos; |
| free( output_buffer ); |
| init_output_buffer(); |
| } |
| |
| namelen = strlen( spec->dll_name ); |
| modtab = restab + ((namelen + 3) & ~1); |
| imptab = modtab; |
| enttab = modtab + 2; |
| cbenttab = 1; |
| codeseg = (enttab + cbenttab + 1) & ~1; |
| dataseg = codeseg + sizeof(code_segment); |
| rsrcdata = dataseg + sizeof(data_segment); |
| |
| init_output_buffer(); |
| |
| put_word( 0x5a4d ); /* e_magic */ |
| put_word( 0x40 ); /* e_cblp */ |
| put_word( 0x01 ); /* e_cp */ |
| put_word( 0 ); /* e_crlc */ |
| put_word( lfanew / 16 ); /* e_cparhdr */ |
| put_word( 0x0000 ); /* e_minalloc */ |
| put_word( 0xffff ); /* e_maxalloc */ |
| put_word( 0x0000 ); /* e_ss */ |
| put_word( 0x00b8 ); /* e_sp */ |
| put_word( 0 ); /* e_csum */ |
| put_word( 0 ); /* e_ip */ |
| put_word( 0 ); /* e_cs */ |
| put_word( lfanew ); /* e_lfarlc */ |
| put_word( 0 ); /* e_ovno */ |
| put_dword( 0 ); /* e_res */ |
| put_dword( 0 ); |
| put_word( 0 ); /* e_oemid */ |
| put_word( 0 ); /* e_oeminfo */ |
| put_dword( 0 ); /* e_res2 */ |
| put_dword( 0 ); |
| put_dword( 0 ); |
| put_dword( 0 ); |
| put_dword( 0 ); |
| put_dword( lfanew ); |
| |
| put_data( fakedll_signature, sizeof(fakedll_signature) ); |
| align_output( 16 ); |
| |
| put_word( 0x454e ); /* ne_magic */ |
| put_byte( 0 ); /* ne_ver */ |
| put_byte( 0 ); /* ne_rev */ |
| put_word( enttab - lfanew ); /* ne_enttab */ |
| put_word( cbenttab ); /* ne_cbenttab */ |
| put_dword( 0 ); /* ne_crc */ |
| put_word( NE_FFLAGS_SINGLEDATA | /* ne_flags */ |
| ((spec->characteristics & IMAGE_FILE_DLL) ? NE_FFLAGS_LIBMODULE : 0) ); |
| put_word( 2 ); /* ne_autodata */ |
| put_word( spec->heap_size ); /* ne_heap */ |
| put_word( 0 ); /* ne_stack */ |
| put_word( 0 ); put_word( 0 ); /* ne_csip */ |
| put_word( 0 ); put_word( 2 ); /* ne_sssp */ |
| put_word( cseg ); /* ne_cseg */ |
| put_word( 0 ); /* ne_cmod */ |
| put_word( 0 ); /* ne_cbnrestab */ |
| put_word( segtab - lfanew ); /* ne_segtab */ |
| put_word( rsrctab - lfanew ); /* ne_rsrctab */ |
| put_word( restab - lfanew ); /* ne_restab */ |
| put_word( modtab - lfanew ); /* ne_modtab */ |
| put_word( imptab - lfanew ); /* ne_imptab */ |
| put_dword( 0 ); /* ne_nrestab */ |
| put_word( 0 ); /* ne_cmovent */ |
| put_word( 0 ); /* ne_align */ |
| put_word( 0 ); /* ne_cres */ |
| put_byte( 2 /*NE_OSFLAGS_WINDOWS*/ ); /* ne_exetyp */ |
| put_byte( 8 /*NE_AFLAGS_FASTLOAD*/ ); /* ne_flagsothers */ |
| put_word( 0 ); /* ne_pretthunks */ |
| put_word( 0 ); /* ne_psegrefbytes */ |
| put_word( 0 ); /* ne_swaparea */ |
| put_word( 0 ); /* ne_expver */ |
| |
| /* segment table */ |
| put_word( codeseg ); |
| put_word( sizeof(code_segment) ); |
| put_word( 0x2000 /* NE_SEGFLAGS_32BIT */ ); |
| put_word( sizeof(code_segment) ); |
| put_word( dataseg ); |
| put_word( sizeof(data_segment) ); |
| put_word( 0x0001 /* NE_SEGFLAGS_DATA */ ); |
| put_word( sizeof(data_segment) ); |
| |
| /* resource directory */ |
| if (spec->nb_resources) |
| { |
| output_bin_res16_directory( spec, rsrcdata ); |
| align_output( 2 ); |
| } |
| |
| /* resident names table */ |
| put_byte( namelen ); |
| for (i = 0; i < namelen; i++) put_byte( toupper(spec->dll_name[i]) ); |
| put_byte( 0 ); |
| align_output( 2 ); |
| |
| /* imported names table */ |
| put_word( 0 ); |
| |
| /* entry table */ |
| put_byte( 0 ); |
| align_output( 2 ); |
| |
| /* code segment */ |
| put_data( code_segment, sizeof(code_segment) ); |
| |
| /* data segment */ |
| put_data( data_segment, sizeof(data_segment) ); |
| |
| /* resource data */ |
| output_bin_res16_data( spec ); |
| |
| flush_output_buffer(); |
| } |