/* 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 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" ); }
/* 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 the delayed import table of a Win32 module */ static int output_delayed_imports( FILE *outfile ) { int i, idx, j, pos; if (!nb_delayed) goto done; for (i = 0; i < nb_imports; i++) { if (!dll_imports[i]->delay) continue; fprintf( outfile, "static void *__wine_delay_imp_%d_hmod;\n", i); for (j = 0; j < dll_imports[i]->nb_imports; j++) { fprintf( outfile, "void __wine_delay_imp_%d_%s();\n", i, dll_imports[i]->imports[j] ); } } fprintf( outfile, "\n" ); fprintf( outfile, "static struct {\n" ); fprintf( outfile, " struct ImgDelayDescr {\n" ); fprintf( outfile, " unsigned int grAttrs;\n" ); fprintf( outfile, " const char *szName;\n" ); fprintf( outfile, " void **phmod;\n" ); fprintf( outfile, " void **pIAT;\n" ); fprintf( outfile, " const char **pINT;\n" ); fprintf( outfile, " void* pBoundIAT;\n" ); fprintf( outfile, " void* pUnloadIAT;\n" ); fprintf( outfile, " unsigned long dwTimeStamp;\n" ); fprintf( outfile, " } imp[%d];\n", nb_delayed ); fprintf( outfile, " void *IAT[%d];\n", total_delayed ); fprintf( outfile, " const char *INT[%d];\n", total_delayed ); fprintf( outfile, "} delay_imports = {\n" ); fprintf( outfile, " {\n" ); for (i = j = 0; i < nb_imports; i++) { if (!dll_imports[i]->delay) continue; fprintf( outfile, " { 0, \"%s\", &__wine_delay_imp_%d_hmod, &delay_imports.IAT[%d], &delay_imports.INT[%d], 0, 0, 0 },\n", dll_imports[i]->dll, i, j, j ); j += dll_imports[i]->nb_imports; } fprintf( outfile, " },\n {\n" ); for (i = 0; i < nb_imports; i++) { if (!dll_imports[i]->delay) continue; fprintf( outfile, " /* %s */\n", dll_imports[i]->dll ); for (j = 0; j < dll_imports[i]->nb_imports; j++) { fprintf( outfile, " &__wine_delay_imp_%d_%s,\n", i, dll_imports[i]->imports[j] ); } } fprintf( outfile, " },\n {\n" ); for (i = 0; i < nb_imports; i++) { if (!dll_imports[i]->delay) continue; fprintf( outfile, " /* %s */\n", dll_imports[i]->dll ); for (j = 0; j < dll_imports[i]->nb_imports; j++) { fprintf( outfile, " \"\\0\\0%s\",\n", dll_imports[i]->imports[j] ); } } fprintf( outfile, " }\n};\n\n" ); /* check if there's some stub defined. if so, exception struct * is already defined, so don't emit it twice */ for (i = 0; i < nb_entry_points; i++) if (EntryPoints[i]->type == TYPE_STUB) break; if (i == nb_entry_points) { fprintf( outfile, "struct exc_record {\n" ); fprintf( outfile, " unsigned int code, flags;\n" ); fprintf( outfile, " void *rec, *addr;\n" ); fprintf( outfile, " unsigned int params;\n" ); fprintf( outfile, " const void *info[15];\n" ); fprintf( outfile, "};\n\n" ); fprintf( outfile, "extern void __stdcall RtlRaiseException( struct exc_record * );\n" ); } fprintf( outfile, "extern void * __stdcall LoadLibraryA(const char*);\n"); fprintf( outfile, "extern void * __stdcall GetProcAddress(void *, const char*);\n"); fprintf( outfile, "\n" ); fprintf( outfile, "void *__stdcall __wine_delay_load( int idx_nr )\n" ); fprintf( outfile, "{\n" ); fprintf( outfile, " int idx = idx_nr >> 16, nr = idx_nr & 0xffff;\n" ); fprintf( outfile, " struct ImgDelayDescr *imd = delay_imports.imp + idx;\n" ); fprintf( outfile, " void **pIAT = imd->pIAT + nr;\n" ); fprintf( outfile, " const char** pINT = imd->pINT + nr;\n" ); fprintf( outfile, " void *fn;\n\n" ); fprintf( outfile, " if (!*imd->phmod) *imd->phmod = LoadLibraryA(imd->szName);\n" ); fprintf( outfile, " if (*imd->phmod && (fn = GetProcAddress(*imd->phmod, *pINT + 2)))\n"); fprintf( outfile, " /* patch IAT with final value */\n" ); fprintf( outfile, " return *pIAT = fn;\n" ); fprintf( outfile, " else {\n"); fprintf( outfile, " struct exc_record rec;\n" ); fprintf( outfile, " rec.code = 0x80000100;\n" ); fprintf( outfile, " rec.flags = 1;\n" ); fprintf( outfile, " rec.rec = 0;\n" ); fprintf( outfile, " rec.params = 2;\n" ); fprintf( outfile, " rec.info[0] = imd->szName;\n" ); fprintf( outfile, " rec.info[1] = *pINT + 2;\n" ); fprintf( outfile, "#ifdef __GNUC__\n" ); fprintf( outfile, " rec.addr = __builtin_return_address(1);\n" ); fprintf( outfile, "#else\n" ); fprintf( outfile, " rec.addr = 0;\n" ); fprintf( outfile, "#endif\n" ); fprintf( outfile, " for (;;) RtlRaiseException( &rec );\n" ); fprintf( outfile, " return 0; /* shouldn't go here */\n" ); fprintf( outfile, " }\n}\n\n" ); fprintf( outfile, "#ifndef __GNUC__\n" ); fprintf( outfile, "static void __asm__dummy_delay_import(void) {\n" ); fprintf( outfile, "#endif\n" ); fprintf( outfile, "asm(\".align %d\\n\"\n", get_alignment(8) ); output_function_name (outfile, "__wine_delay_load_asm"); fprintf( outfile, " \"" PREFIX "__wine_delay_load_asm:\\n\"\n" ); #if defined(__i386__) fprintf( outfile, " \"\\tpushl %%ecx\\n\\tpushl %%edx\\n\\tpushl %%eax\\n\"\n" ); fprintf( outfile, " \"\\tcall " __ASM_NAME("__wine_delay_load") "\\n\"\n" ); fprintf( outfile, " \"\\tpopl %%edx\\n\\tpopl %%ecx\\n\\tjmp *%%eax\\n\"\n" ); #elif defined(__sparc__) fprintf( outfile, " \"\\tsave %%sp, -96, %%sp\\n\"\n" ); fprintf( outfile, " \"\\tcall __wine_delay_load\\n\"\n" ); fprintf( outfile, " \"\\tmov %%g1, %%o0\\n\"\n" ); fprintf( outfile, " \"\\tjmp %%o0\\n\\trestore\\n\"\n" ); #elif defined(__PPC__) fprintf(outfile, "#error: DELAYED IMPORTS NOT SUPPORTED ON PPC!!!\n"); #else #error You need to defined delayed import thunks for your architecture! #endif for (i = idx = 0; i < nb_imports; i++) { if (!dll_imports[i]->delay) continue; for (j = 0; j < dll_imports[i]->nb_imports; j++) { char buffer[128]; sprintf( buffer, "__wine_delay_imp_%d_%s", i, dll_imports[i]->imports[j]); output_function_name (outfile, buffer); fprintf( outfile, " \"" PREFIX "%s:\\n\"\n", buffer ); #if defined(__i386__) fprintf( outfile, " \"\\tmovl $%d, %%eax\\n\"\n", (idx << 16) | j ); fprintf( outfile, " \"\\tjmp " __ASM_NAME("__wine_delay_load_asm")"\\n\"\n" ); #elif defined(__sparc__) fprintf( outfile, " \"\\tset %d, %%g1\\n\"\n", (idx << 16) | j ); fprintf( outfile, " \"\\tb,a __wine_delay_load_asm\\n\"\n" ); #elif defined(__PPC__) fprintf(outfile, "#error: DELAYED IMPORTS NOT SUPPORTED ON PPC!!!\n"); #else #error You need to defined delayed import thunks for your architecture! #endif } idx++; } fprintf( outfile, "\n \".align %d\\n\"\n", get_alignment(8) ); pos = nb_delayed * 32; for (i = 0; i < nb_imports; i++) { if (!dll_imports[i]->delay) continue; for (j = 0; j < dll_imports[i]->nb_imports; j++, pos += 4) output_import_thunk (outfile, dll_imports[i]->imports[j], "delay_imports", pos); } fprintf( outfile, ");\n" ); fprintf( outfile, "#ifndef __GNUC__\n" ); fprintf( outfile, "}\n" ); fprintf( outfile, "#endif\n" ); fprintf( outfile, "\n" ); done: return nb_delayed; }
/* output the import table of a Win32 module */ static int output_immediate_imports( FILE *outfile ) { int i, j, pos; int nb_imm = nb_imports - nb_delayed; if (!nb_imm) goto done; /* main import header */ fprintf( outfile, "\nstatic struct {\n" ); fprintf( outfile, " struct {\n" ); fprintf( outfile, " void *OriginalFirstThunk;\n" ); fprintf( outfile, " unsigned int TimeDateStamp;\n" ); fprintf( outfile, " unsigned int ForwarderChain;\n" ); fprintf( outfile, " const char *Name;\n" ); fprintf( outfile, " void *FirstThunk;\n" ); fprintf( outfile, " } imp[%d];\n", nb_imm+1 ); fprintf( outfile, " const char *data[%d];\n", total_imports - total_delayed + nb_imm ); fprintf( outfile, "} imports = {\n {\n" ); /* list of dlls */ for (i = j = 0; i < nb_imports; i++) { if (dll_imports[i]->delay) continue; fprintf( outfile, " { 0, 0, 0, \"%s\", &imports.data[%d] },\n", dll_imports[i]->dll, j ); j += dll_imports[i]->nb_imports + 1; } fprintf( outfile, " { 0, 0, 0, 0, 0 },\n" ); fprintf( outfile, " },\n {\n" ); /* list of imported functions */ for (i = 0; i < nb_imports; i++) { if (dll_imports[i]->delay) continue; fprintf( outfile, " /* %s */\n", dll_imports[i]->dll ); for (j = 0; j < dll_imports[i]->nb_imports; j++) fprintf( outfile, " \"\\0\\0%s\",\n", dll_imports[i]->imports[j] ); fprintf( outfile, " 0,\n" ); } fprintf( outfile, " }\n};\n\n" ); /* thunks for imported functions */ fprintf( outfile, "#ifndef __GNUC__\nstatic void __asm__dummy_import(void) {\n#endif\n\n" ); pos = 20 * (nb_imm + 1); /* offset of imports.data from start of imports */ fprintf( outfile, "asm(\".text\\n\\t.align %d\\n\"\n", get_alignment(8) ); for (i = 0; i < nb_imports; i++) { if (dll_imports[i]->delay) continue; for (j = 0; j < dll_imports[i]->nb_imports; j++, pos += 4) output_import_thunk (outfile, dll_imports[i]->imports[j], "imports", pos); pos += 4; } #if !defined(__APPLE__) fprintf( outfile, "\".section\\t\\\".text\\\"\");\n#ifndef __GNUC__\n}\n#endif\n\n" ); #else /* Slightly different syntax on the Mac assembler */ fprintf( outfile, "\".text\");\n#ifndef __GNUC__\n}\n#endif\n\n" ); #endif done: return nb_imm; }