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