/******************************************************************* * BuildPendingEventCheck * * Build a function that checks whether there are any * pending DPMI events. * * Stack layout: * * (sp+12) long eflags * (sp+6) long cs * (sp+2) long ip * (sp) word fs * * On entry to function, fs register points to a valid TEB. * On exit from function, stack will be popped. */ static void BuildPendingEventCheck(void) { /* Function header */ function_header( "DPMI_PendingEventCheck" ); /* Check for pending events. */ output( "\t.byte 0x64\n\ttestl $0xffffffff,(%d)\n", STRUCTOFFSET(TEB,GdiTebBatch) + STRUCTOFFSET(WINE_VM86_TEB_INFO,vm86_pending) ); output( "\tje %s\n", asm_name("DPMI_PendingEventCheck_Cleanup") ); output( "\t.byte 0x64\n\ttestl $0xffffffff,(%d)\n", STRUCTOFFSET(TEB,GdiTebBatch) + STRUCTOFFSET(WINE_VM86_TEB_INFO,dpmi_vif) ); output( "\tje %s\n", asm_name("DPMI_PendingEventCheck_Cleanup") ); /* Process pending events. */ output( "\tsti\n" ); /* Start cleanup. Restore fs register. */ output( "%s\n", asm_globl("DPMI_PendingEventCheck_Cleanup") ); output( "\tpopw %%fs\n" ); /* Return from function. */ output( "%s\n", asm_globl("DPMI_PendingEventCheck_Return") ); output( "\tiret\n" ); output_function_size( "DPMI_PendingEventCheck" ); }
/******************************************************************* * output_asm_constructor * * Output code for calling a dll constructor. */ static void output_asm_constructor( const char *constructor ) { if (target_platform == PLATFORM_APPLE) { /* Mach-O doesn't have an init section */ output( "\n\t.mod_init_func\n" ); output( "\t.align %d\n", get_alignment(4) ); output( "\t.long %s\n", asm_name(constructor) ); } else { output( "\n\t.section \".init\",\"ax\"\n" ); switch(target_cpu) { case CPU_x86: case CPU_x86_64: output( "\tcall %s\n", asm_name(constructor) ); break; case CPU_SPARC: output( "\tcall %s\n", asm_name(constructor) ); output( "\tnop\n" ); break; case CPU_ARM: case CPU_POWERPC: output( "\tbl %s\n", asm_name(constructor) ); break; } } }
/******************************************************************* * output_asm_constructor * * Output code for calling a dll constructor. */ static void output_asm_constructor( const char *constructor ) { if (target_platform == PLATFORM_APPLE) { /* Mach-O doesn't have an init section */ output( "\n\t.mod_init_func\n" ); output( "\t.align %d\n", get_alignment(get_ptr_size()) ); output( "\t%s %s\n", get_asm_ptr_keyword(), asm_name(constructor) ); } else { switch(target_cpu) { case CPU_x86: case CPU_x86_64: // output( "\n\t.section \".init\",\"ax\"\n" ); output( "\n\t.section .init,\"ax\"\n" ); output( "\tcall %s\n", asm_name(constructor) ); break; case CPU_ARM: output( "\n\t.section \".text\",\"ax\"\n" ); output( "\tblx %s\n", asm_name(constructor) ); break; case CPU_ARM64: case CPU_POWERPC: output( "\n\t.section \".init\",\"ax\"\n" ); output( "\tbl %s\n", asm_name(constructor) ); break; } } }
/* output import stubs for exported entry points that link to external symbols */ static void output_external_link_imports( DLLSPEC *spec ) { unsigned int i, pos; if (!ext_link_imports.count) return; /* nothing to do */ sort_names( &ext_link_imports ); /* get rid of duplicate names */ for (i = 1; i < ext_link_imports.count; i++) { if (!strcmp( ext_link_imports.names[i-1], ext_link_imports.names[i] )) remove_name( &ext_link_imports, i-- ); } output( "\n/* external link thunks */\n\n" ); output( "\t.data\n" ); output( "\t.align %d\n", get_alignment(get_ptr_size()) ); output( ".L__wine_spec_external_links:\n" ); for (i = 0; i < ext_link_imports.count; i++) output( "\t%s %s\n", get_asm_ptr_keyword(), asm_name(ext_link_imports.names[i]) ); output( "\n\t.text\n" ); output( "\t.align %d\n", get_alignment(get_ptr_size()) ); output( "%s:\n", asm_name("__wine_spec_external_link_thunks") ); for (i = pos = 0; i < ext_link_imports.count; i++) { char *buffer = strmake( "__wine_spec_ext_link_%s", ext_link_imports.names[i] ); output_import_thunk( buffer, ".L__wine_spec_external_links", pos ); free( buffer ); pos += get_ptr_size(); } output_function_size( "__wine_spec_external_link_thunks" ); }
/******************************************************************* * BuildRet16Func * * Build the return code for 16-bit callbacks */ static void BuildRet16Func(void) { function_header( "__wine_call_to_16_ret" ); /* Save %esp into %esi */ output( "\tmovl %%esp,%%esi\n" ); /* Restore 32-bit segment registers */ output( "\t.byte 0x2e\n\tmovl %s", asm_name("CallTo16_DataSelector") ); output( "-%s,%%edi\n", asm_name("__wine_call16_start") ); output( "\tmovw %%di,%%ds\n" ); output( "\tmovw %%di,%%es\n" ); output( "\t.byte 0x2e\n\tmov %s", asm_name("CallTo16_TebSelector") ); output( "-%s,%%fs\n", asm_name("__wine_call16_start") ); output( "\t.byte 0x64\n\tmov (%d),%%gs\n", GS_OFFSET ); /* Restore the 32-bit stack */ output( "\tmovw %%di,%%ss\n" ); output( "\t.byte 0x64\n\tmovl (%d),%%esp\n", STACKOFFSET ); /* Return to caller */ output( "\tlret\n" ); output_function_size( "__wine_call_to_16_ret" ); }
/* create a .o file that references all the undefined symbols we want to resolve */ static char *create_undef_symbols_file( DLLSPEC *spec ) { char *as_file, *obj_file; int i; unsigned int j; FILE *f; as_file = get_temp_file_name( output_file_name, ".s" ); if (!(f = fopen( as_file, "w" ))) fatal_error( "Cannot create %s\n", as_file ); fprintf( f, "\t.data\n" ); for (i = 0; i < spec->nb_entry_points; i++) { ORDDEF *odp = &spec->entry_points[i]; if (odp->type == TYPE_STUB || odp->type == TYPE_ABS || odp->type == TYPE_VARIABLE) continue; if (odp->flags & FLAG_FORWARD) continue; fprintf( f, "\t%s %s\n", get_asm_ptr_keyword(), asm_name(odp->link_name) ); } for (j = 0; j < extra_ld_symbols.count; j++) fprintf( f, "\t%s %s\n", get_asm_ptr_keyword(), asm_name(extra_ld_symbols.names[j]) ); fclose( f ); obj_file = get_temp_file_name( output_file_name, ".o" ); assemble_file( as_file, obj_file ); return obj_file; }
/******************************************************************* * BuildRelays16 * * Build all the 16-bit relay callbacks */ void BuildRelays16(void) { if (target_cpu != CPU_x86) { output( "/* File not used with this architecture. Do not edit! */\n\n" ); return; } /* File header */ output( "/* File generated automatically. Do not edit! */\n\n" ); output( "\t.text\n" ); output( "%s:\n\n", asm_name("__wine_spec_thunk_text_16") ); output( "%s\n", asm_globl("__wine_call16_start") ); /* Standard CallFrom16 routine */ BuildCallFrom16Core( FALSE, FALSE ); /* Register CallFrom16 routine */ BuildCallFrom16Core( TRUE, FALSE ); /* C16ThkSL CallFrom16 routine */ BuildCallFrom16Core( FALSE, TRUE ); /* Standard CallTo16 routine */ BuildCallTo16Core( 0 ); /* Register CallTo16 routine */ BuildCallTo16Core( 1 ); /* Standard CallTo16 return stub */ BuildRet16Func(); /* CBClientThunkSL routine */ BuildCallTo32CBClient( FALSE ); /* CBClientThunkSLEx routine */ BuildCallTo32CBClient( TRUE ); /* Pending DPMI events check stub */ BuildPendingEventCheck(); output( "%s\n", asm_globl("__wine_call16_end") ); output_function_size( "__wine_spec_thunk_text_16" ); /* Declare the return address and data selector variables */ output( "\n\t.data\n\t.align %d\n", get_alignment(4) ); output( "%s\n\t.long 0\n", asm_globl("CallTo16_DataSelector") ); output( "%s\n\t.long 0\n", asm_globl("CallTo16_TebSelector") ); if (UsePIC) output( "wine_ldt_copy_ptr:\t.long %s\n", asm_name("wine_ldt_copy") ); output_gnu_stack_note(); }
/* output a single import thunk */ static void output_import_thunk( const char *name, const char *table, int pos ) { output( "\n\t.align %d\n", get_alignment(4) ); output( "\t%s\n", func_declaration(name) ); output( "%s\n", asm_globl(name) ); output_cfi( ".cfi_startproc" ); switch(target_cpu) { case CPU_x86: if (!UsePIC) { output( "\tjmp *(%s+%d)\n", table, pos ); } else { output( "\tcall %s\n", asm_name("__wine_spec_get_pc_thunk_eax") ); output( "1:\tjmp *%s+%d-1b(%%eax)\n", table, pos ); } break; case CPU_x86_64: output( "\tjmpq *%s+%d(%%rip)\n", table, pos ); break; case CPU_ARM: output( "\tldr IP,1f\n"); output( "\tldr PC,[PC,IP]\n" ); output( "1:\t.long %s+%u-(1b+4)\n", table, pos ); break; case CPU_ARM64: output( "\tadr x9, 1f\n" ); output( "\tldur x9, [x9, #0]\n" ); if (pos & 0xf000) output( "\tadd x9, x9, #%u\n", pos & 0xf000 ); if (pos & 0x0f00) output( "\tadd x9, x9, #%u\n", pos & 0x0f00 ); if (pos & 0x00f0) output( "\tadd x9, x9, #%u\n", pos & 0x00f0 ); if (pos & 0x000f) output( "\tadd x9, x9, #%u\n", pos & 0x000f ); output( "\tldur x9, [x9, #0]\n" ); output( "\tbr x9\n" ); output( "1:\t.quad %s\n", table ); break; case CPU_POWERPC: output( "\tmr %s, %s\n", ppc_reg(0), ppc_reg(31) ); if (target_platform == PLATFORM_APPLE) { output( "\tlis %s, ha16(%s+%d+32768)\n", ppc_reg(31), table, pos ); output( "\tla %s, lo16(%s+%d)(%s)\n", ppc_reg(31), table, pos, ppc_reg(31) ); } else { output( "\tlis %s, (%s+%d+32768)@h\n", ppc_reg(31), table, pos ); output( "\tla %s, (%s+%d)@l(%s)\n", ppc_reg(31), table, pos, ppc_reg(31) ); } output( "\tlwz %s, 0(%s)\n", ppc_reg(31), ppc_reg(31) ); output( "\tmtctr %s\n", ppc_reg(31) ); output( "\tmr %s, %s\n", ppc_reg(31), ppc_reg(0) ); output( "\tbctr\n" ); break; } output_cfi( ".cfi_endproc" ); output_function_size( name ); }
/* output the import thunks of a Win32 module */ static void output_immediate_import_thunks(void) { int i, j, pos; int nb_imm = nb_imports - nb_delayed; static const char import_thunks[] = "__wine_spec_import_thunks"; if (!nb_imm) return; output( "\n/* immediate import thunks */\n\n" ); output( "\t.text\n" ); output( "\t.align %d\n", get_alignment(8) ); output( "%s:\n", asm_name(import_thunks)); for (i = pos = 0; i < nb_imports; i++) { if (dll_imports[i]->delay) continue; for (j = 0; j < dll_imports[i]->nb_imports; j++, pos += get_ptr_size()) { ORDDEF *odp = dll_imports[i]->imports[j]; output_import_thunk( odp->name ? odp->name : odp->export_name, ".L__wine_spec_import_data_ptrs", pos ); } pos += get_ptr_size(); } output_function_size( import_thunks ); }
/* output the get_pc thunk if needed */ void output_get_pc_thunk(void) { if (target_cpu != CPU_x86) return; if (!UsePIC) return; output( "\n\t.text\n" ); output( "\t.align %d\n", get_alignment(4) ); output( "\t%s\n", func_declaration("__wine_spec_get_pc_thunk_eax") ); output( "%s:\n", asm_name("__wine_spec_get_pc_thunk_eax") ); output_cfi( ".cfi_startproc" ); output( "\tmovl (%%esp),%%eax\n" ); output( "\tret\n" ); output_cfi( ".cfi_endproc" ); output_function_size( "__wine_spec_get_pc_thunk_eax" ); }
/******************************************************************* * BuildRelays32 * * Build all the 32-bit relay callbacks */ void BuildRelays32(void) { if (target_cpu != CPU_x86) { output( "/* File not used with this architecture. Do not edit! */\n\n" ); return; } /* File header */ output( "/* File generated automatically. Do not edit! */\n\n" ); output( "\t.text\n" ); output( "%s:\n\n", asm_name("__wine_spec_thunk_text_32") ); /* 32-bit register entry point */ BuildCallFrom32Regs(); output_function_size( "__wine_spec_thunk_text_32" ); output_gnu_stack_note(); }
/******************************************************************* * output_asm_relays16 * * Build all the 16-bit relay callbacks */ void output_asm_relays16(void) { /* File header */ output( "\t.text\n" ); output( "%s:\n\n", asm_name("__wine_spec_thunk_text_16") ); output( "%s\n", asm_globl("__wine_call16_start") ); /* Standard CallFrom16 routine */ BuildCallFrom16Core( 0, 0 ); /* Register CallFrom16 routine */ BuildCallFrom16Core( 1, 0 ); /* C16ThkSL CallFrom16 routine */ BuildCallFrom16Core( 0, 1 ); /* Standard CallTo16 routine */ BuildCallTo16Core( 0 ); /* Register CallTo16 routine */ BuildCallTo16Core( 1 ); /* Standard CallTo16 return stub */ BuildRet16Func(); /* CBClientThunkSL routine */ BuildCallTo32CBClient( 0 ); /* CBClientThunkSLEx routine */ BuildCallTo32CBClient( 1 ); output( "%s\n", asm_globl("__wine_call16_end") ); output_function_size( "__wine_spec_thunk_text_16" ); /* Declare the return address and data selector variables */ output( "\n\t.data\n\t.align %d\n", get_alignment(4) ); output( "%s\n\t.long 0\n", asm_globl("CallTo16_DataSelector") ); output( "%s\n\t.long 0\n", asm_globl("CallTo16_TebSelector") ); }
/******************************************************************* * 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("%s:/*?*/\n", asm_name("_end")); }
/* read in the list of undefined symbols */ void read_undef_symbols( DLLSPEC *spec, char **argv ) { size_t prefix_len; FILE *f; const char *prog = get_nm_command(); char *cmd, buffer[1024], name_prefix[16]; int err; const char *name; if (!argv[0]) return; add_extra_undef_symbols( spec ); strcpy( name_prefix, asm_name("") ); prefix_len = strlen( name_prefix ); name = ldcombine_files( spec, argv ); cmd = strmake( "%s -u %s", prog, name ); if (!(f = popen( cmd, "r" ))) fatal_error( "Cannot execute '%s'\n", cmd ); while (fgets( buffer, sizeof(buffer), f )) { char *p = buffer + strlen(buffer) - 1; if (p < buffer) continue; if (*p == '\n') *p-- = 0; p = buffer; while (*p == ' ') p++; if (p[0] == 'U' && p[1] == ' ' && p[2]) p += 2; if (prefix_len && !strncmp( p, name_prefix, prefix_len )) p += prefix_len; add_name( &undef_symbols, p ); } if ((err = pclose( f ))) warning( "%s failed with status %d\n", cmd, err ); free( cmd ); }
/******************************************************************* * output_exports * * Output the export table for a Win32 module. */ void output_exports( DLLSPEC *spec ) { int i, fwd_size = 0; int nr_exports = spec->base <= spec->limit ? spec->limit - spec->base + 1 : 0; if (!nr_exports) return; output( "\n/* export table */\n\n" ); output( "\t.data\n" ); output( "\t.align %d\n", get_alignment(4) ); output( ".L__wine_spec_exports:\n" ); /* export directory header */ output( "\t.long 0\n" ); /* Characteristics */ output( "\t.long 0\n" ); /* TimeDateStamp */ output( "\t.long 0\n" ); /* MajorVersion/MinorVersion */ output( "\t.long .L__wine_spec_exp_names-.L__wine_spec_rva_base\n" ); /* Name */ output( "\t.long %u\n", spec->base ); /* Base */ output( "\t.long %u\n", nr_exports ); /* NumberOfFunctions */ output( "\t.long %u\n", spec->nb_names ); /* NumberOfNames */ output( "\t.long .L__wine_spec_exports_funcs-.L__wine_spec_rva_base\n" ); /* AddressOfFunctions */ if (spec->nb_names) { output( "\t.long .L__wine_spec_exp_name_ptrs-.L__wine_spec_rva_base\n" ); /* AddressOfNames */ output( "\t.long .L__wine_spec_exp_ordinals-.L__wine_spec_rva_base\n" ); /* AddressOfNameOrdinals */ } else { output( "\t.long 0\n" ); /* AddressOfNames */ output( "\t.long 0\n" ); /* AddressOfNameOrdinals */ } /* output the function pointers */ output( "\n.L__wine_spec_exports_funcs:\n" ); for (i = spec->base; i <= spec->limit; i++) { ORDDEF *odp = spec->ordinals[i]; if (!odp) output( "\t%s 0\n", get_asm_ptr_keyword() ); else switch(odp->type) { case TYPE_EXTERN: case TYPE_STDCALL: case TYPE_VARARGS: case TYPE_CDECL: case TYPE_THISCALL: if (odp->flags & FLAG_FORWARD) { output( "\t%s .L__wine_spec_forwards+%u\n", get_asm_ptr_keyword(), fwd_size ); fwd_size += strlen(odp->link_name) + 1; } else if (odp->flags & FLAG_EXT_LINK) { output( "\t%s %s_%s\n", get_asm_ptr_keyword(), asm_name("__wine_spec_ext_link"), odp->link_name ); } else { output( "\t%s %s\n", get_asm_ptr_keyword(), asm_name(odp->link_name) ); } break; case TYPE_STUB: output( "\t%s %s\n", get_asm_ptr_keyword(), asm_name( get_stub_name( odp, spec )) ); break; default: assert(0); } } if (spec->nb_names) { /* output the function name pointers */ int namepos = strlen(spec->file_name) + 1; output( "\n.L__wine_spec_exp_name_ptrs:\n" ); for (i = 0; i < spec->nb_names; i++) { output( "\t.long .L__wine_spec_exp_names+%u-.L__wine_spec_rva_base\n", namepos ); namepos += strlen(spec->names[i]->name) + 1; } /* output the function ordinals */ output( "\n.L__wine_spec_exp_ordinals:\n" ); for (i = 0; i < spec->nb_names; i++) { output( "\t%s %d\n", get_asm_short_keyword(), spec->names[i]->ordinal - spec->base ); } if (spec->nb_names % 2) { output( "\t%s 0\n", get_asm_short_keyword() ); } } /* output the export name strings */ output( "\n.L__wine_spec_exp_names:\n" ); output( "\t%s \"%s\"\n", get_asm_string_keyword(), spec->file_name ); for (i = 0; i < spec->nb_names; i++) output( "\t%s \"%s\"\n", get_asm_string_keyword(), spec->names[i]->name ); /* output forward strings */ if (fwd_size) { output( "\n.L__wine_spec_forwards:\n" ); for (i = spec->base; i <= spec->limit; i++) { ORDDEF *odp = spec->ordinals[i]; if (odp && (odp->flags & FLAG_FORWARD)) output( "\t%s \"%s\"\n", get_asm_string_keyword(), odp->link_name ); } } output( "\t.align %d\n", get_alignment(get_ptr_size()) ); output( ".L__wine_spec_exports_end:\n" ); /* output relays */ if (!has_relays( spec )) { output( "\t%s 0\n", get_asm_ptr_keyword() ); return; } output( ".L__wine_spec_relay_descr:\n" ); output( "\t%s 0xdeb90001\n", get_asm_ptr_keyword() ); /* magic */ output( "\t%s 0,0\n", get_asm_ptr_keyword() ); /* relay funcs */ output( "\t%s 0\n", get_asm_ptr_keyword() ); /* private data */ output( "\t%s __wine_spec_relay_entry_points\n", get_asm_ptr_keyword() ); output( "\t%s .L__wine_spec_relay_entry_point_offsets\n", get_asm_ptr_keyword() ); output( "\t%s .L__wine_spec_relay_arg_types\n", get_asm_ptr_keyword() ); output_relay_debug( spec ); }
/******************************************************************* * output_stubs * * Output the functions for stub entry points */ void output_stubs( DLLSPEC *spec ) { const char *name, *exp_name; int i, count; if (!has_stubs( spec )) return; output( "\n/* stub functions */\n\n" ); output( "\t.text\n" ); for (i = count = 0; i < spec->nb_entry_points; i++) { ORDDEF *odp = &spec->entry_points[i]; if (odp->type != TYPE_STUB) continue; name = get_stub_name( odp, spec ); exp_name = odp->name ? odp->name : odp->export_name; output( "\t.align %d\n", get_alignment(4) ); output( "\t%s\n", func_declaration(name) ); output( "%s:\n", asm_name(name) ); output_cfi( ".cfi_startproc" ); switch (target_cpu) { case CPU_x86: /* flesh out the stub a bit to make safedisc happy */ output(" \tnop\n" ); output(" \tnop\n" ); output(" \tnop\n" ); output(" \tnop\n" ); output(" \tnop\n" ); output(" \tnop\n" ); output(" \tnop\n" ); output(" \tnop\n" ); output(" \tnop\n" ); output( "\tsubl $12,%%esp\n" ); output_cfi( ".cfi_adjust_cfa_offset 12" ); if (UsePIC) { output( "\tcall %s\n", asm_name("__wine_spec_get_pc_thunk_eax") ); output( "1:" ); if (exp_name) { output( "\tleal .L%s_string-1b(%%eax),%%ecx\n", name ); output( "\tmovl %%ecx,4(%%esp)\n" ); count++; } else output( "\tmovl $%d,4(%%esp)\n", odp->ordinal ); output( "\tleal .L__wine_spec_file_name-1b(%%eax),%%ecx\n" ); output( "\tmovl %%ecx,(%%esp)\n" ); } else { if (exp_name) { output( "\tmovl $.L%s_string,4(%%esp)\n", name ); count++; } else output( "\tmovl $%d,4(%%esp)\n", odp->ordinal ); output( "\tmovl $.L__wine_spec_file_name,(%%esp)\n" ); } output( "\tcall %s\n", asm_name("__wine_spec_unimplemented_stub") ); break; case CPU_x86_64: output( "\tsubq $8,%%rsp\n" ); output_cfi( ".cfi_adjust_cfa_offset 8" ); output( "\tleaq .L__wine_spec_file_name(%%rip),%%rdi\n" ); if (exp_name) { output( "leaq .L%s_string(%%rip),%%rsi\n", name ); count++; } else output( "\tmovq $%d,%%rsi\n", odp->ordinal ); output( "\tcall %s\n", asm_name("__wine_spec_unimplemented_stub") ); break; case CPU_ARM: output( "\tldr r0,[PC,#0]\n"); output( "\tmov PC,PC\n"); output( "\t.long .L__wine_spec_file_name\n" ); output( "\tldr r1,[PC,#0]\n"); output( "\tmov PC,PC\n"); if (exp_name) { output( "\t.long .L%s_string\n", name ); count++; } else output( "\t.long %d\n", odp->ordinal ); output( "\tbl %s\n", asm_name("__wine_spec_unimplemented_stub") ); break; default: assert(0); } output_cfi( ".cfi_endproc" ); output_function_size( name ); } if (count) { output( "\t%s\n", get_asm_string_section() ); for (i = 0; i < spec->nb_entry_points; i++) { ORDDEF *odp = &spec->entry_points[i]; if (odp->type != TYPE_STUB) continue; exp_name = odp->name ? odp->name : odp->export_name; if (exp_name) { name = get_stub_name( odp, spec ); output( ".L%s_string:\n", name ); output( "\t%s \"%s\"\n", get_asm_string_keyword(), exp_name ); } } } }
/******************************************************************* * output_relay_debug * * Output entry points for relay debugging */ static void output_relay_debug( FILE *outfile, DLLSPEC *spec ) { unsigned int i, j, args, flags; /* first the table of entry point offsets */ fprintf( outfile, "\t%s\n", get_asm_rodata_section() ); fprintf( outfile, "\t.align %d\n", get_alignment(4) ); fprintf( outfile, ".L__wine_spec_relay_entry_point_offsets:\n" ); for (i = spec->base; i <= spec->limit; i++) { ORDDEF *odp = spec->ordinals[i]; if (needs_relay( odp )) fprintf( outfile, "\t.long .L__wine_spec_relay_entry_point_%d-__wine_spec_relay_entry_points\n", i ); else fprintf( outfile, "\t.long 0\n" ); } /* then the table of argument types */ fprintf( outfile, "\t.align %d\n", get_alignment(4) ); fprintf( outfile, ".L__wine_spec_relay_arg_types:\n" ); for (i = spec->base; i <= spec->limit; i++) { ORDDEF *odp = spec->ordinals[i]; unsigned int mask = 0; if (needs_relay( odp )) { for (j = 0; j < 16 && odp->u.func.arg_types[j]; j++) { if (odp->u.func.arg_types[j] == 't') mask |= 1<< (j*2); if (odp->u.func.arg_types[j] == 'W') mask |= 2<< (j*2); } } fprintf( outfile, "\t.long 0x%08x\n", mask ); } /* then the relay thunks */ fprintf( outfile, "\t.text\n" ); fprintf( outfile, "__wine_spec_relay_entry_points:\n" ); fprintf( outfile, "\tnop\n" ); /* to avoid 0 offset */ for (i = spec->base; i <= spec->limit; i++) { ORDDEF *odp = spec->ordinals[i]; if (!needs_relay( odp )) continue; fprintf( outfile, "\t.align %d\n", get_alignment(4) ); fprintf( outfile, ".L__wine_spec_relay_entry_point_%d:\n", i ); if (odp->flags & FLAG_REGISTER) fprintf( outfile, "\tpushl %%eax\n" ); else fprintf( outfile, "\tpushl %%esp\n" ); args = strlen(odp->u.func.arg_types); flags = 0; if (odp->flags & FLAG_RET64) flags |= 1; if (odp->type == TYPE_STDCALL) flags |= 2; fprintf( outfile, "\tpushl $%u\n", (flags << 24) | (args << 16) | (i - spec->base) ); if (UsePIC) { fprintf( outfile, "\tcall %s\n", asm_name("__wine_spec_get_pc_thunk_eax") ); fprintf( outfile, "1:\tleal .L__wine_spec_relay_descr-1b(%%eax),%%eax\n" ); } else fprintf( outfile, "\tmovl $.L__wine_spec_relay_descr,%%eax\n" ); fprintf( outfile, "\tpushl %%eax\n" ); if (odp->flags & FLAG_REGISTER) { fprintf( outfile, "\tcall *8(%%eax)\n" ); } else { fprintf( outfile, "\tcall *4(%%eax)\n" ); if (odp->type == TYPE_STDCALL) fprintf( outfile, "\tret $%u\n", args * get_ptr_size() ); else fprintf( outfile, "\tret\n" ); } } }
void symtab_node::dump_base (FILE *f) { static const char * const visibility_types[] = { "default", "protected", "hidden", "internal" }; fprintf (f, "%s/%i (%s)", asm_name (), order, name ()); dump_addr (f, " @", (void *)this); fprintf (f, "\n Type: %s", symtab_type_names[type]); if (definition) fprintf (f, " definition"); if (analyzed) fprintf (f, " analyzed"); if (alias) fprintf (f, " alias"); if (weakref) fprintf (f, " weakref"); if (cpp_implicit_alias) fprintf (f, " cpp_implicit_alias"); if (alias_target) fprintf (f, " target:%s", DECL_P (alias_target) ? IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (alias_target)) : IDENTIFIER_POINTER (alias_target)); if (body_removed) fprintf (f, "\n Body removed by symtab_remove_unreachable_nodes"); fprintf (f, "\n Visibility:"); if (in_other_partition) fprintf (f, " in_other_partition"); if (used_from_other_partition) fprintf (f, " used_from_other_partition"); if (force_output) fprintf (f, " force_output"); if (forced_by_abi) fprintf (f, " forced_by_abi"); if (externally_visible) fprintf (f, " externally_visible"); if (resolution != LDPR_UNKNOWN) fprintf (f, " %s", ld_plugin_symbol_resolution_names[(int)resolution]); if (TREE_ASM_WRITTEN (decl)) fprintf (f, " asm_written"); if (DECL_EXTERNAL (decl)) fprintf (f, " external"); if (TREE_PUBLIC (decl)) fprintf (f, " public"); if (DECL_COMMON (decl)) fprintf (f, " common"); if (DECL_WEAK (decl)) fprintf (f, " weak"); if (DECL_DLLIMPORT_P (decl)) fprintf (f, " dll_import"); if (DECL_COMDAT (decl)) fprintf (f, " comdat"); if (get_comdat_group ()) fprintf (f, " comdat_group:%s", IDENTIFIER_POINTER (get_comdat_group_id ())); if (DECL_ONE_ONLY (decl)) fprintf (f, " one_only"); if (get_section ()) fprintf (f, " section:%s", get_section ()); if (implicit_section) fprintf (f," (implicit_section)"); if (DECL_VISIBILITY_SPECIFIED (decl)) fprintf (f, " visibility_specified"); if (DECL_VISIBILITY (decl)) fprintf (f, " visibility:%s", visibility_types [DECL_VISIBILITY (decl)]); if (DECL_VIRTUAL_P (decl)) fprintf (f, " virtual"); if (DECL_ARTIFICIAL (decl)) fprintf (f, " artificial"); if (TREE_CODE (decl) == FUNCTION_DECL) { if (DECL_STATIC_CONSTRUCTOR (decl)) fprintf (f, " constructor"); if (DECL_STATIC_DESTRUCTOR (decl)) fprintf (f, " destructor"); } fprintf (f, "\n"); if (same_comdat_group) fprintf (f, " Same comdat group as: %s/%i\n", same_comdat_group->asm_name (), same_comdat_group->order); if (next_sharing_asm_name) fprintf (f, " next sharing asm name: %i\n", next_sharing_asm_name->order); if (previous_sharing_asm_name) fprintf (f, " previous sharing asm name: %i\n", previous_sharing_asm_name->order); if (address_taken) fprintf (f, " Address is taken.\n"); if (aux) { fprintf (f, " Aux:"); dump_addr (f, " @", (void *)aux); } fprintf (f, " References: "); dump_references (f); fprintf (f, " Referring: "); dump_referring (f); if (lto_file_data) fprintf (f, " Read from file: %s\n", lto_file_data->file_name); }
/******************************************************************* * 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("_imp__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 ); }
/******************************************************************* * 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("\t.globl __wine_spec_dos_header\n"); output("__wine_spec_dos_header:\n"); output("\t.globl _wine_spec_dos_header\n"); output("_wine_spec_dos_header:\n"); 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_stdcall16( odp->type == TYPE_STUB ? get_stub_name( odp, spec ) : odp->link_name , odp)); 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("_imp__wine_ldt_copy") ); } free( typelist ); }
/******************************************************************* * BuildCallFrom16Core * * This routine builds the core routines used in 16->32 thunks: * CallFrom16Word, CallFrom16Long, CallFrom16Register, and CallFrom16Thunk. * * These routines are intended to be called via a far call (with 32-bit * operand size) from 16-bit code. The 16-bit code stub must push %bp, * the 32-bit entry point to be called, and the argument conversion * routine to be used (see stack layout below). * * The core routine completes the STACK16FRAME on the 16-bit stack and * switches to the 32-bit stack. Then, the argument conversion routine * is called; it gets passed the 32-bit entry point and a pointer to the * 16-bit arguments (on the 16-bit stack) as parameters. (You can either * use conversion routines automatically generated by BuildCallFrom16, * or write your own for special purposes.) * * The conversion routine must call the 32-bit entry point, passing it * the converted arguments, and return its return value to the core. * After the conversion routine has returned, the core switches back * to the 16-bit stack, converts the return value to the DX:AX format * (CallFrom16Long), and returns to the 16-bit call stub. All parameters, * including %bp, are popped off the stack. * * The 16-bit call stub now returns to the caller, popping the 16-bit * arguments if necessary (pascal calling convention). * * In the case of a 'register' function, CallFrom16Register fills a * CONTEXT86 structure with the values all registers had at the point * the first instruction of the 16-bit call stub was about to be * executed. A pointer to this CONTEXT86 is passed as third parameter * to the argument conversion routine, which typically passes it on * to the called 32-bit entry point. * * CallFrom16Thunk is a special variant used by the implementation of * the Win95 16->32 thunk functions C16ThkSL and C16ThkSL01 and is * implemented as follows: * On entry, the EBX register is set up to contain a flat pointer to the * 16-bit stack such that EBX+22 points to the first argument. * Then, the entry point is called, while EBP is set up to point * to the return address (on the 32-bit stack). * The called function returns with CX set to the number of bytes * to be popped of the caller's stack. * * Stack layout upon entry to the core routine (STACK16FRAME): * ... ... * (sp+24) word first 16-bit arg * (sp+22) word cs * (sp+20) word ip * (sp+18) word bp * (sp+14) long 32-bit entry point (reused for Win16 mutex recursion count) * (sp+12) word ip of actual entry point (necessary for relay debugging) * (sp+8) long relay (argument conversion) function entry point * (sp+4) long cs of 16-bit entry point * (sp) long ip of 16-bit entry point * * Added on the stack: * (sp-2) word saved gs * (sp-4) word saved fs * (sp-6) word saved es * (sp-8) word saved ds * (sp-12) long saved ebp * (sp-16) long saved ecx * (sp-20) long saved edx * (sp-24) long saved previous stack */ static void BuildCallFrom16Core( int reg_func, int thunk ) { /* Function header */ if (thunk) function_header( "__wine_call_from_16_thunk" ); else if (reg_func) function_header( "__wine_call_from_16_regs" ); else function_header( "__wine_call_from_16" ); /* Create STACK16FRAME (except STACK32FRAME link) */ output( "\tpushw %%gs\n" ); output( "\tpushw %%fs\n" ); output( "\tpushw %%es\n" ); output( "\tpushw %%ds\n" ); output( "\tpushl %%ebp\n" ); output( "\tpushl %%ecx\n" ); output( "\tpushl %%edx\n" ); /* Save original EFlags register */ if (reg_func) output( "\tpushfl\n" ); if ( UsePIC ) { output( "\tcall 1f\n" ); output( "1:\tpopl %%ecx\n" ); output( "\t.byte 0x2e\n\tmovl %s-1b(%%ecx),%%edx\n", asm_name("CallTo16_DataSelector") ); } else output( "\t.byte 0x2e\n\tmovl %s,%%edx\n", asm_name("CallTo16_DataSelector") ); /* Load 32-bit segment registers */ output( "\tmovw %%dx, %%ds\n" ); output( "\tmovw %%dx, %%es\n" ); if ( UsePIC ) output( "\tmovw %s-1b(%%ecx), %%fs\n", asm_name("CallTo16_TebSelector") ); else output( "\tmovw %s, %%fs\n", asm_name("CallTo16_TebSelector") ); output( "\t.byte 0x64\n\tmov (%d),%%gs\n", GS_OFFSET ); /* Translate STACK16FRAME base to flat offset in %edx */ output( "\tmovw %%ss, %%dx\n" ); output( "\tandl $0xfff8, %%edx\n" ); output( "\tshrl $1, %%edx\n" ); if (UsePIC) { output( "\taddl wine_ldt_copy_ptr-1b(%%ecx),%%edx\n" ); output( "\tmovl (%%edx), %%edx\n" ); } else output( "\tmovl %s(%%edx), %%edx\n", asm_name("wine_ldt_copy") ); output( "\tmovzwl %%sp, %%ebp\n" ); output( "\tleal %d(%%ebp,%%edx), %%edx\n", reg_func ? 0 : -4 ); /* Get saved flags into %ecx */ if (reg_func) output( "\tpopl %%ecx\n" ); /* Get the 32-bit stack pointer from the TEB and complete STACK16FRAME */ output( "\t.byte 0x64\n\tmovl (%d), %%ebp\n", STACKOFFSET ); output( "\tpushl %%ebp\n" ); /* Switch stacks */ output( "\t.byte 0x64\n\tmovw %%ss, (%d)\n", STACKOFFSET + 2 ); output( "\t.byte 0x64\n\tmovw %%sp, (%d)\n", STACKOFFSET ); output( "\tpushl %%ds\n" ); output( "\tpopl %%ss\n" ); output( "\tmovl %%ebp, %%esp\n" ); output( "\taddl $0x20,%%ebp\n"); /* FIELD_OFFSET(STACK32FRAME,ebp) */ /* At this point: STACK16FRAME is completely set up DS, ES, SS: flat data segment FS: current TEB ESP: points to last STACK32FRAME EBP: points to ebp member of last STACK32FRAME EDX: points to current STACK16FRAME ECX: contains saved flags all other registers: unchanged */ /* Special case: C16ThkSL stub */ if ( thunk ) { /* Set up registers as expected and call thunk */ output( "\tleal 0x1a(%%edx),%%ebx\n" ); /* sizeof(STACK16FRAME)-22 */ output( "\tleal -4(%%esp), %%ebp\n" ); output( "\tcall *0x26(%%edx)\n"); /* FIELD_OFFSET(STACK16FRAME,entry_point) */ /* Switch stack back */ output( "\t.byte 0x64\n\tmovw (%d), %%ss\n", STACKOFFSET+2 ); output( "\t.byte 0x64\n\tmovzwl (%d), %%esp\n", STACKOFFSET ); output( "\t.byte 0x64\n\tpopl (%d)\n", STACKOFFSET ); /* Restore registers and return directly to caller */ output( "\taddl $8, %%esp\n" ); output( "\tpopl %%ebp\n" ); output( "\tpopw %%ds\n" ); output( "\tpopw %%es\n" ); output( "\tpopw %%fs\n" ); output( "\tpopw %%gs\n" ); output( "\taddl $20, %%esp\n" ); output( "\txorb %%ch, %%ch\n" ); output( "\tpopl %%ebx\n" ); output( "\taddw %%cx, %%sp\n" ); output( "\tpush %%ebx\n" ); output( "\t.byte 0x66\n" ); output( "\tlret\n" ); output_function_size( "__wine_call_from_16_thunk" ); return; } /* Build register CONTEXT */ if ( reg_func ) { output( "\tsubl $0x2cc,%%esp\n" ); /* sizeof(CONTEXT86) */ output( "\tmovl %%ecx,0xc0(%%esp)\n" ); /* EFlags */ output( "\tmovl %%eax,0xb0(%%esp)\n" ); /* Eax */ output( "\tmovl %%ebx,0xa4(%%esp)\n" ); /* Ebx */ output( "\tmovl %%esi,0xa0(%%esp)\n" ); /* Esi */ output( "\tmovl %%edi,0x9c(%%esp)\n" ); /* Edi */ output( "\tmovl 0x0c(%%edx),%%eax\n"); /* FIELD_OFFSET(STACK16FRAME,ebp) */ output( "\tmovl %%eax,0xb4(%%esp)\n" ); /* Ebp */ output( "\tmovl 0x08(%%edx),%%eax\n"); /* FIELD_OFFSET(STACK16FRAME,ecx) */ output( "\tmovl %%eax,0xac(%%esp)\n" ); /* Ecx */ output( "\tmovl 0x04(%%edx),%%eax\n"); /* FIELD_OFFSET(STACK16FRAME,edx) */ output( "\tmovl %%eax,0xa8(%%esp)\n" ); /* Edx */ output( "\tmovzwl 0x10(%%edx),%%eax\n"); /* FIELD_OFFSET(STACK16FRAME,ds) */ output( "\tmovl %%eax,0x98(%%esp)\n" ); /* SegDs */ output( "\tmovzwl 0x12(%%edx),%%eax\n"); /* FIELD_OFFSET(STACK16FRAME,es) */ output( "\tmovl %%eax,0x94(%%esp)\n" ); /* SegEs */ output( "\tmovzwl 0x14(%%edx),%%eax\n"); /* FIELD_OFFSET(STACK16FRAME,fs) */ output( "\tmovl %%eax,0x90(%%esp)\n" ); /* SegFs */ output( "\tmovzwl 0x16(%%edx),%%eax\n"); /* FIELD_OFFSET(STACK16FRAME,gs) */ output( "\tmovl %%eax,0x8c(%%esp)\n" ); /* SegGs */ output( "\tmovzwl 0x2e(%%edx),%%eax\n"); /* FIELD_OFFSET(STACK16FRAME,cs) */ output( "\tmovl %%eax,0xbc(%%esp)\n" ); /* SegCs */ output( "\tmovzwl 0x2c(%%edx),%%eax\n"); /* FIELD_OFFSET(STACK16FRAME,ip) */ output( "\tmovl %%eax,0xb8(%%esp)\n" ); /* Eip */ output( "\t.byte 0x64\n\tmovzwl (%d), %%eax\n", STACKOFFSET+2 ); output( "\tmovl %%eax,0xc8(%%esp)\n" ); /* SegSs */ output( "\t.byte 0x64\n\tmovzwl (%d), %%eax\n", STACKOFFSET ); output( "\taddl $0x2c,%%eax\n"); /* FIELD_OFFSET(STACK16FRAME,ip) */ output( "\tmovl %%eax,0xc4(%%esp)\n" ); /* Esp */ #if 0 output( "\tfsave 0x1c(%%esp)\n" ); /* FloatSave */ #endif /* Push address of CONTEXT86 structure -- popped by the relay routine */ output( "\tmovl %%esp,%%eax\n" ); output( "\tandl $~15,%%esp\n" ); output( "\tsubl $4,%%esp\n" ); output( "\tpushl %%eax\n" ); } else { output( "\tsubl $8,%%esp\n" ); output( "\tandl $~15,%%esp\n" ); output( "\taddl $8,%%esp\n" ); } /* Call relay routine (which will call the API entry point) */ output( "\tleal 0x30(%%edx),%%eax\n" ); /* sizeof(STACK16FRAME) */ output( "\tpushl %%eax\n" ); output( "\tpushl 0x26(%%edx)\n"); /* FIELD_OFFSET(STACK16FRAME,entry_point) */ output( "\tcall *0x20(%%edx)\n"); /* FIELD_OFFSET(STACK16FRAME,relay) */ if ( reg_func ) { output( "\tleal -748(%%ebp),%%ebx\n" ); /* sizeof(CONTEXT) + FIELD_OFFSET(STACK32FRAME,ebp) */ /* Switch stack back */ output( "\t.byte 0x64\n\tmovw (%d), %%ss\n", STACKOFFSET+2 ); output( "\t.byte 0x64\n\tmovzwl (%d), %%esp\n", STACKOFFSET ); output( "\t.byte 0x64\n\tpopl (%d)\n", STACKOFFSET ); /* Get return address to CallFrom16 stub */ output( "\taddw $0x14,%%sp\n" ); /* FIELD_OFFSET(STACK16FRAME,callfrom_ip)-4 */ output( "\tpopl %%eax\n" ); output( "\tpopl %%edx\n" ); /* Restore all registers from CONTEXT */ output( "\tmovw 0xc8(%%ebx),%%ss\n"); /* SegSs */ output( "\tmovl 0xc4(%%ebx),%%esp\n"); /* Esp */ output( "\taddl $4, %%esp\n" ); /* room for final return address */ output( "\tpushw 0xbc(%%ebx)\n"); /* SegCs */ output( "\tpushw 0xb8(%%ebx)\n"); /* Eip */ output( "\tpushl %%edx\n" ); output( "\tpushl %%eax\n" ); output( "\tpushl 0xc0(%%ebx)\n"); /* EFlags */ output( "\tpushl 0x98(%%ebx)\n"); /* SegDs */ output( "\tpushl 0x94(%%ebx)\n"); /* SegEs */ output( "\tpopl %%es\n" ); output( "\tpushl 0x90(%%ebx)\n"); /* SegFs */ output( "\tpopl %%fs\n" ); output( "\tpushl 0x8c(%%ebx)\n"); /* SegGs */ output( "\tpopl %%gs\n" ); output( "\tmovl 0xb4(%%ebx),%%ebp\n"); /* Ebp */ output( "\tmovl 0xa0(%%ebx),%%esi\n"); /* Esi */ output( "\tmovl 0x9c(%%ebx),%%edi\n"); /* Edi */ output( "\tmovl 0xb0(%%ebx),%%eax\n"); /* Eax */ output( "\tmovl 0xa8(%%ebx),%%edx\n"); /* Edx */ output( "\tmovl 0xac(%%ebx),%%ecx\n"); /* Ecx */ output( "\tmovl 0xa4(%%ebx),%%ebx\n"); /* Ebx */ output( "\tpopl %%ds\n" ); output( "\tpopfl\n" ); output( "\tlret\n" ); output_function_size( "__wine_call_from_16_regs" ); } else { /* Switch stack back */ output( "\t.byte 0x64\n\tmovw (%d), %%ss\n", STACKOFFSET+2 ); output( "\t.byte 0x64\n\tmovzwl (%d), %%esp\n", STACKOFFSET ); output( "\t.byte 0x64\n\tpopl (%d)\n", STACKOFFSET ); /* Restore registers */ output( "\tpopl %%edx\n" ); output( "\tpopl %%ecx\n" ); output( "\tpopl %%ebp\n" ); output( "\tpopw %%ds\n" ); output( "\tpopw %%es\n" ); output( "\tpopw %%fs\n" ); output( "\tpopw %%gs\n" ); /* Return to return stub which will return to caller */ output( "\tlret $12\n" ); output_function_size( "__wine_call_from_16" ); } }
/******************************************************************* * output_relay_debug * * Output entry points for relay debugging */ static void output_relay_debug( DLLSPEC *spec ) { int i, j; unsigned int pos, args, flags; /* first the table of entry point offsets */ output( "\t%s\n", get_asm_rodata_section() ); output( "\t.align %d\n", get_alignment(4) ); output( ".L__wine_spec_relay_entry_point_offsets:\n" ); for (i = spec->base; i <= spec->limit; i++) { ORDDEF *odp = spec->ordinals[i]; if (needs_relay( odp )) output( "\t.long .L__wine_spec_relay_entry_point_%d-__wine_spec_relay_entry_points\n", i ); else output( "\t.long 0\n" ); } /* then the table of argument types */ output( "\t.align %d\n", get_alignment(4) ); output( ".L__wine_spec_relay_arg_types:\n" ); for (i = spec->base; i <= spec->limit; i++) { ORDDEF *odp = spec->ordinals[i]; unsigned int mask = 0; if (needs_relay( odp )) { for (j = pos = 0; pos < 16 && j < odp->u.func.nb_args; j++) { switch (odp->u.func.args[j]) { case ARG_STR: mask |= 1 << (2 * pos++); break; case ARG_WSTR: mask |= 2 << (2 * pos++); break; case ARG_INT64: case ARG_DOUBLE: pos += 8 / get_ptr_size(); break; case ARG_INT128: pos += (target_cpu == CPU_x86) ? 4 : 1; break; default: pos++; break; } } } output( "\t.long 0x%08x\n", mask ); } /* then the relay thunks */ output( "\t.text\n" ); output( "__wine_spec_relay_entry_points:\n" ); output( "\tnop\n" ); /* to avoid 0 offset */ for (i = spec->base; i <= spec->limit; i++) { ORDDEF *odp = spec->ordinals[i]; if (!needs_relay( odp )) continue; output( "\t.align %d\n", get_alignment(4) ); output( ".L__wine_spec_relay_entry_point_%d:\n", i ); output_cfi( ".cfi_startproc" ); args = get_args_size(odp) / get_ptr_size(); flags = 0; switch (target_cpu) { case CPU_x86: if (odp->type == TYPE_THISCALL) /* add the this pointer */ { output( "\tpopl %%eax\n" ); output( "\tpushl %%ecx\n" ); output( "\tpushl %%eax\n" ); flags |= 2; } if (odp->flags & FLAG_REGISTER) output( "\tpushl %%eax\n" ); else output( "\tpushl %%esp\n" ); output_cfi( ".cfi_adjust_cfa_offset 4" ); if (odp->flags & FLAG_RET64) flags |= 1; output( "\tpushl $%u\n", (flags << 24) | (args << 16) | (i - spec->base) ); output_cfi( ".cfi_adjust_cfa_offset 4" ); if (UsePIC) { output( "\tcall %s\n", asm_name("__wine_spec_get_pc_thunk_eax") ); output( "1:\tleal .L__wine_spec_relay_descr-1b(%%eax),%%eax\n" ); } else output( "\tmovl $.L__wine_spec_relay_descr,%%eax\n" ); output( "\tpushl %%eax\n" ); output_cfi( ".cfi_adjust_cfa_offset 4" ); if (odp->flags & FLAG_REGISTER) { output( "\tcall *8(%%eax)\n" ); } else { output( "\tcall *4(%%eax)\n" ); output_cfi( ".cfi_adjust_cfa_offset -12" ); if (odp->type == TYPE_STDCALL || odp->type == TYPE_THISCALL) output( "\tret $%u\n", args * get_ptr_size() ); else output( "\tret\n" ); } break; case CPU_x86_64: output( "\tsubq $40,%%rsp\n" ); output_cfi( ".cfi_adjust_cfa_offset 40" ); switch (args) { default: output( "\tmovq %%%s,72(%%rsp)\n", is_float_arg( odp, 3 ) ? "xmm3" : "r9" ); /* fall through */ case 3: output( "\tmovq %%%s,64(%%rsp)\n", is_float_arg( odp, 2 ) ? "xmm2" : "r8" ); /* fall through */ case 2: output( "\tmovq %%%s,56(%%rsp)\n", is_float_arg( odp, 1 ) ? "xmm1" : "rdx" ); /* fall through */ case 1: output( "\tmovq %%%s,48(%%rsp)\n", is_float_arg( odp, 0 ) ? "xmm0" : "rcx" ); /* fall through */ case 0: break; } output( "\tleaq 40(%%rsp),%%r8\n" ); output( "\tmovq $%u,%%rdx\n", (flags << 24) | (args << 16) | (i - spec->base) ); output( "\tleaq .L__wine_spec_relay_descr(%%rip),%%rcx\n" ); output( "\tcallq *8(%%rcx)\n" ); output( "\taddq $40,%%rsp\n" ); output_cfi( ".cfi_adjust_cfa_offset -40" ); output( "\tret\n" ); break; default: assert(0); } output_cfi( ".cfi_endproc" ); } }
/* output a single import thunk */ static void output_import_thunk( const char *name, const char *table, int pos ) { output( "\n\t.align %d\n", get_alignment(4) ); output( "\t%s\n", func_declaration(name) ); output( "%s\n", asm_globl(name) ); output_cfi( ".cfi_startproc" ); switch(target_cpu) { case CPU_x86: if (!UsePIC) { output( "\tjmp *(%s+%d)\n", table, pos ); } else { output( "\tcall %s\n", asm_name("__wine_spec_get_pc_thunk_eax") ); output( "1:\tjmp *%s+%d-1b(%%eax)\n", table, pos ); } break; case CPU_x86_64: output( "\tjmpq *%s+%d(%%rip)\n", table, pos ); break; case CPU_SPARC: if ( !UsePIC ) { output( "\tsethi %%hi(%s+%d), %%g1\n", table, pos ); output( "\tld [%%g1+%%lo(%s+%d)], %%g1\n", table, pos ); output( "\tjmp %%g1\n" ); output( "\tnop\n" ); } else { /* Hmpf. Stupid sparc assembler always interprets global variable names as GOT offsets, so we have to do it the long way ... */ output( "\tsave %%sp, -96, %%sp\n" ); output( "0:\tcall 1f\n" ); output( "\tnop\n" ); output( "1:\tsethi %%hi(%s+%d-0b), %%g1\n", table, pos ); output( "\tor %%g1, %%lo(%s+%d-0b), %%g1\n", table, pos ); output( "\tld [%%g1+%%o7], %%g1\n" ); output( "\tjmp %%g1\n" ); output( "\trestore\n" ); } break; case CPU_ARM: output( "\tldr IP,[PC,#0]\n"); output( "\tldr PC,[IP,#%d]\n", pos); output( "\t.long %s\n", table ); break; case CPU_ARM64: output( "\tadr x9, 1f\n" ); output( "\tldur x9, [x9, #0]\n" ); if (pos & 0xf000) output( "\tadd x9, x9, #%u\n", pos & 0xf000 ); if (pos & 0x0f00) output( "\tadd x9, x9, #%u\n", pos & 0x0f00 ); if (pos & 0x00f0) output( "\tadd x9, x9, #%u\n", pos & 0x00f0 ); if (pos & 0x000f) output( "\tadd x9, x9, #%u\n", pos & 0x000f ); output( "\tldur x9, [x9, #0]\n" ); output( "\tbr x9\n" ); output( "1:\t.quad %s\n", table ); break; case CPU_POWERPC: output( "\tmr %s, %s\n", ppc_reg(0), ppc_reg(31) ); if (target_platform == PLATFORM_APPLE) { output( "\tlis %s, ha16(%s+%d+32768)\n", ppc_reg(31), table, pos ); output( "\tla %s, lo16(%s+%d)(%s)\n", ppc_reg(31), table, pos, ppc_reg(31) ); } else { output( "\tlis %s, (%s+%d+32768)@h\n", ppc_reg(31), table, pos ); output( "\tla %s, (%s+%d)@l(%s)\n", ppc_reg(31), table, pos, ppc_reg(31) ); } output( "\tlwz %s, 0(%s)\n", ppc_reg(31), ppc_reg(31) ); output( "\tmtctr %s\n", ppc_reg(31) ); output( "\tmr %s, %s\n", ppc_reg(31), ppc_reg(0) ); output( "\tbctr\n" ); break; } output_cfi( ".cfi_endproc" ); output_function_size( name ); }
/******************************************************************* * output_relay_debug * * Output entry points for relay debugging */ static void output_relay_debug( DLLSPEC *spec ) { int i; unsigned int j, args, flags; /* first the table of entry point offsets */ output( "\t%s\n", get_asm_rodata_section() ); output( "\t.align %d\n", get_alignment(4) ); output( ".L__wine_spec_relay_entry_point_offsets:\n" ); for (i = spec->base; i <= spec->limit; i++) { ORDDEF *odp = spec->ordinals[i]; if (needs_relay( odp )) output( "\t.long .L__wine_spec_relay_entry_point_%d-__wine_spec_relay_entry_points\n", i ); else output( "\t.long 0\n" ); } /* then the table of argument types */ output( "\t.align %d\n", get_alignment(4) ); output( ".L__wine_spec_relay_arg_types:\n" ); for (i = spec->base; i <= spec->limit; i++) { ORDDEF *odp = spec->ordinals[i]; unsigned int mask = 0; if (needs_relay( odp )) { for (j = 0; j < 16 && odp->u.func.arg_types[j]; j++) { if (odp->u.func.arg_types[j] == 't') mask |= 1<< (j*2); if (odp->u.func.arg_types[j] == 'W') mask |= 2<< (j*2); } } output( "\t.long 0x%08x\n", mask ); } /* then the relay thunks */ output( "\t.text\n" ); output( "__wine_spec_relay_entry_points:\n" ); output( "\tnop\n" ); /* to avoid 0 offset */ for (i = spec->base; i <= spec->limit; i++) { ORDDEF *odp = spec->ordinals[i]; if (!needs_relay( odp )) continue; output( "\t.align %d\n", get_alignment(4) ); output( ".L__wine_spec_relay_entry_point_%d:\n", i ); args = strlen(odp->u.func.arg_types); flags = 0; switch (target_cpu) { case CPU_x86: if (odp->flags & FLAG_REGISTER) output( "\tpushl %%eax\n" ); else output( "\tpushl %%esp\n" ); if (odp->flags & FLAG_RET64) flags |= 1; output( "\tpushl $%u\n", (flags << 24) | (args << 16) | (i - spec->base) ); if (UsePIC) { output( "\tcall %s\n", asm_name("__wine_spec_get_pc_thunk_eax") ); output( "1:\tleal .L__wine_spec_relay_descr-1b(%%eax),%%eax\n" ); } else output( "\tmovl $.L__wine_spec_relay_descr,%%eax\n" ); output( "\tpushl %%eax\n" ); if (odp->flags & FLAG_REGISTER) { output( "\tcall *8(%%eax)\n" ); } else { output( "\tcall *4(%%eax)\n" ); if (odp->type == TYPE_STDCALL) output( "\tret $%u\n", args * get_ptr_size() ); else output( "\tret\n" ); } break; case CPU_x86_64: output( "\tmovq %%rcx,8(%%rsp)\n" ); output( "\tmovq %%rdx,16(%%rsp)\n" ); output( "\tmovq %%r8,24(%%rsp)\n" ); output( "\tmovq %%r9,32(%%rsp)\n" ); output( "\tmovq %%rsp,%%r8\n" ); output( "\tmovq $%u,%%rdx\n", (flags << 24) | (args << 16) | (i - spec->base) ); output( "\tleaq .L__wine_spec_relay_descr(%%rip),%%rcx\n" ); output( "\tsubq $40,%%rsp\n" ); output( "\tcallq *%u(%%rcx)\n", (odp->flags & FLAG_REGISTER) ? 16 : 8 ); output( "\taddq $40,%%rsp\n" ); output( "\tret\n" ); break; default: assert(0); } } }
/* output the delayed import thunks of a Win32 module */ static void output_delayed_import_thunks( const DLLSPEC *spec ) { int i, idx, j, pos, extra_stack_storage = 0; static const char delayed_import_loaders[] = "__wine_spec_delayed_import_loaders"; static const char delayed_import_thunks[] = "__wine_spec_delayed_import_thunks"; if (!nb_delayed) return; output( "\n/* delayed import thunks */\n\n" ); output( "\t.text\n" ); output( "\t.align %d\n", get_alignment(8) ); output( "%s:\n", asm_name(delayed_import_loaders)); output( "\t%s\n", func_declaration("__wine_delay_load_asm") ); output( "%s:\n", asm_name("__wine_delay_load_asm") ); output_cfi( ".cfi_startproc" ); switch(target_cpu) { case CPU_x86: output( "\tpushl %%ecx\n" ); output_cfi( ".cfi_adjust_cfa_offset 4" ); output( "\tpushl %%edx\n" ); output_cfi( ".cfi_adjust_cfa_offset 4" ); output( "\tpushl %%eax\n" ); output_cfi( ".cfi_adjust_cfa_offset 4" ); output( "\tcall %s\n", asm_name("__wine_spec_delay_load") ); output_cfi( ".cfi_adjust_cfa_offset -4" ); output( "\tpopl %%edx\n" ); output_cfi( ".cfi_adjust_cfa_offset -4" ); output( "\tpopl %%ecx\n" ); output_cfi( ".cfi_adjust_cfa_offset -4" ); output( "\tjmp *%%eax\n" ); break; case CPU_x86_64: output( "\tsubq $88,%%rsp\n" ); output_cfi( ".cfi_adjust_cfa_offset 88" ); output( "\tmovq %%rdx,80(%%rsp)\n" ); output( "\tmovq %%rcx,72(%%rsp)\n" ); output( "\tmovq %%r8,64(%%rsp)\n" ); output( "\tmovq %%r9,56(%%rsp)\n" ); output( "\tmovq %%r10,48(%%rsp)\n" ); output( "\tmovq %%r11,40(%%rsp)\n" ); output( "\tmovq %%rax,%%rcx\n" ); output( "\tcall %s\n", asm_name("__wine_spec_delay_load") ); output( "\tmovq 40(%%rsp),%%r11\n" ); output( "\tmovq 48(%%rsp),%%r10\n" ); output( "\tmovq 56(%%rsp),%%r9\n" ); output( "\tmovq 64(%%rsp),%%r8\n" ); output( "\tmovq 72(%%rsp),%%rcx\n" ); output( "\tmovq 80(%%rsp),%%rdx\n" ); output( "\taddq $88,%%rsp\n" ); output_cfi( ".cfi_adjust_cfa_offset -88" ); output( "\tjmp *%%rax\n" ); break; case CPU_SPARC: output( "\tsave %%sp, -96, %%sp\n" ); output( "\tcall %s\n", asm_name("__wine_spec_delay_load") ); output( "\tmov %%g1, %%o0\n" ); output( "\tjmp %%o0\n" ); output( "\trestore\n" ); break; case CPU_ARM: output( "\tstmfd SP!, {r4-r10,FP,LR}\n" ); output( "\tmov LR,PC\n"); output( "\tadd LR,LR,#8\n"); output( "\tldr PC,[PC,#-4]\n"); output( "\t.long %s\n", asm_name("__wine_spec_delay_load") ); output( "\tmov IP,r0\n"); output( "\tldmfd SP!, {r4-r10,FP,LR}\n" ); output( "\tldmfd SP!, {r0-r3}\n" ); output( "\tmov PC,IP\n"); break; case CPU_ARM64: output( "\tstp x29, x30, [sp,#-16]!\n" ); output( "\tmov x29, sp\n" ); output( "\tadr x9, 1f\n" ); output( "\tldur x9, [x9, #0]\n" ); output( "\tblr x9\n" ); output( "\tmov x9, x0\n" ); output( "\tldp x29, x30, [sp],#16\n" ); output( "\tldp x0, x1, [sp,#16]\n" ); output( "\tldp x2, x3, [sp,#32]\n" ); output( "\tldp x4, x5, [sp,#48]\n" ); output( "\tldp x6, x7, [sp],#80\n" ); output( "\tbr x9\n" ); /* or "ret x9" */ output( "1:\t.quad %s\n", asm_name("__wine_spec_delay_load") ); break; case CPU_POWERPC: if (target_platform == PLATFORM_APPLE) extra_stack_storage = 56; /* Save all callee saved registers into a stackframe. */ output( "\tstwu %s, -%d(%s)\n",ppc_reg(1), 48+extra_stack_storage, ppc_reg(1)); output( "\tstw %s, %d(%s)\n", ppc_reg(3), 4+extra_stack_storage, ppc_reg(1)); output( "\tstw %s, %d(%s)\n", ppc_reg(4), 8+extra_stack_storage, ppc_reg(1)); output( "\tstw %s, %d(%s)\n", ppc_reg(5), 12+extra_stack_storage, ppc_reg(1)); output( "\tstw %s, %d(%s)\n", ppc_reg(6), 16+extra_stack_storage, ppc_reg(1)); output( "\tstw %s, %d(%s)\n", ppc_reg(7), 20+extra_stack_storage, ppc_reg(1)); output( "\tstw %s, %d(%s)\n", ppc_reg(8), 24+extra_stack_storage, ppc_reg(1)); output( "\tstw %s, %d(%s)\n", ppc_reg(9), 28+extra_stack_storage, ppc_reg(1)); output( "\tstw %s, %d(%s)\n", ppc_reg(10),32+extra_stack_storage, ppc_reg(1)); output( "\tstw %s, %d(%s)\n", ppc_reg(11),36+extra_stack_storage, ppc_reg(1)); output( "\tstw %s, %d(%s)\n", ppc_reg(12),40+extra_stack_storage, ppc_reg(1)); /* r0 -> r3 (arg1) */ output( "\tmr %s, %s\n", ppc_reg(3), ppc_reg(0)); /* save return address */ output( "\tmflr %s\n", ppc_reg(0)); output( "\tstw %s, %d(%s)\n", ppc_reg(0), 44+extra_stack_storage, ppc_reg(1)); /* Call the __wine_delay_load function, arg1 is arg1. */ output( "\tbl %s\n", asm_name("__wine_spec_delay_load") ); /* Load return value from call into ctr register */ output( "\tmtctr %s\n", ppc_reg(3)); /* restore all saved registers and drop stackframe. */ output( "\tlwz %s, %d(%s)\n", ppc_reg(3), 4+extra_stack_storage, ppc_reg(1)); output( "\tlwz %s, %d(%s)\n", ppc_reg(4), 8+extra_stack_storage, ppc_reg(1)); output( "\tlwz %s, %d(%s)\n", ppc_reg(5), 12+extra_stack_storage, ppc_reg(1)); output( "\tlwz %s, %d(%s)\n", ppc_reg(6), 16+extra_stack_storage, ppc_reg(1)); output( "\tlwz %s, %d(%s)\n", ppc_reg(7), 20+extra_stack_storage, ppc_reg(1)); output( "\tlwz %s, %d(%s)\n", ppc_reg(8), 24+extra_stack_storage, ppc_reg(1)); output( "\tlwz %s, %d(%s)\n", ppc_reg(9), 28+extra_stack_storage, ppc_reg(1)); output( "\tlwz %s, %d(%s)\n", ppc_reg(10),32+extra_stack_storage, ppc_reg(1)); output( "\tlwz %s, %d(%s)\n", ppc_reg(11),36+extra_stack_storage, ppc_reg(1)); output( "\tlwz %s, %d(%s)\n", ppc_reg(12),40+extra_stack_storage, ppc_reg(1)); /* Load return value from call into return register */ output( "\tlwz %s, %d(%s)\n", ppc_reg(0), 44+extra_stack_storage, ppc_reg(1)); output( "\tmtlr %s\n", ppc_reg(0)); output( "\taddi %s, %s, %d\n", ppc_reg(1), ppc_reg(1), 48+extra_stack_storage); /* branch to ctr register. */ output( "\tbctr\n"); break; } output_cfi( ".cfi_endproc" ); output_function_size( "__wine_delay_load_asm" ); output( "\n" ); for (i = idx = 0; i < nb_imports; i++) { if (!dll_imports[i]->delay) continue; for (j = 0; j < dll_imports[i]->nb_imports; j++) { ORDDEF *odp = dll_imports[i]->imports[j]; const char *name = odp->name ? odp->name : odp->export_name; output( ".L__wine_delay_imp_%d_%s:\n", i, name ); output_cfi( ".cfi_startproc" ); switch(target_cpu) { case CPU_x86: output( "\tmovl $%d, %%eax\n", (idx << 16) | j ); output( "\tjmp %s\n", asm_name("__wine_delay_load_asm") ); break; case CPU_x86_64: output( "\tmovq $%d,%%rax\n", (idx << 16) | j ); output( "\tjmp %s\n", asm_name("__wine_delay_load_asm") ); break; case CPU_SPARC: output( "\tset %d, %%g1\n", (idx << 16) | j ); output( "\tb,a %s\n", asm_name("__wine_delay_load_asm") ); output( "\tnop\n" ); break; case CPU_ARM: output( "\tstmfd SP!, {r0-r3}\n" ); output( "\tmov r0, #%d\n", idx ); output( "\tmov r1, #16384\n" ); output( "\tmul r1, r0, r1\n" ); output( "\tmov r0, r1\n" ); output( "\tmov r1, #4\n" ); output( "\tmul r1, r0, r1\n" ); output( "\tmov r0, r1\n" ); output( "\tadd r0, #%d\n", j ); output( "\tldr PC,[PC,#-4]\n"); output( "\t.long %s\n", asm_name("__wine_delay_load_asm") ); break; case CPU_ARM64: output( "\tstp x6, x7, [sp,#-80]!\n" ); output( "\tstp x4, x5, [sp,#48]\n" ); output( "\tstp x2, x3, [sp,#32]\n" ); output( "\tstp x0, x1, [sp,#16]\n" ); output( "\tmov x0, #%d\n", idx ); output( "\tmov x1, #16384\n" ); output( "\tmul x1, x0, x1\n" ); output( "\tmov x0, x1\n" ); output( "\tmov x1, #4\n" ); output( "\tmul x1, x0, x1\n" ); output( "\tmov x0, x1\n" ); output( "\tadd x0, x0, #%d\n", j ); output( "\tadr x9, 1f\n" ); output( "\tldur x9, [x9, #0]\n" ); output( "\tbr x9\n" ); output( "1:\t.quad %s\n", asm_name("__wine_delay_load_asm") ); break; case CPU_POWERPC: switch(target_platform) { case PLATFORM_APPLE: /* On Darwin we can use r0 and r2 */ /* Upper part in r2 */ output( "\tlis %s, %d\n", ppc_reg(2), idx); /* Lower part + r2 -> r0, Note we can't use r0 directly */ output( "\taddi %s, %s, %d\n", ppc_reg(0), ppc_reg(2), j); output( "\tb %s\n", asm_name("__wine_delay_load_asm") ); break; default: /* On linux we can't use r2 since r2 is not a scratch register (hold the TOC) */ /* Save r13 on the stack */ output( "\taddi %s, %s, -0x4\n", ppc_reg(1), ppc_reg(1)); output( "\tstw %s, 0(%s)\n", ppc_reg(13), ppc_reg(1)); /* Upper part in r13 */ output( "\tlis %s, %d\n", ppc_reg(13), idx); /* Lower part + r13 -> r0, Note we can't use r0 directly */ output( "\taddi %s, %s, %d\n", ppc_reg(0), ppc_reg(13), j); /* Restore r13 */ output( "\tstw %s, 0(%s)\n", ppc_reg(13), ppc_reg(1)); output( "\taddic %s, %s, 0x4\n", ppc_reg(1), ppc_reg(1)); output( "\tb %s\n", asm_name("__wine_delay_load_asm") ); break; } break; } output_cfi( ".cfi_endproc" ); } idx++; } output_function_size( delayed_import_loaders ); output( "\n\t.align %d\n", get_alignment(get_ptr_size()) ); output( "%s:\n", asm_name(delayed_import_thunks)); for (i = pos = 0; i < nb_imports; i++) { if (!dll_imports[i]->delay) continue; for (j = 0; j < dll_imports[i]->nb_imports; j++, pos += get_ptr_size()) { ORDDEF *odp = dll_imports[i]->imports[j]; output_import_thunk( odp->name ? odp->name : odp->export_name, ".L__wine_delay_IAT", pos ); } } output_function_size( delayed_import_thunks ); }
/******************************************************************* * output_module * * Output the module data. */ void output_module( DLLSPEC *spec ) { int machine = 0; unsigned int page_size = get_page_size(); /* Reserve some space for the PE header */ switch (target_platform) { case PLATFORM_APPLE: output( "\t.text\n" ); output( "\t.align %d\n", get_alignment(page_size) ); output( "__wine_spec_pe_header:\n" ); output( "\t.space 65536\n" ); break; case PLATFORM_SOLARIS: output( "\n\t.section \".text\",\"ax\"\n" ); output( "__wine_spec_pe_header:\n" ); output( "\t.skip %u\n", 65536 + page_size ); break; default: output( "\n\t.section \".init\",\"ax\"\n" ); switch(target_cpu) { case CPU_x86: case CPU_x86_64: case CPU_SPARC: output( "\tjmp 1f\n" ); break; case CPU_ARM: case CPU_POWERPC: output( "\tb 1f\n" ); break; } output( "__wine_spec_pe_header:\n" ); output( "\t.skip %u\n", 65536 + page_size ); output( "1:\n" ); break; } /* Output the NT header */ output( "\n\t.data\n" ); output( "\t.align %d\n", get_alignment(get_ptr_size()) ); output( "%s\n", asm_globl("__wine_spec_nt_header") ); output( ".L__wine_spec_rva_base:\n" ); output( "\t.long 0x4550\n" ); /* Signature */ switch(target_cpu) { case CPU_x86: machine = IMAGE_FILE_MACHINE_I386; break; case CPU_x86_64: machine = IMAGE_FILE_MACHINE_AMD64; break; case CPU_ARM: machine = IMAGE_FILE_MACHINE_ARMV7; break; case CPU_POWERPC: machine = IMAGE_FILE_MACHINE_POWERPC; break; case CPU_SPARC: machine = IMAGE_FILE_MACHINE_SPARC; break; } output( "\t%s 0x%04x\n", /* Machine */ get_asm_short_keyword(), machine ); output( "\t%s 0\n", /* NumberOfSections */ get_asm_short_keyword() ); output( "\t.long 0\n" ); /* TimeDateStamp */ output( "\t.long 0\n" ); /* PointerToSymbolTable */ output( "\t.long 0\n" ); /* NumberOfSymbols */ output( "\t%s %d\n", /* SizeOfOptionalHeader */ get_asm_short_keyword(), get_ptr_size() == 8 ? IMAGE_SIZEOF_NT_OPTIONAL64_HEADER : IMAGE_SIZEOF_NT_OPTIONAL32_HEADER ); output( "\t%s 0x%04x\n", /* Characteristics */ get_asm_short_keyword(), spec->characteristics ); output( "\t%s 0x%04x\n", /* Magic */ get_asm_short_keyword(), get_ptr_size() == 8 ? IMAGE_NT_OPTIONAL_HDR64_MAGIC : IMAGE_NT_OPTIONAL_HDR32_MAGIC ); output( "\t.byte 0\n" ); /* MajorLinkerVersion */ output( "\t.byte 0\n" ); /* MinorLinkerVersion */ output( "\t.long 0\n" ); /* SizeOfCode */ output( "\t.long 0\n" ); /* SizeOfInitializedData */ output( "\t.long 0\n" ); /* SizeOfUninitializedData */ /* note: we expand the AddressOfEntryPoint field on 64-bit by overwriting the BaseOfCode field */ output( "\t%s %s\n", /* AddressOfEntryPoint */ get_asm_ptr_keyword(), spec->init_func ? asm_name(spec->init_func) : "0" ); if (get_ptr_size() == 4) { output( "\t.long 0\n" ); /* BaseOfCode */ output( "\t.long 0\n" ); /* BaseOfData */ } output( "\t%s __wine_spec_pe_header\n", /* ImageBase */ get_asm_ptr_keyword() ); output( "\t.long %u\n", page_size ); /* SectionAlignment */ output( "\t.long %u\n", page_size ); /* FileAlignment */ output( "\t%s 1,0\n", /* Major/MinorOperatingSystemVersion */ get_asm_short_keyword() ); output( "\t%s 0,0\n", /* Major/MinorImageVersion */ get_asm_short_keyword() ); output( "\t%s %u,%u\n", /* Major/MinorSubsystemVersion */ get_asm_short_keyword(), spec->subsystem_major, spec->subsystem_minor ); output( "\t.long 0\n" ); /* Win32VersionValue */ output( "\t.long %s-.L__wine_spec_rva_base\n", /* SizeOfImage */ asm_name("_end") ); output( "\t.long %u\n", page_size ); /* SizeOfHeaders */ output( "\t.long 0\n" ); /* CheckSum */ output( "\t%s 0x%04x\n", /* Subsystem */ get_asm_short_keyword(), spec->subsystem ); output( "\t%s 0x%04x\n", /* DllCharacteristics */ get_asm_short_keyword(), spec->dll_characteristics ); output( "\t%s %u,%u\n", /* SizeOfStackReserve/Commit */ get_asm_ptr_keyword(), (spec->stack_size ? spec->stack_size : 1024) * 1024, page_size ); output( "\t%s %u,%u\n", /* SizeOfHeapReserve/Commit */ get_asm_ptr_keyword(), (spec->heap_size ? spec->heap_size : 1024) * 1024, page_size ); output( "\t.long 0\n" ); /* LoaderFlags */ output( "\t.long 16\n" ); /* NumberOfRvaAndSizes */ if (spec->base <= spec->limit) /* DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT] */ output( "\t.long .L__wine_spec_exports-.L__wine_spec_rva_base," ".L__wine_spec_exports_end-.L__wine_spec_exports\n" ); else output( "\t.long 0,0\n" ); if (has_imports()) /* DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT] */ output( "\t.long .L__wine_spec_imports-.L__wine_spec_rva_base," ".L__wine_spec_imports_end-.L__wine_spec_imports\n" ); else output( "\t.long 0,0\n" ); if (spec->nb_resources) /* DataDirectory[IMAGE_DIRECTORY_ENTRY_RESOURCE] */ output( "\t.long .L__wine_spec_resources-.L__wine_spec_rva_base," ".L__wine_spec_resources_end-.L__wine_spec_resources\n" ); else output( "\t.long 0,0\n" ); output( "\t.long 0,0\n" ); /* DataDirectory[3] */ output( "\t.long 0,0\n" ); /* DataDirectory[4] */ output( "\t.long 0,0\n" ); /* DataDirectory[5] */ output( "\t.long 0,0\n" ); /* DataDirectory[6] */ output( "\t.long 0,0\n" ); /* DataDirectory[7] */ output( "\t.long 0,0\n" ); /* DataDirectory[8] */ output( "\t.long 0,0\n" ); /* DataDirectory[9] */ output( "\t.long 0,0\n" ); /* DataDirectory[10] */ output( "\t.long 0,0\n" ); /* DataDirectory[11] */ output( "\t.long 0,0\n" ); /* DataDirectory[12] */ output( "\t.long 0,0\n" ); /* DataDirectory[13] */ output( "\t.long 0,0\n" ); /* DataDirectory[14] */ output( "\t.long 0,0\n" ); /* DataDirectory[15] */ output( "\n\t%s\n", get_asm_string_section() ); output( "%s\n", asm_globl("__wine_spec_file_name") ); output( ".L__wine_spec_file_name:\n" ); output( "\t%s \"%s\"\n", get_asm_string_keyword(), spec->file_name ); if (target_platform == PLATFORM_APPLE) output( "\t.lcomm %s,4\n", asm_name("_end") ); output_asm_constructor( "__wine_spec_init_ctor" ); }