?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
setupapi: Avoid hardcoding the Unicode string literal lengths.
[wine.git] / tools / winebuild / spec16.c
blob481ed132e0e999f3d051e742ebb897145a51448a
1 /*
2 * 16-bit spec files
3 *
4 * Copyright 1993 Robert J. Amstadt
5 * Copyright 1995 Martin von Loewis
6 * Copyright 1995, 1996, 1997 Alexandre Julliard
7 * Copyright 1997 Eric Youngdale
8 * Copyright 1999 Ulrich Weigand
9 *
10 * This library is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU Lesser General Public
12 * License as published by the Free Software Foundation; either
13 * version 2.1 of the License, or (at your option) any later version.
14 *
15 * This library is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * Lesser General Public License for more details.
19 *
20 * You should have received a copy of the GNU Lesser General Public
21 * License along with this library; if not, write to the Free Software
22 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
23 */
24
25 #include "config.h"
26 #include "wine/port.h"
27
28 #include <assert.h>
29 #include <ctype.h>
30
31 #include "build.h"
32
33 #define NE_FFLAGS_SINGLEDATA 0x0001
34 #define NE_FFLAGS_LIBMODULE 0x8000
35
36 /* argument type flags for relay debugging */
37 enum arg_types
38 {
39 ARG16_NONE = 0, /* indicates end of arg list */
40 ARG16_WORD, /* unsigned word */
41 ARG16_SWORD, /* signed word */
42 ARG16_LONG, /* long or segmented pointer */
43 ARG16_PTR, /* linear pointer */
44 ARG16_STR, /* linear pointer to null-terminated string */
45 ARG16_SEGSTR, /* segmented pointer to null-terminated string */
46 ARG16_VARARG /* start of varargs */
47 };
48
49 /* sequences of nops to fill a certain number of words */
50 static const char * const nop_sequence[4] =
51 {
52 ".byte 0x89,0xf6", /* mov %esi,%esi */
53 ".byte 0x8d,0x74,0x26,0x00", /* lea 0x00(%esi),%esi */
54 ".byte 0x8d,0xb6,0x00,0x00,0x00,0x00", /* lea 0x00000000(%esi),%esi */
55 ".byte 0x8d,0x74,0x26,0x00,0x8d,0x74,0x26,0x00" /* lea 0x00(%esi),%esi; lea 0x00(%esi),%esi */
56 };
57
58 static inline int is_function( const ORDDEF *odp )
59 {
60 if (odp->flags & FLAG_EXPORT32) return 0;
61 return (odp->type == TYPE_CDECL ||
62 odp->type == TYPE_PASCAL ||
63 odp->type == TYPE_VARARGS ||
64 odp->type == TYPE_STUB);
65 }
66
67 static const char *get_args_str( const ORDDEF *odp )
68 {
69 static char buffer[MAX_ARGUMENTS*2+1];
70 int i;
71
72 buffer[0] = 0;
73 for (i = 0; i < odp->u.func.nb_args; i++)
74 {
75 switch (odp->u.func.args[i])
76 {
77 case ARG_WORD: strcat( buffer, "w" ); break;
78 case ARG_SWORD: strcat( buffer, "s" ); break;
79 case ARG_SEGSTR: strcat( buffer, "T" ); break;
80 case ARG_STR: strcat( buffer, "t" ); break;
81 case ARG_LONG:
82 case ARG_FLOAT:
83 case ARG_SEGPTR: strcat( buffer, "l" ); break;
84 case ARG_PTR:
85 case ARG_WSTR:
86 case ARG_INT128: strcat( buffer, "p" ); break;
87 case ARG_INT64:
88 case ARG_DOUBLE: strcat( buffer, "ll" ); break;
89 }
90 }
91 return buffer;
92 }
93
94 /*******************************************************************
95 * output_entries
96 *
97 * Output entries for individual symbols in the entry table.
98 */
99 static void output_entries( DLLSPEC *spec, int first, int count )
100 {
101 int i;
102
103 for (i = 0; i < count; i++)
104 {
105 ORDDEF *odp = spec->ordinals[first + i];
106 output( "\t.byte 0x03\n" ); /* flags: exported & public data */
107 switch (odp->type)
108 {
109 case TYPE_CDECL:
110 case TYPE_PASCAL:
111 case TYPE_VARARGS:
112 case TYPE_STUB:
113 output( "\t%s .L__wine_%s_%u-.L__wine_spec_code_segment\n",
114 get_asm_short_keyword(),
115 make_c_identifier(spec->dll_name), first + i );
116 break;
117 case TYPE_VARIABLE:
118 output( "\t%s .L__wine_%s_%u-.L__wine_spec_data_segment\n",
119 get_asm_short_keyword(),
120 make_c_identifier(spec->dll_name), first + i );
121 break;
122 case TYPE_ABS:
123 output( "\t%s 0x%04x /* %s */\n",
124 get_asm_short_keyword(), odp->u.abs.value, odp->name );
125 break;
126 default:
127 assert(0);
128 }
129 }
130 }
131
132
133 /*******************************************************************
134 * output_entry_table
135 */
136 static void output_entry_table( DLLSPEC *spec )
137 {
138 int i, prev = 0, prev_sel = -1, bundle_count = 0;
139
140 for (i = 1; i <= spec->limit; i++)
141 {
142 int selector = 0;
143 ORDDEF *odp = spec->ordinals[i];
144 if (!odp) continue;
145 if (odp->flags & FLAG_EXPORT32) continue;
146
147 switch (odp->type)
148 {
149 case TYPE_CDECL:
150 case TYPE_PASCAL:
151 case TYPE_VARARGS:
152 case TYPE_STUB:
153 selector = 1; /* Code selector */
154 break;
155 case TYPE_VARIABLE:
156 selector = 2; /* Data selector */
157 break;
158 case TYPE_ABS:
159 selector = 0xfe; /* Constant selector */
160 break;
161 default:
162 continue;
163 }
164
165 if (prev + 1 != i || prev_sel != selector || bundle_count == 255)
166 {
167 /* need to start a new bundle */
168
169 /* flush previous bundle */
170 if (bundle_count)
171 {
172 output( "\t/* %s.%d - %s.%d */\n",
173 spec->dll_name, prev - bundle_count + 1, spec->dll_name, prev );
174 output( "\t.byte 0x%02x,0x%02x\n", bundle_count, prev_sel );
175 output_entries( spec, prev - bundle_count + 1, bundle_count );
176 }
177
178 if (prev + 1 != i)
179 {
180 int skip = i - (prev + 1);
181 while (skip > 255)
182 {
183 output( "\t.byte 0xff,0x00\n" );
184 skip -= 255;
185 }
186 output( "\t.byte 0x%02x,0x00\n", skip );
187 }
188
189 bundle_count = 0;
190 prev_sel = selector;
191 }
192 bundle_count++;
193 prev = i;
194 }
195
196 /* flush last bundle */
197 if (bundle_count)
198 {
199 output( "\t.byte 0x%02x,0x%02x\n", bundle_count, prev_sel );
200 output_entries( spec, prev - bundle_count + 1, bundle_count );
201 }
202 output( "\t.byte 0x00\n" );
203 }
204
205
206 /*******************************************************************
207 * output_resident_name
208 */
209 static void output_resident_name( const char *string, int ordinal )
210 {
211 unsigned int i, len = strlen(string);
212
213 output( "\t.byte 0x%02x", len );
214 for (i = 0; i < len; i++) output( ",0x%02x", (unsigned char)toupper(string[i]) );
215 output( " /* %s */\n", string );
216 output( "\t%s %u\n", get_asm_short_keyword(), ordinal );
217 }
218
219
220 /*******************************************************************
221 * get_callfrom16_name
222 */
223 static const char *get_callfrom16_name( const ORDDEF *odp )
224 {
225 static char *buffer;
226
227 free( buffer );
228 buffer = strmake( "%s_%s_%s",
229 (odp->type == TYPE_PASCAL) ? "p" :
230 (odp->type == TYPE_VARARGS) ? "v" : "c",
231 (odp->flags & FLAG_REGISTER) ? "regs" :
232 (odp->flags & FLAG_RET16) ? "word" : "long",
233 get_args_str(odp) );
234 return buffer;
235 }
236
237
238 /*******************************************************************
239 * get_relay_name
240 */
241 static const char *get_relay_name( const ORDDEF *odp )
242 {
243 static char buffer[80];
244 char *p;
245
246 switch(odp->type)
247 {
248 case TYPE_PASCAL:
249 strcpy( buffer, "p_" );
250 break;
251 case TYPE_VARARGS:
252 strcpy( buffer, "v_" );
253 break;
254 case TYPE_CDECL:
255 case TYPE_STUB:
256 strcpy( buffer, "c_" );
257 break;
258 default:
259 assert(0);
260 }
261 strcat( buffer, get_args_str(odp) );
262 for (p = buffer + 2; *p; p++)
263 {
264 /* map string types to the corresponding plain pointer type */
265 if (*p == 't') *p = 'p';
266 else if (*p == 'T') *p = 'l';
267 }
268 if (odp->flags & FLAG_REGISTER) strcat( buffer, "_regs" );
269 return buffer;
270 }
271
272
273 /*******************************************************************
274 * get_function_argsize
275 */
276 static int get_function_argsize( const ORDDEF *odp )
277 {
278 int i, argsize = 0;
279
280 for (i = 0; i < odp->u.func.nb_args; i++)
281 {
282 switch (odp->u.func.args[i])
283 {
284 case ARG_WORD:
285 case ARG_SWORD:
286 argsize += 2;
287 break;
288 case ARG_SEGPTR:
289 case ARG_SEGSTR:
290 case ARG_LONG:
291 case ARG_PTR:
292 case ARG_STR:
293 case ARG_WSTR:
294 case ARG_FLOAT:
295 case ARG_INT128:
296 argsize += 4;
297 break;
298 case ARG_INT64:
299 case ARG_DOUBLE:
300 argsize += 8;
301 break;
302 }
303 }
304 return argsize;
305 }
306
307
308 /*******************************************************************
309 * output_call16_function
310 *
311 * Build a 16-bit-to-Wine callback glue function.
312 *
313 * The generated routines are intended to be used as argument conversion
314 * routines to be called by the CallFrom16... core. Thus, the prototypes of
315 * the generated routines are (see also CallFrom16):
316 *
317 * extern WORD WINAPI __wine_spec_call16_C_xxx( FARPROC func, LPBYTE args );
318 * extern LONG WINAPI __wine_spec_call16_C_xxx( FARPROC func, LPBYTE args );
319 * extern void WINAPI __wine_spec_call16_C_xxx_regs( FARPROC func, LPBYTE args, CONTEXT86 *context );
320 *
321 * where 'C' is the calling convention ('p' for pascal or 'c' for cdecl),
322 * and each 'x' is an argument ('w'=word, 's'=signed word, 'l'=long,
323 * 'p'=linear pointer, 't'=linear pointer to null-terminated string,
324 * 'T'=segmented pointer to null-terminated string).
325 *
326 * The generated routines fetch the arguments from the 16-bit stack (pointed
327 * to by 'args'); the offsets of the single argument values are computed
328 * according to the calling convention and the argument types. Then, the
329 * 32-bit entry point is called with these arguments.
330 *
331 * For register functions, the arguments (if present) are converted just
332 * the same as for normal functions, but in addition the CONTEXT86 pointer
333 * filled with the current register values is passed to the 32-bit routine.
334 */
335 static void output_call16_function( ORDDEF *odp )
336 {
337 char *name;
338 int i, pos, stack_words;
339 int argsize = get_function_argsize( odp );
340 int needs_ldt = (strpbrk( get_args_str( odp ), "pt" ) != NULL);
341
342 name = strmake( ".L__wine_spec_call16_%s", get_relay_name(odp) );
343
344 output( "\t.align %d\n", get_alignment(4) );
345 output( "\t%s\n", func_declaration(name) );
346 output( "%s:\n", name );
347 output_cfi( ".cfi_startproc" );
348 output( "\tpushl %%ebp\n" );
349 output_cfi( ".cfi_adjust_cfa_offset 4" );
350 output_cfi( ".cfi_rel_offset %%ebp,0" );
351 output( "\tmovl %%esp,%%ebp\n" );
352 output_cfi( ".cfi_def_cfa_register %%ebp" );
353 stack_words = 2;
354 if (needs_ldt)
355 {
356 output( "\tpushl %%esi\n" );
357 output_cfi( ".cfi_rel_offset %%esi,-4" );
358 stack_words++;
359 if (UsePIC)
360 {
361 output( "\tcall %s\n", asm_name("__wine_spec_get_pc_thunk_eax") );
362 output( "1:\tmovl wine_ldt_copy_ptr-1b(%%eax),%%esi\n" );
363 }
364 else
365 output( "\tmovl $%s,%%esi\n", asm_name("wine_ldt_copy") );
366 }
367
368 /* preserve 16-byte stack alignment */
369 stack_words += odp->u.func.nb_args;
370 for (i = 0; i < odp->u.func.nb_args; i++)
371 if (odp->u.func.args[i] == ARG_DOUBLE || odp->u.func.args[i] == ARG_INT64) stack_words++;
372 if ((odp->flags & FLAG_REGISTER) || (odp->type == TYPE_VARARGS)) stack_words++;
373 if (stack_words % 4) output( "\tsubl $%d,%%esp\n", 16 - 4 * (stack_words % 4) );
374
375 if (odp->u.func.nb_args || odp->type == TYPE_VARARGS)
376 output( "\tmovl 12(%%ebp),%%ecx\n" ); /* args */
377
378 if (odp->flags & FLAG_REGISTER)
379 {
380 output( "\tpushl 16(%%ebp)\n" ); /* context */
381 }
382 else if (odp->type == TYPE_VARARGS)
383 {
384 output( "\tleal %d(%%ecx),%%eax\n", argsize );
385 output( "\tpushl %%eax\n" ); /* va_list16 */
386 }
387
388 pos = (odp->type == TYPE_PASCAL) ? 0 : argsize;
389 for (i = odp->u.func.nb_args - 1; i >= 0; i--)
390 {
391 switch (odp->u.func.args[i])
392 {
393 case ARG_WORD:
394 if (odp->type != TYPE_PASCAL) pos -= 2;
395 output( "\tmovzwl %d(%%ecx),%%eax\n", pos );
396 output( "\tpushl %%eax\n" );
397 if (odp->type == TYPE_PASCAL) pos += 2;
398 break;
399
400 case ARG_SWORD:
401 if (odp->type != TYPE_PASCAL) pos -= 2;
402 output( "\tmovswl %d(%%ecx),%%eax\n", pos );
403 output( "\tpushl %%eax\n" );
404 if (odp->type == TYPE_PASCAL) pos += 2;
405 break;
406
407 case ARG_INT64:
408 case ARG_DOUBLE:
409 if (odp->type != TYPE_PASCAL) pos -= 4;
410 output( "\tpushl %d(%%ecx)\n", pos );
411 if (odp->type == TYPE_PASCAL) pos += 4;
412 /* fall through */
413 case ARG_LONG:
414 case ARG_FLOAT:
415 case ARG_SEGPTR:
416 case ARG_SEGSTR:
417 if (odp->type != TYPE_PASCAL) pos -= 4;
418 output( "\tpushl %d(%%ecx)\n", pos );
419 if (odp->type == TYPE_PASCAL) pos += 4;
420 break;
421
422 case ARG_PTR:
423 case ARG_STR:
424 case ARG_WSTR:
425 case ARG_INT128:
426 if (odp->type != TYPE_PASCAL) pos -= 4;
427 output( "\tmovzwl %d(%%ecx),%%edx\n", pos + 2 ); /* sel */
428 output( "\tshr $3,%%edx\n" );
429 output( "\tmovzwl %d(%%ecx),%%eax\n", pos ); /* offset */
430 output( "\taddl (%%esi,%%edx,4),%%eax\n" );
431 output( "\tpushl %%eax\n" );
432 if (odp->type == TYPE_PASCAL) pos += 4;
433 break;
434 }
435 }
436
437 output( "\tcall *8(%%ebp)\n" );
438
439 if (needs_ldt)
440 {
441 output( "\tmovl -4(%%ebp),%%esi\n" );
442 output_cfi( ".cfi_same_value %%esi" );
443 }
444 output( "\tleave\n" );
445 output_cfi( ".cfi_def_cfa %%esp,4" );
446 output_cfi( ".cfi_same_value %%ebp" );
447 output( "\tret\n" );
448 output_cfi( ".cfi_endproc" );
449 output_function_size( name );
450 free( name );
451 }
452
453
454 /*******************************************************************
455 * callfrom16_type_compare
456 *
457 * Compare two callfrom16 sequences.
458 */
459 static int callfrom16_type_compare( const void *e1, const void *e2 )
460 {
461 const ORDDEF *odp1 = *(const ORDDEF * const *)e1;
462 const ORDDEF *odp2 = *(const ORDDEF * const *)e2;
463 int retval;
464 int type1 = odp1->type;
465 int type2 = odp2->type;
466 char args1[80];
467
468 if (type1 == TYPE_STUB) type1 = TYPE_CDECL;
469 if (type2 == TYPE_STUB) type2 = TYPE_CDECL;
470
471 if ((retval = type1 - type2) != 0) return retval;
472
473 type1 = odp1->flags & (FLAG_RET16|FLAG_REGISTER);
474 type2 = odp2->flags & (FLAG_RET16|FLAG_REGISTER);
475
476 if ((retval = type1 - type2) != 0) return retval;
477
478 strcpy( args1, get_args_str( odp1 ));
479 return strcmp( args1, get_args_str( odp2 ));
480 }
481
482
483 /*******************************************************************
484 * relay_type_compare
485 *
486 * Same as callfrom16_type_compare but ignores differences that don't affect the resulting relay function.
487 */
488 static int relay_type_compare( const void *e1, const void *e2 )
489 {
490 const ORDDEF *odp1 = *(const ORDDEF * const *)e1;
491 const ORDDEF *odp2 = *(const ORDDEF * const *)e2;
492 char name1[80];
493
494 strcpy( name1, get_relay_name(odp1) );
495 return strcmp( name1, get_relay_name(odp2) );
496 }
497
498
499 /*******************************************************************
500 * sort_func_list
501 *
502 * Sort a list of functions, removing duplicates.
503 */
504 static int sort_func_list( ORDDEF **list, int count,
505 int (*compare)(const void *, const void *) )
506 {
507 int i, j;
508
509 if (!count) return 0;
510 qsort( list, count, sizeof(*list), compare );
511
512 for (i = j = 0; i < count; i++)
513 {
514 if (compare( &list[j], &list[i] )) list[++j] = list[i];
515 }
516 return j + 1;
517 }
518
519
520 /*******************************************************************
521 * output_module16
522 *
523 * Output code for a 16-bit module.
524 */
525 static void output_module16( DLLSPEC *spec )
526 {
527 ORDDEF **typelist;
528 ORDDEF *entry_point = NULL;
529 int i, j, nb_funcs;
530
531 /* store the main entry point as ordinal 0 */
532
533 if (!spec->ordinals)
534 {
535 assert(spec->limit == 0);
536 spec->ordinals = xmalloc( sizeof(spec->ordinals[0]) );
537 spec->ordinals[0] = NULL;
538 }
539 if (spec->init_func && !(spec->characteristics & IMAGE_FILE_DLL))
540 {
541 entry_point = xmalloc( sizeof(*entry_point) );
542 entry_point->type = TYPE_PASCAL;
543 entry_point->ordinal = 0;
544 entry_point->lineno = 0;
545 entry_point->flags = FLAG_REGISTER;
546 entry_point->name = NULL;
547 entry_point->link_name = xstrdup( spec->init_func );
548 entry_point->export_name = NULL;
549 entry_point->u.func.nb_args = 0;
550 assert( !spec->ordinals[0] );
551 spec->ordinals[0] = entry_point;
552 }
553
554 /* Build sorted list of all argument types, without duplicates */
555
556 typelist = xmalloc( (spec->limit + 1) * sizeof(*typelist) );
557
558 for (i = nb_funcs = 0; i <= spec->limit; i++)
559 {
560 ORDDEF *odp = spec->ordinals[i];
561 if (!odp) continue;
562 if (is_function( odp )) typelist[nb_funcs++] = odp;
563 }
564
565 nb_funcs = sort_func_list( typelist, nb_funcs, callfrom16_type_compare );
566
567 /* Output the module structure */
568
569 output( "\n/* module data */\n\n" );
570 output( "\t.data\n" );
571 output( "\t.align %d\n", get_alignment(4) );
572 output( ".L__wine_spec_dos_header:\n" );
573 output( "\t%s 0x5a4d\n", get_asm_short_keyword() ); /* e_magic */
574 output( "\t%s 0\n", get_asm_short_keyword() ); /* e_cblp */
575 output( "\t%s 0\n", get_asm_short_keyword() ); /* e_cp */
576 output( "\t%s 0\n", get_asm_short_keyword() ); /* e_crlc */
577 output( "\t%s 0\n", get_asm_short_keyword() ); /* e_cparhdr */
578 output( "\t%s 0\n", get_asm_short_keyword() ); /* e_minalloc */
579 output( "\t%s 0\n", get_asm_short_keyword() ); /* e_maxalloc */
580 output( "\t%s 0\n", get_asm_short_keyword() ); /* e_ss */
581 output( "\t%s 0\n", get_asm_short_keyword() ); /* e_sp */
582 output( "\t%s 0\n", get_asm_short_keyword() ); /* e_csum */
583 output( "\t%s 0\n", get_asm_short_keyword() ); /* e_ip */
584 output( "\t%s 0\n", get_asm_short_keyword() ); /* e_cs */
585 output( "\t%s 0\n", get_asm_short_keyword() ); /* e_lfarlc */
586 output( "\t%s 0\n", get_asm_short_keyword() ); /* e_ovno */
587 output( "\t%s 0,0,0,0\n", get_asm_short_keyword() ); /* e_res */
588 output( "\t%s 0\n", get_asm_short_keyword() ); /* e_oemid */
589 output( "\t%s 0\n", get_asm_short_keyword() ); /* e_oeminfo */
590 output( "\t%s 0,0,0,0,0,0,0,0,0,0\n", get_asm_short_keyword() ); /* e_res2 */
591 output( "\t.long .L__wine_spec_ne_header-.L__wine_spec_dos_header\n" );/* e_lfanew */
592
593 output( ".L__wine_spec_ne_header:\n" );
594 output( "\t%s 0x454e\n", get_asm_short_keyword() ); /* ne_magic */
595 output( "\t.byte 0\n" ); /* ne_ver */
596 output( "\t.byte 0\n" ); /* ne_rev */
597 output( "\t%s .L__wine_spec_ne_enttab-.L__wine_spec_ne_header\n", /* ne_enttab */
598 get_asm_short_keyword() );
599 output( "\t%s .L__wine_spec_ne_enttab_end-.L__wine_spec_ne_enttab\n", /* ne_cbenttab */
600 get_asm_short_keyword() );
601 output( "\t.long 0\n" ); /* ne_crc */
602 output( "\t%s 0x%04x\n", get_asm_short_keyword(), /* ne_flags */
603 NE_FFLAGS_SINGLEDATA |
604 ((spec->characteristics & IMAGE_FILE_DLL) ? NE_FFLAGS_LIBMODULE : 0) );
605 output( "\t%s 2\n", get_asm_short_keyword() ); /* ne_autodata */
606 output( "\t%s %u\n", get_asm_short_keyword(), spec->heap_size ); /* ne_heap */
607 output( "\t%s 0\n", get_asm_short_keyword() ); /* ne_stack */
608 if (!entry_point) output( "\t.long 0\n" ); /* ne_csip */
609 else output( "\t%s .L__wine_%s_0-.L__wine_spec_code_segment,1\n",
610 get_asm_short_keyword(), make_c_identifier(spec->dll_name) );
611 output( "\t%s 0,2\n", get_asm_short_keyword() ); /* ne_sssp */
612 output( "\t%s 2\n", get_asm_short_keyword() ); /* ne_cseg */
613 output( "\t%s 0\n", get_asm_short_keyword() ); /* ne_cmod */
614 output( "\t%s 0\n", get_asm_short_keyword() ); /* ne_cbnrestab */
615 output( "\t%s .L__wine_spec_ne_segtab-.L__wine_spec_ne_header\n", /* ne_segtab */
616 get_asm_short_keyword() );
617 output( "\t%s .L__wine_spec_ne_rsrctab-.L__wine_spec_ne_header\n", /* ne_rsrctab */
618 get_asm_short_keyword() );
619 output( "\t%s .L__wine_spec_ne_restab-.L__wine_spec_ne_header\n", /* ne_restab */
620 get_asm_short_keyword() );
621 output( "\t%s .L__wine_spec_ne_modtab-.L__wine_spec_ne_header\n", /* ne_modtab */
622 get_asm_short_keyword() );
623 output( "\t%s .L__wine_spec_ne_imptab-.L__wine_spec_ne_header\n", /* ne_imptab */
624 get_asm_short_keyword() );
625 output( "\t.long 0\n" ); /* ne_nrestab */
626 output( "\t%s 0\n", get_asm_short_keyword() ); /* ne_cmovent */
627 output( "\t%s 0\n", get_asm_short_keyword() ); /* ne_align */
628 output( "\t%s 0\n", get_asm_short_keyword() ); /* ne_cres */
629 output( "\t.byte 0x02\n" ); /* ne_exetyp = NE_OSFLAGS_WINDOWS */
630 output( "\t.byte 0x08\n" ); /* ne_flagsothers = NE_AFLAGS_FASTLOAD */
631 output( "\t%s 0\n", get_asm_short_keyword() ); /* ne_pretthunks */
632 output( "\t%s 0\n", get_asm_short_keyword() ); /* ne_psegrefbytes */
633 output( "\t%s 0\n", get_asm_short_keyword() ); /* ne_swaparea */
634 output( "\t%s 0\n", get_asm_short_keyword() ); /* ne_expver */
635
636 /* segment table */
637
638 output( "\n.L__wine_spec_ne_segtab:\n" );
639
640 /* code segment entry */
641
642 output( "\t%s .L__wine_spec_code_segment-.L__wine_spec_dos_header\n", /* filepos */
643 get_asm_short_keyword() );
644 output( "\t%s .L__wine_spec_code_segment_end-.L__wine_spec_code_segment\n", /* size */
645 get_asm_short_keyword() );
646 output( "\t%s 0x2000\n", get_asm_short_keyword() ); /* flags = NE_SEGFLAGS_32BIT */
647 output( "\t%s .L__wine_spec_code_segment_end-.L__wine_spec_code_segment\n", /* minsize */
648 get_asm_short_keyword() );
649
650 /* data segment entry */
651
652 output( "\t%s .L__wine_spec_data_segment-.L__wine_spec_dos_header\n", /* filepos */
653 get_asm_short_keyword() );
654 output( "\t%s .L__wine_spec_data_segment_end-.L__wine_spec_data_segment\n", /* size */
655 get_asm_short_keyword() );
656 output( "\t%s 0x0001\n", get_asm_short_keyword() ); /* flags = NE_SEGFLAGS_DATA */
657 output( "\t%s .L__wine_spec_data_segment_end-.L__wine_spec_data_segment\n", /* minsize */
658 get_asm_short_keyword() );
659
660 /* resource directory */
661
662 output_res16_directory( spec );
663
664 /* resident names table */
665
666 output( "\n\t.align %d\n", get_alignment(2) );
667 output( ".L__wine_spec_ne_restab:\n" );
668 output_resident_name( spec->dll_name, 0 );
669 for (i = 1; i <= spec->limit; i++)
670 {
671 ORDDEF *odp = spec->ordinals[i];
672 if (!odp || !odp->name[0]) continue;
673 if (odp->flags & FLAG_EXPORT32) continue;
674 output_resident_name( odp->name, i );
675 }
676 output( "\t.byte 0\n" );
677
678 /* imported names table */
679
680 output( "\n\t.align %d\n", get_alignment(2) );
681 output( ".L__wine_spec_ne_modtab:\n" );
682 output( ".L__wine_spec_ne_imptab:\n" );
683 output( "\t.byte 0,0\n" );
684
685 /* entry table */
686
687 output( "\n.L__wine_spec_ne_enttab:\n" );
688 output_entry_table( spec );
689 output( ".L__wine_spec_ne_enttab_end:\n" );
690
691 /* code segment */
692
693 output( "\n\t.align %d\n", get_alignment(2) );
694 output( ".L__wine_spec_code_segment:\n" );
695
696 for ( i = 0; i < nb_funcs; i++ )
697 {
698 unsigned int arg_types[2];
699 int nop_words, pos, argsize = 0;
700
701 if ( typelist[i]->type == TYPE_PASCAL )
702 argsize = get_function_argsize( typelist[i] );
703
704 /* build the arg types bit fields */
705 arg_types[0] = arg_types[1] = 0;
706 for (j = pos = 0; j < typelist[i]->u.func.nb_args && pos < 20; j++, pos++)
707 {
708 int type = 0;
709 switch (typelist[i]->u.func.args[j])
710 {
711 case ARG_WORD: type = ARG16_WORD; break;
712 case ARG_SWORD: type = ARG16_SWORD; break;
713 case ARG_SEGPTR: type = ARG16_LONG; break;
714 case ARG_SEGSTR: type = ARG16_SEGSTR; break;
715 case ARG_LONG: type = ARG16_LONG; break;
716 case ARG_PTR: type = ARG16_PTR; break;
717 case ARG_STR: type = ARG16_STR; break;
718 case ARG_WSTR: type = ARG16_PTR; break;
719 case ARG_FLOAT: type = ARG16_LONG; break;
720 case ARG_INT128: type = ARG16_PTR; break;
721 case ARG_INT64:
722 case ARG_DOUBLE:
723 type = ARG16_LONG;
724 arg_types[pos / 10] |= type << (3 * (pos % 10));
725 pos++;
726 break;
727 }
728 if (pos < 20) arg_types[pos / 10] |= type << (3 * (pos % 10));
729 }
730 if (typelist[i]->type == TYPE_VARARGS && pos < 20)
731 arg_types[pos / 10] |= ARG16_VARARG << (3 * (pos % 10));
732
733 output( ".L__wine_spec_callfrom16_%s:\n", get_callfrom16_name(typelist[i]) );
734 output( "\tpushl $.L__wine_spec_call16_%s\n", get_relay_name(typelist[i]) );
735 output( "\tlcall $0,$0\n" );
736
737 if (typelist[i]->flags & FLAG_REGISTER)
738 {
739 nop_words = 4;
740 }
741 else if (typelist[i]->flags & FLAG_RET16)
742 {
743 output( "\torw %%ax,%%ax\n" );
744 output( "\tnop\n" ); /* so that the lretw is aligned */
745 nop_words = 2;
746 }
747 else
748 {
749 output( "\tshld $16,%%eax,%%edx\n" );
750 output( "\torl %%eax,%%eax\n" );
751 nop_words = 1;
752 }
753
754 if (argsize)
755 {
756 output( "\tlretw $%u\n", argsize );
757 nop_words--;
758 }
759 else output( "\tlretw\n" );
760
761 if (nop_words) output( "\t%s\n", nop_sequence[nop_words-1] );
762
763 /* the movl is here so that the code contains only valid instructions, */
764 /* it's never actually executed, we only care about the arg_types[] values */
765 output( "\t%s 0x86c7\n", get_asm_short_keyword() );
766 output( "\t.long 0x%08x,0x%08x\n", arg_types[0], arg_types[1] );
767 }
768
769 for (i = 0; i <= spec->limit; i++)
770 {
771 ORDDEF *odp = spec->ordinals[i];
772 if (!odp || !is_function( odp )) continue;
773 output( ".L__wine_%s_%u:\n", make_c_identifier(spec->dll_name), i );
774 output( "\tpushw %%bp\n" );
775 output( "\tpushl $%s\n",
776 asm_name( odp->type == TYPE_STUB ? get_stub_name( odp, spec ) : odp->link_name ));
777 output( "\tcallw .L__wine_spec_callfrom16_%s\n", get_callfrom16_name( odp ) );
778 }
779 output( ".L__wine_spec_code_segment_end:\n" );
780
781 /* data segment */
782
783 output( "\n.L__wine_spec_data_segment:\n" );
784 output( "\t.byte 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0\n" ); /* instance data */
785 for (i = 0; i <= spec->limit; i++)
786 {
787 ORDDEF *odp = spec->ordinals[i];
788 if (!odp || odp->type != TYPE_VARIABLE) continue;
789 output( ".L__wine_%s_%u:\n", make_c_identifier(spec->dll_name), i );
790 output( "\t.long " );
791 for (j = 0; j < odp->u.var.n_values-1; j++)
792 output( "0x%08x,", odp->u.var.values[j] );
793 output( "0x%08x\n", odp->u.var.values[j] );
794 }
795 output( ".L__wine_spec_data_segment_end:\n" );
796
797 /* resource data */
798
799 if (spec->nb_resources)
800 {
801 output( "\n.L__wine_spec_resource_data:\n" );
802 output_res16_data( spec );
803 }
804
805 output( "\t.byte 0\n" ); /* make sure the last symbol points to something */
806
807 /* relay functions */
808
809 nb_funcs = sort_func_list( typelist, nb_funcs, relay_type_compare );
810 if (nb_funcs)
811 {
812 output( "\n/* relay functions */\n\n" );
813 output( "\t.text\n" );
814 for ( i = 0; i < nb_funcs; i++ ) output_call16_function( typelist[i] );
815 output( "\t.data\n" );
816 output( "wine_ldt_copy_ptr:\n" );
817 output( "\t.long %s\n", asm_name("wine_ldt_copy") );
818 }
819
820 free( typelist );
821 }
822
823
824 /*******************************************************************
825 * output_spec16_file
826 *
827 * Output the complete data for a spec 16-bit file.
828 */
829 void output_spec16_file( DLLSPEC *spec16 )
830 {
831 DLLSPEC *spec32 = alloc_dll_spec();
832
833 resolve_imports( spec16 );
834 add_16bit_exports( spec32, spec16 );
835
836 output_standard_file_header();
837 output_module( spec32 );
838 output_module16( spec16 );
839 output_stubs( spec16 );
840 output_exports( spec32 );
841 output_imports( spec16 );
842 if (is_undefined( "__wine_call_from_16" )) output_asm_relays16();
843 if (spec16->main_module)
844 {
845 output( "\n\t%s\n", get_asm_string_section() );
846 output( ".L__wine_spec_main_module:\n" );
847 output( "\t%s \"%s\"\n", get_asm_string_keyword(), spec16->main_module );
848 }
849 output_gnu_stack_note();
850 free_dll_spec( spec32 );
851 }
852
853 /*******************************************************************
854 * output_fake_module16
855 *
856 * Create a fake 16-bit binary module.
857 */
858 void output_fake_module16( DLLSPEC *spec )
859 {
860 static const unsigned char code_segment[] = { 0x90, 0xc3 };
861 static const unsigned char data_segment[16] = { 0 };
862 static const char fakedll_signature[] = "Wine placeholder DLL";
863 const unsigned int cseg = 2;
864 const unsigned int lfanew = (0x40 + sizeof(fakedll_signature) + 15) & ~15;
865 const unsigned int segtab = lfanew + 0x40;
866
867 unsigned int i, rsrctab, restab, namelen, modtab, imptab, enttab, cbenttab, codeseg, dataseg, rsrcdata;
868
869 init_output_buffer();
870
871 rsrctab = lfanew;
872 restab = segtab + 8 * cseg;
873 if (spec->nb_resources)
874 {
875 output_bin_res16_directory( spec, 0 );
876 align_output( 2 );
877 rsrctab = restab;
878 restab += output_buffer_pos;
879 free( output_buffer );
880 init_output_buffer();
881 }
882
883 namelen = strlen( spec->dll_name );
884 modtab = restab + ((namelen + 3) & ~1);
885 imptab = modtab;
886 enttab = modtab + 2;
887 cbenttab = 1;
888 codeseg = (enttab + cbenttab + 1) & ~1;
889 dataseg = codeseg + sizeof(code_segment);
890 rsrcdata = dataseg + sizeof(data_segment);
891
892 init_output_buffer();
893
894 put_word( 0x5a4d ); /* e_magic */
895 put_word( 0x40 ); /* e_cblp */
896 put_word( 0x01 ); /* e_cp */
897 put_word( 0 ); /* e_crlc */
898 put_word( lfanew / 16 ); /* e_cparhdr */
899 put_word( 0x0000 ); /* e_minalloc */
900 put_word( 0xffff ); /* e_maxalloc */
901 put_word( 0x0000 ); /* e_ss */
902 put_word( 0x00b8 ); /* e_sp */
903 put_word( 0 ); /* e_csum */
904 put_word( 0 ); /* e_ip */
905 put_word( 0 ); /* e_cs */
906 put_word( lfanew ); /* e_lfarlc */
907 put_word( 0 ); /* e_ovno */
908 put_dword( 0 ); /* e_res */
909 put_dword( 0 );
910 put_word( 0 ); /* e_oemid */
911 put_word( 0 ); /* e_oeminfo */
912 put_dword( 0 ); /* e_res2 */
913 put_dword( 0 );
914 put_dword( 0 );
915 put_dword( 0 );
916 put_dword( 0 );
917 put_dword( lfanew );
918
919 put_data( fakedll_signature, sizeof(fakedll_signature) );
920 align_output( 16 );
921
922 put_word( 0x454e ); /* ne_magic */
923 put_byte( 0 ); /* ne_ver */
924 put_byte( 0 ); /* ne_rev */
925 put_word( enttab - lfanew ); /* ne_enttab */
926 put_word( cbenttab ); /* ne_cbenttab */
927 put_dword( 0 ); /* ne_crc */
928 put_word( NE_FFLAGS_SINGLEDATA | /* ne_flags */
929 ((spec->characteristics & IMAGE_FILE_DLL) ? NE_FFLAGS_LIBMODULE : 0) );
930 put_word( 2 ); /* ne_autodata */
931 put_word( spec->heap_size ); /* ne_heap */
932 put_word( 0 ); /* ne_stack */
933 put_word( 0 ); put_word( 0 ); /* ne_csip */
934 put_word( 0 ); put_word( 2 ); /* ne_sssp */
935 put_word( cseg ); /* ne_cseg */
936 put_word( 0 ); /* ne_cmod */
937 put_word( 0 ); /* ne_cbnrestab */
938 put_word( segtab - lfanew ); /* ne_segtab */
939 put_word( rsrctab - lfanew ); /* ne_rsrctab */
940 put_word( restab - lfanew ); /* ne_restab */
941 put_word( modtab - lfanew ); /* ne_modtab */
942 put_word( imptab - lfanew ); /* ne_imptab */
943 put_dword( 0 ); /* ne_nrestab */
944 put_word( 0 ); /* ne_cmovent */
945 put_word( 0 ); /* ne_align */
946 put_word( 0 ); /* ne_cres */
947 put_byte( 2 /*NE_OSFLAGS_WINDOWS*/ ); /* ne_exetyp */
948 put_byte( 8 /*NE_AFLAGS_FASTLOAD*/ ); /* ne_flagsothers */
949 put_word( 0 ); /* ne_pretthunks */
950 put_word( 0 ); /* ne_psegrefbytes */
951 put_word( 0 ); /* ne_swaparea */
952 put_word( 0 ); /* ne_expver */
953
954 /* segment table */
955 put_word( codeseg );
956 put_word( sizeof(code_segment) );
957 put_word( 0x2000 /* NE_SEGFLAGS_32BIT */ );
958 put_word( sizeof(code_segment) );
959 put_word( dataseg );
960 put_word( sizeof(data_segment) );
961 put_word( 0x0001 /* NE_SEGFLAGS_DATA */ );
962 put_word( sizeof(data_segment) );
963
964 /* resource directory */
965 if (spec->nb_resources)
966 {
967 output_bin_res16_directory( spec, rsrcdata );
968 align_output( 2 );
969 }
970
971 /* resident names table */
972 put_byte( namelen );
973 for (i = 0; i < namelen; i++) put_byte( toupper(spec->dll_name[i]) );
974 put_byte( 0 );
975 align_output( 2 );
976
977 /* imported names table */
978 put_word( 0 );
979
980 /* entry table */
981 put_byte( 0 );
982 align_output( 2 );
983
984 /* code segment */
985 put_data( code_segment, sizeof(code_segment) );
986
987 /* data segment */
988 put_data( data_segment, sizeof(data_segment) );
989
990 /* resource data */
991 output_bin_res16_data( spec );
992
993 flush_output_buffer();
994 }
Windows API implementation