2 * Copyright 1993 Robert J. Amstadt
3 * Copyright 1995 Alexandre Julliard
4 * Copyright 1995 Martin von Loewis
15 /* ELF symbols do not have an underscore in front */
16 #if defined (__ELF__) || defined (__svr4__)
22 #define TYPE_INVALID 0
26 #define TYPE_PASCAL_16 4
28 #define TYPE_REGISTER 6
32 #define TYPE_STDCALL 10
35 #define MAX_ORDINALS 1299
37 /* Callback function used for stub functions */
38 #define STUB_CALLBACK "RELAY_Unimplemented"
40 typedef struct ordinal_definition_s
45 void *additional_data;
48 typedef struct ordinal_variable_definition_s
54 typedef struct ordinal_function_definition_s
58 char internal_name[80];
61 typedef struct ordinal_return_definition_s
67 static ORDDEF OrdinalDefinitions[MAX_ORDINALS];
69 char LowerDLLName[80];
70 char UpperDLLName[80];
76 char *ParseBuffer = NULL;
81 static int debugging = 1;
83 /* Offset of register relative to the end of the context struct */
84 #define CONTEXTOFFSET(reg) \
85 ((int)&(((struct sigcontext_struct *)1)->reg) - 1 \
86 - sizeof(struct sigcontext_struct))
88 #define sc_eax uc_mcontext.gregs[EAX]
89 #define sc_ebx uc_mcontext.gregs[EBX]
90 #define sc_ecx uc_mcontext.gregs[ECX]
91 #define sc_edx uc_mcontext.gregs[EDX]
92 #define sc_esi uc_mcontext.gregs[ESI]
93 #define sc_edi uc_mcontext.gregs[EDI]
94 #define sc_ds uc_mcontext.gregs[DS]
95 #define sc_es uc_mcontext.gregs[ES]
96 #define sc_eflags uc_mcontext.gregs[EFL]
99 static void *xmalloc (size_t size)
103 res = malloc (size ? size : 1);
106 fprintf (stderr, "Virtual memory exhausted.\n");
113 static void *xrealloc (void *ptr, size_t size)
115 void *res = realloc (ptr, size);
118 fprintf (stderr, "Virtual memory exhausted.\n");
125 static int IsNumberString(char *s)
134 static char *strlower(char *s)
138 for(p = s; *p != '\0'; p++)
144 static char *strupper(char *s)
148 for(p = s; *p != '\0'; p++)
154 static char * GetTokenInLine(void)
159 if (ParseNext != ParseBuffer)
161 if (ParseSaveChar == '\0')
163 *ParseNext = ParseSaveChar;
167 * Remove initial white space.
169 for (p = ParseNext; isspace(*p); p++)
172 if ((*p == '\0') || (*p == '#'))
179 if (*token != '(' && *token != ')')
180 while (*p != '\0' && *p != '(' && *p != ')' && !isspace(*p))
190 static char * GetToken(void)
194 if (ParseBuffer == NULL)
196 ParseBuffer = xmalloc(512);
197 ParseNext = ParseBuffer;
201 if (fgets(ParseBuffer, 511, SpecFp) == NULL)
203 if (ParseBuffer[0] != '#')
208 while ((token = GetTokenInLine()) == NULL)
210 ParseNext = ParseBuffer;
214 if (fgets(ParseBuffer, 511, SpecFp) == NULL)
216 if (ParseBuffer[0] != '#')
224 static int ParseVariable(int ordinal, int type)
228 char export_name[80];
233 int value_array_size;
235 strcpy(export_name, GetToken());
240 fprintf(stderr, "%d: Expected '(' got '%s'\n", Line, token);
245 value_array_size = 25;
246 value_array = xmalloc(sizeof(*value_array) * value_array_size);
248 while ((token = GetToken()) != NULL)
253 value_array[n_values++] = strtol(token, &endptr, 0);
254 if (n_values == value_array_size)
256 value_array_size += 25;
257 value_array = xrealloc(value_array,
258 sizeof(*value_array) * value_array_size);
261 if (endptr == NULL || *endptr != '\0')
263 fprintf(stderr, "%d: Expected number value, got '%s'\n", Line,
271 fprintf(stderr, "%d: End of file in variable declaration\n", Line);
275 if (ordinal >= MAX_ORDINALS)
277 fprintf(stderr, "%d: Ordinal number too large\n", Line);
281 odp = &OrdinalDefinitions[ordinal];
283 strcpy(odp->export_name, export_name);
285 vdp = xmalloc(sizeof(*vdp));
286 odp->additional_data = vdp;
288 vdp->n_values = n_values;
289 vdp->values = xrealloc(value_array, sizeof(*value_array) * n_values);
294 static int ParseExportFunction(int ordinal, int type)
301 odp = &OrdinalDefinitions[ordinal];
302 strcpy(odp->export_name, GetToken());
304 fdp = xmalloc(sizeof(*fdp));
305 odp->additional_data = fdp;
310 fprintf(stderr, "%d: Expected '(' got '%s'\n", Line, token);
314 for (i = 0; i < 16; i++)
320 if (!strcmp(token, "byte") || !strcmp(token, "word"))
321 fdp->arg_types[i] = 'w';
322 else if (!strcmp(token, "s_byte") || !strcmp(token, "s_word"))
323 fdp->arg_types[i] = 's';
324 else if (!strcmp(token, "long") || !strcmp(token, "segptr"))
325 fdp->arg_types[i] = 'l';
326 else if (!strcmp(token, "ptr"))
327 fdp->arg_types[i] = 'p';
328 else if (!strcmp(token, "..."))
329 fdp->arg_types[i] = '.';
332 fprintf(stderr, "%d: Unknown variable type '%s'\n", Line, token);
336 fdp->arg_types[i] = '\0';
338 strcpy(fdp->internal_name, GetToken());
342 static int ParseEquate(int ordinal)
349 odp = &OrdinalDefinitions[ordinal];
350 strcpy(odp->export_name, GetToken());
353 value = strtol(token, &endptr, 0);
354 if (endptr == NULL || *endptr != '\0')
356 fprintf(stderr, "%d: Expected number value, got '%s'\n", Line,
361 odp->type = TYPE_ABS;
362 odp->additional_data = (void *) value;
367 static int ParseReturn(int ordinal)
374 rdp = xmalloc(sizeof(*rdp));
376 odp = &OrdinalDefinitions[ordinal];
377 strcpy(odp->export_name, GetToken());
378 odp->type = TYPE_RETURN;
379 odp->additional_data = rdp;
382 rdp->arg_size = strtol(token, &endptr, 0);
383 if (endptr == NULL || *endptr != '\0')
385 fprintf(stderr, "%d: Expected number value, got '%s'\n", Line,
391 rdp->ret_value = strtol(token, &endptr, 0);
392 if (endptr == NULL || *endptr != '\0')
394 fprintf(stderr, "%d: Expected number value, got '%s'\n", Line,
403 static int ParseStub( int ordinal )
408 odp = &OrdinalDefinitions[ordinal];
409 strcpy( odp->export_name, GetToken() );
410 odp->type = TYPE_STUB;
411 fdp = xmalloc(sizeof(*fdp));
412 odp->additional_data = fdp;
413 fdp->arg_types[0] = '\0';
414 strcpy( fdp->internal_name, STUB_CALLBACK );
419 static int ParseOrdinal(int ordinal)
423 if (ordinal >= MAX_ORDINALS)
425 fprintf(stderr, "%d: Ordinal number too large\n", Line);
428 if (ordinal > Limit) Limit = ordinal;
433 fprintf(stderr, "%d: Expected type after ordinal\n", Line);
437 if (strcmp(token, "byte") == 0)
438 return ParseVariable(ordinal, TYPE_BYTE);
439 else if (strcmp(token, "word") == 0)
440 return ParseVariable(ordinal, TYPE_WORD);
441 else if (strcmp(token, "long") == 0)
442 return ParseVariable(ordinal, TYPE_LONG);
443 else if (strcmp(token, "p") == 0)
444 return ParseExportFunction(ordinal, TYPE_PASCAL);
445 else if (strcmp(token, "pascal") == 0)
446 return ParseExportFunction(ordinal, TYPE_PASCAL);
447 else if (strcmp(token, "pascal16") == 0)
448 return ParseExportFunction(ordinal, TYPE_PASCAL_16);
449 else if (strcmp(token, "register") == 0)
450 return ParseExportFunction(ordinal, TYPE_REGISTER);
451 else if (strcmp(token, "stdcall") == 0)
452 return ParseExportFunction(ordinal, TYPE_STDCALL);
453 else if (strcmp(token, "cdecl") == 0)
454 return ParseExportFunction(ordinal, TYPE_CDECL);
455 else if (strcmp(token, "equate") == 0)
456 return ParseEquate(ordinal);
457 else if (strcmp(token, "return") == 0)
458 return ParseReturn(ordinal);
459 else if (strcmp(token, "stub") == 0)
460 return ParseStub(ordinal);
464 "%d: Expected type after ordinal, found '%s' instead\n",
470 static int ParseTopLevel(void)
474 while ((token = GetToken()) != NULL)
476 if (strcmp(token, "name") == 0)
478 strcpy(LowerDLLName, GetToken());
479 strlower(LowerDLLName);
481 strcpy(UpperDLLName, LowerDLLName);
482 strupper(UpperDLLName);
484 else if (strcmp(token, "id") == 0)
487 if (!IsNumberString(token))
489 fprintf(stderr, "%d: Expected number after id\n", Line);
495 else if (strcmp(token, "base") == 0)
498 if (!IsNumberString(token))
500 fprintf(stderr, "%d: Expected number after base\n", Line);
506 else if (IsNumberString(token))
511 ordinal = atoi(token);
512 if ((rv = ParseOrdinal(ordinal)) < 0)
518 "%d: Expected name, id, length or ordinal\n", Line);
527 static int OutputVariableCode( char *storage, ORDDEF *odp )
532 vdp = odp->additional_data;
533 printf( "\t.data\n" );
534 for (i = 0; i < vdp->n_values; i++)
537 printf( "\t%s\t", storage);
539 printf( "%d", vdp->values[i]);
541 if ((i & 7) == 7 || i == vdp->n_values - 1) printf( "\n");
545 printf( "\t.text\n" );
546 return vdp->n_values;
550 /*******************************************************************
553 * Build the in-memory representation of the module, and dump it
554 * as a byte stream into the assembly code.
556 static void BuildModule( int max_code_offset, int max_data_offset )
562 SEGTABLEENTRY *pSegment;
563 LOADEDFILEINFO *pFileInfo;
569 * LOADEDFILEINFO File information
570 * SEGTABLEENTRY Segment 1 (code)
571 * SEGTABLEENTRY Segment 2 (data)
572 * WORD[2] Resource table (empty)
573 * BYTE[2] Imported names (empty)
574 * BYTE[n] Resident names table
575 * BYTE[n] Entry table
578 buffer = xmalloc( 0x10000 );
580 pModule = (NE_MODULE *)buffer;
581 pModule->magic = NE_SIGNATURE;
584 pModule->flags = NE_FFLAGS_SINGLEDATA | NE_FFLAGS_BUILTIN | NE_FFLAGS_LIBMODULE;
586 pModule->heap_size = 0xffff;
587 pModule->stack_size = 0;
592 pModule->seg_count = 2;
593 pModule->modref_count = 0;
594 pModule->nrname_size = 0;
595 pModule->modref_table = 0;
596 pModule->nrname_fpos = 0;
597 pModule->moveable_entries = 0;
598 pModule->alignment = 0;
599 pModule->truetype = 0;
600 pModule->os_flags = NE_OSFLAGS_WINDOWS;
601 pModule->misc_flags = 0;
602 pModule->dlls_to_init = 0;
603 pModule->nrname_handle = 0;
604 pModule->min_swap_area = 0;
605 pModule->expected_version = 0x030a;
607 /* File information */
609 pFileInfo = (LOADEDFILEINFO *)(pModule + 1);
610 pModule->fileinfo = (int)pFileInfo - (int)pModule;
611 pFileInfo->length = sizeof(LOADEDFILEINFO) + strlen(UpperDLLName) + 3;
612 pFileInfo->fixed_media = 0;
613 pFileInfo->error = 0;
616 sprintf( pFileInfo->filename, "%s.DLL", UpperDLLName );
617 pstr = (char *)pFileInfo + pFileInfo->length + 1;
621 pSegment = (SEGTABLEENTRY *)pstr;
622 pModule->seg_table = (int)pSegment - (int)pModule;
623 pSegment->filepos = 0;
624 pSegment->size = max_code_offset;
626 pSegment->minsize = max_code_offset;
627 pSegment->selector = 0;
630 pModule->dgroup_entry = (int)pSegment - (int)pModule;
631 pSegment->filepos = 0;
632 pSegment->size = max_data_offset;
633 pSegment->flags = NE_SEGFLAGS_DATA;
634 pSegment->minsize = max_data_offset;
635 pSegment->selector = 0;
640 pword = (WORD *)pSegment;
641 pModule->res_table = (int)pword - (int)pModule;
645 /* Imported names table */
647 pstr = (char *)pword;
648 pModule->import_table = (int)pstr - (int)pModule;
652 /* Resident names table */
654 pModule->name_table = (int)pstr - (int)pModule;
655 /* First entry is module name */
656 *pstr = strlen(UpperDLLName );
657 strcpy( pstr + 1, UpperDLLName );
660 pstr += sizeof(WORD);
661 /* Store all ordinals */
662 odp = OrdinalDefinitions + 1;
663 for (i = 1; i <= Limit; i++, odp++)
665 if (!odp->export_name[0]) continue;
666 *pstr = strlen( odp->export_name );
667 strcpy( pstr + 1, odp->export_name );
668 strupper( pstr + 1 );
671 pstr += sizeof(WORD);
677 pModule->entry_table = (int)pstr - (int)pModule;
679 odp = OrdinalDefinitions + 1;
680 for (i = 1; i <= Limit; i++, odp++)
687 selector = 0; /* Invalid selector */
695 selector = 1; /* Code selector */
701 selector = 2; /* Data selector */
705 selector = 0xfe; /* Constant selector */
709 /* create a new bundle if necessary */
710 if (!bundle || (bundle[0] >= 254) || (bundle[1] != selector))
714 bundle[1] = selector;
722 *(WORD *)pstr = odp->offset;
723 pstr += sizeof(WORD);
728 /* Dump the module content */
730 printf( "\t.data\n" );
731 printf( "\t.globl " PREFIX "%s_Module_Start\n", UpperDLLName );
732 printf( PREFIX "%s_Module_Start:\n", UpperDLLName );
733 size = (int)pstr - (int)pModule;
734 for (i = 0, pstr = buffer; i < size; i++, pstr++)
736 if (!(i & 7)) printf( "\t.byte " );
737 printf( "%d%c", *pstr, ((i & 7) != 7) ? ',' : '\n' );
739 if (i & 7) printf( "0\n" );
740 printf( "\t.globl " PREFIX "%s_Module_End\n", UpperDLLName );
741 printf( PREFIX "%s_Module_End:\n", UpperDLLName );
745 static void BuildSpec32Files( char *specname )
753 SpecFp = fopen( specname, "r");
756 fprintf(stderr, "Could not open specification file, '%s'\n", specname);
762 printf( "/* File generated automatically, do not edit! */\n" );
763 printf( "#include <sys/types.h>\n");
764 printf( "#include <stdarg.h>\n");
765 printf( "#include \"windows.h\"\n");
766 printf( "#include \"dlls.h\"\n");
767 printf( "#include \"pe_image.h\"\n");
768 printf( "#include \"winerror.h\"\n");
769 printf( "#include \"relay32.h\"\n");
770 printf( "#include \"stddebug.h\"\n");
771 printf( "#include \"debug.h\"\n");
773 odp = OrdinalDefinitions;
774 for (i = 0; i <= Limit; i++, odp++)
777 fdp = odp->additional_data;
778 rdp = odp->additional_data;
784 printf( "int %s_%d()\n{\n\t", UpperDLLName, i);
785 printf( "RELAY32_Unimplemented(\"%s\",%d);\n", UpperDLLName, i);
786 printf( "\t/*NOTREACHED*/\n\treturn 0;\n}\n\n");
791 argc=strlen(fdp->arg_types);
793 if(odp->type == TYPE_STDCALL)
795 /* Output a function prototype with stdcall attribute */
796 printf( "void %s_%d(", UpperDLLName, i);
797 for(argno=0;argno<argc;argno++)
799 switch(fdp->arg_types[argno])
801 case 'p': printf( "void *");break;
802 case 'l': printf( "int ");break;
803 case '.': printf( "... ");varargs=argno;break;
805 fprintf(stderr, "Not supported argument type %c\n",
806 fdp->arg_types[argno]);
809 if(fdp->arg_types[argno]!='.') putchar( 'a'+argno );
810 if (argno!=argc-1) putchar( ',' );
812 printf( ") __attribute((stdcall));\n" );
815 printf( "void %s_%d(", UpperDLLName, i);
816 for(argno=0;argno<argc;argno++)
818 if(odp->type == TYPE_STDCALL) {
819 switch(fdp->arg_types[argno])
821 case 'p': printf( "void *");break;
822 case 'l': printf( "int ");break;
824 fprintf(stderr, "Not supported argument type %c\n",
825 fdp->arg_types[argno]);
829 switch(fdp->arg_types[argno])
831 case 'p': printf( "void *");break;
832 case 'l': printf( "int ");break;
833 case '.': printf( "... ");varargs=argno;break;
835 fprintf(stderr, "Not supported argument type %c\n",
836 fdp->arg_types[argno]);
840 if(fdp->arg_types[argno]!='.') putchar( 'a'+argno );
841 if (argno!=argc-1) putchar( ',' );
845 if (varargs) printf( "\tva_list valist;\n\n\tva_start(valist, %c);",
847 printf( "\tdprintf_relay(stddeb,\"Call %%s.%%s(");
848 for (argno=0;argno<argc;argno++)
849 if(fdp->arg_types[argno]!='.')
852 putchar( (fdp->arg_types[argno] == 'p') ? 'p' : 'x' );
853 if (argno < argc-1) putchar( ',' );
855 printf( ")\\n\", \"%s\", \"%s\"", UpperDLLName, odp->export_name);
856 for(argno=0;argno<argc;argno++)
857 if(fdp->arg_types[argno]!='.') printf( ",%c", 'a'+argno);
858 printf( ");\n\t%s(", fdp->internal_name );
859 for(argno=0;argno<argc;argno++)
861 if (fdp->arg_types[argno]=='.') printf("valist");
862 else putchar('a'+argno);
863 if (argno!=argc-1) putchar(',');
866 if(odp->type == TYPE_STDCALL) {
867 printf( "\t__asm__ __volatile__ (\"movl %%ebp,%%esp\");\n");
868 printf( "\t__asm__ __volatile__ (\"popl %%ebp\");\n");
869 printf( "\t__asm__ __volatile__ (\"addl $%d,%%esp\");\n", argc*4+4);
870 printf( "\t__asm__ __volatile__ (\"jmp -%d(%%esp)\");\n", argc*4+4);
875 printf( "void %s_%d()\n{\n\t", UpperDLLName, i);
876 printf( "RELAY32_DebugEnter(\"%s\",\"%s\");\n\t",
877 UpperDLLName, odp->export_name);
878 printf( "WIN32_LastError=ERROR_CALL_NOT_IMPLEMENTED;\n");
879 printf( "\t__asm__ __volatile__ (\"movl $%d,%%eax\");\n",
881 printf( "\t__asm__ __volatile__ (\"movl %%ebp,%%esp;popl %%ebp;"
882 "ret $%d\");\n}\n\n", rdp->arg_size);
885 fprintf(stderr,"build: function type %d not available for Win32\n",
891 printf( "static WIN32_function functions[%d+1]={\n", Limit);
893 odp = OrdinalDefinitions;
894 for (i = 0; i <= Limit; i++, odp++)
896 fdp = odp->additional_data;
897 rdp = odp->additional_data;
902 printf( "{0,%s_%d},\n",UpperDLLName, i);
908 printf( "{\"%s\",%s_%d},\n", odp->export_name, UpperDLLName, i);
911 fprintf(stderr, "build: implementation error: missing %d\n",
918 printf( "static WIN32_builtin dll={\"%s\",functions,%d,0};\n",
919 UpperDLLName, Limit+1);
921 printf( "void %s_Init(void)\n{\n",UpperDLLName);
922 printf( "\tdll.next=WIN32_builtin_list;\n");
923 printf( "\tWIN32_builtin_list=&dll;\n}");
927 static void BuildSpec16Files( char *specname )
933 int code_offset, data_offset;
935 SpecFp = fopen( specname, "r");
938 fprintf(stderr, "Could not open specification file, '%s'\n", specname);
944 printf( "/* File generated automatically; do not edit! */\n" );
945 printf( "\t.data\n" );
946 printf( "\t.globl " PREFIX "%s_Data_Start\n", UpperDLLName );
947 printf( PREFIX "%s_Data_Start:\n", UpperDLLName );
949 printf( "\t.4byte 0,0,0,0,0,0,0,0\n" );
951 printf( "\t.word 0,0,0,0,0,0,0,0\n" );
954 printf( "\t.text\n" );
955 printf( "\t.globl " PREFIX "%s_Code_Start\n", UpperDLLName );
956 printf( PREFIX "%s_Code_Start:\n", UpperDLLName );
959 odp = OrdinalDefinitions;
960 for (i = 0; i <= Limit; i++, odp++)
962 fdp = odp->additional_data;
963 rdp = odp->additional_data;
968 odp->offset = 0xffff;
972 odp->offset = (int)odp->additional_data & 0xffff;
976 printf( "/* %s.%d */\n", UpperDLLName, i);
977 odp->offset = data_offset;
978 data_offset += OutputVariableCode( ".byte", odp);
982 printf( "/* %s.%d */\n", UpperDLLName, i);
983 odp->offset = data_offset;
985 data_offset += 2 * OutputVariableCode( ".4byte", odp);
987 data_offset += 2 * OutputVariableCode( ".word", odp);
992 printf( "/* %s.%d */\n", UpperDLLName, i);
993 odp->offset = data_offset;
994 data_offset += 4 * OutputVariableCode( ".long", odp);
998 printf( "/* %s.%d */\n", UpperDLLName, i);
999 printf( "\tmovw $%d,%%ax\n", rdp->ret_value & 0xffff );
1000 printf( "\tmovw $%d,%%dx\n", (rdp->ret_value >> 16) & 0xffff);
1001 printf( "\t.byte 0x66\n");
1002 if (rdp->arg_size != 0)
1003 printf( "\tlret $%d\n", rdp->arg_size);
1005 printf( "\tlret\n");
1006 odp->offset = code_offset;
1007 code_offset += 10; /* Assembly code is 10 bytes long */
1008 if (rdp->arg_size != 0) code_offset += 2;
1013 case TYPE_PASCAL_16:
1015 printf( "/* %s.%d */\n", UpperDLLName, i);
1016 printf( "\tpushw %%bp\n" );
1017 printf( "\tpushl $0x%08x\n", (DLLId << 16) | i);
1018 printf( "\tpushl $" PREFIX "%s\n", fdp->internal_name );
1019 printf( "\tljmp $0x%04x, $" PREFIX "CallTo32_%s_%s\n\n",
1021 (odp->type == TYPE_REGISTER) ? "regs" :
1022 (odp->type == TYPE_PASCAL) ? "long" : "word",
1024 printf( "\tnop\n" );
1025 printf( "\tnop\n" );
1026 printf( "\tnop\n" );
1027 printf( "\tnop\n" );
1028 printf( "\tnop\n" );
1029 odp->offset = code_offset;
1030 code_offset += 24; /* Assembly code is 24 bytes long */
1034 fprintf( stderr, "build: Unknown function type; please report.\n");
1039 if (!code_offset) /* Make sure the code segment is not empty */
1041 printf( "\t.byte 0\n" );
1045 BuildModule( code_offset, data_offset );
1049 /*******************************************************************
1050 * BuildCall32LargeStack
1052 * Build the function used to switch to the original 32-bit stack
1053 * before calling a 32-bit function from 32-bit code. This is used for
1054 * functions that need a large stack, like X bitmaps functions.
1056 * The generated function has the following prototype:
1057 * int CallTo32_LargeStack( int (*func)(), int nbargs, ... )
1068 static void BuildCall32LargeStack(void)
1070 /* Function header */
1072 printf( "/**********\n" );
1073 printf( " * " PREFIX "CallTo32_LargeStack\n" );
1074 printf( " **********/\n" );
1075 printf( "\t.align 4\n" );
1076 printf( "\t.globl " PREFIX "CallTo32_LargeStack\n\n" );
1077 printf( PREFIX "CallTo32_LargeStack:\n" );
1081 printf( "\tpushl %%ebp\n" );
1082 printf( "\tmovl %%esp,%%ebp\n" );
1084 /* Save registers */
1086 printf( "\tpushl %%ecx\n" );
1087 printf( "\tpushl %%esi\n" );
1088 printf( "\tpushl %%edi\n" );
1090 /* Retrieve the original 32-bit stack pointer and switch to it if any */
1092 printf( "\tmovl " PREFIX "IF1632_Original32_esp, %%eax\n" );
1093 printf( "\torl %%eax,%%eax\n" );
1094 printf( "\tje no_orig_esp\n" );
1095 printf( "\tmovl %%eax,%%esp\n" );
1096 printf( "no_orig_esp:\n" );
1098 /* Transfer the arguments */
1100 printf( "\tmovl 12(%%ebp),%%ecx\n" );
1101 printf( "\torl %%ecx,%%ecx\n" );
1102 printf( "\tje no_args\n" );
1103 printf( "\tleal 16(%%ebp),%%esi\n" );
1104 printf( "\tshll $2,%%ecx\n" );
1105 printf( "\tsubl %%ecx,%%esp\n" );
1106 printf( "\tmovl %%esp,%%edi\n" );
1107 printf( "\tshrl $2,%%ecx\n" );
1108 printf( "\tcld\n" );
1109 printf( "\trep; movsl\n" );
1110 printf( "no_args:\n" );
1112 /* Call the function */
1114 printf( "\tcall 8(%%ebp)\n" );
1116 /* Switch back to the normal stack */
1118 printf( "\tleal -12(%%ebp),%%esp\n" );
1120 /* Restore registers and return */
1122 printf( "\tpopl %%edi\n" );
1123 printf( "\tpopl %%esi\n" );
1124 printf( "\tpopl %%ecx\n" );
1125 printf( "\tpopl %%ebp\n" );
1126 printf( "\tret\n" );
1130 /*******************************************************************
1131 * TransferArgs16To32
1133 * Get the arguments from the 16-bit stack and push them on the 32-bit stack.
1134 * The 16-bit stack layout is:
1142 static int TransferArgs16To32( char *args )
1144 int i, pos16, pos32;
1146 /* Save ebx first */
1148 printf( "\tpushl %%ebx\n" );
1150 /* Get the 32-bit stack pointer */
1152 printf( "\tmovl " PREFIX "IF1632_Saved32_esp,%%ebx\n" );
1154 /* Copy the arguments */
1156 pos16 = 6; /* skip bp and return address */
1159 for (i = strlen(args); i > 0; i--)
1164 case 'w': /* word */
1165 printf( "\tmovzwl %d(%%ebp),%%eax\n", pos16 );
1166 printf( "\tmovl %%eax,%d(%%ebx)\n", pos32 );
1170 case 's': /* s_word */
1171 printf( "\tmovswl %d(%%ebp),%%eax\n", pos16 );
1172 printf( "\tmovl %%eax,%d(%%ebx)\n", pos32 );
1176 case 'l': /* long */
1177 printf( "\tmovl %d(%%ebp),%%eax\n", pos16 );
1178 printf( "\tmovl %%eax,%d(%%ebx)\n", pos32 );
1183 /* Get the selector */
1184 printf( "\tmovw %d(%%ebp),%%ax\n", pos16 + 2 );
1185 /* Get the selector base */
1186 printf( "\tandl $0xfff8,%%eax\n" );
1187 printf( "\tmovl " PREFIX "ldt_copy(%%eax),%%eax\n" );
1188 printf( "\tmovl %%eax,%d(%%ebx)\n", pos32 );
1189 /* Add the offset */
1190 printf( "\tmovzwl %d(%%ebp),%%eax\n", pos16 );
1191 printf( "\taddl %%eax,%d(%%ebx)\n", pos32 );
1196 fprintf( stderr, "Unknown arg type '%c'\n", args[i-1] );
1202 printf( "\tpopl %%ebx\n" );
1204 return pos16 - 6; /* Return the size of the 16-bit args */
1208 /*******************************************************************
1211 * Build the context structure on the 32-bit stack.
1212 * The only valid registers in the context structure are:
1213 * eax, ebx, ecx, edx, esi, edi, ds, es, (some of the) flags
1215 static void BuildContext(void)
1217 /* Save ebx first */
1219 printf( "\tpushl %%ebx\n" );
1221 /* Get the 32-bit stack pointer */
1223 printf( "\tmovl " PREFIX "IF1632_Saved32_esp,%%ebx\n" );
1225 /* Store the registers */
1227 printf( "\tpopl %d(%%ebx)\n", CONTEXTOFFSET(sc_ebx) ); /* Get ebx from stack */
1228 printf( "\tmovl %%eax,%d(%%ebx)\n", CONTEXTOFFSET(sc_eax) );
1229 printf( "\tmovl %%ecx,%d(%%ebx)\n", CONTEXTOFFSET(sc_ecx) );
1230 printf( "\tmovl %%edx,%d(%%ebx)\n", CONTEXTOFFSET(sc_edx) );
1231 printf( "\tmovl %%esi,%d(%%ebx)\n", CONTEXTOFFSET(sc_esi) );
1232 printf( "\tmovl %%edi,%d(%%ebx)\n", CONTEXTOFFSET(sc_edi) );
1233 printf( "\tmovw -10(%%ebp),%%ax\n" ); /* Get saved ds from stack */
1234 printf( "\tmovw %%ax,%d(%%ebx)\n", CONTEXTOFFSET(sc_ds) );
1235 printf( "\tmovw -12(%%ebp),%%ax\n" ); /* Get saved es from stack */
1236 printf( "\tmovw %%ax,%d(%%ebx)\n", CONTEXTOFFSET(sc_es) );
1237 printf( "\tpushfl\n" );
1239 printf( "\tpopl %d(%%ebx)\n", CONTEXTOFFSET(sc_eflags) );
1241 printf( "\tpopl %d(%%ebx)\n", CONTEXTOFFSET(sc_efl) );
1246 /*******************************************************************
1249 * Restore the registers from the context structure
1251 static void RestoreContext(void)
1253 /* Get the 32-bit stack pointer */
1255 printf( "\tmovl " PREFIX "IF1632_Saved32_esp,%%ebx\n" );
1257 /* Restore the registers */
1259 printf( "\tmovl %d(%%ebx),%%ecx\n", CONTEXTOFFSET(sc_ecx) );
1260 printf( "\tmovl %d(%%ebx),%%edx\n", CONTEXTOFFSET(sc_edx) );
1261 printf( "\tmovl %d(%%ebx),%%esi\n", CONTEXTOFFSET(sc_esi) );
1262 printf( "\tmovl %d(%%ebx),%%edi\n", CONTEXTOFFSET(sc_edi) );
1263 printf( "\tpopl %%eax\n" ); /* Remove old ds and es from stack */
1264 printf( "\tpushw %d(%%ebx)\n", CONTEXTOFFSET(sc_ds) ); /* Push new ds */
1265 printf( "\tpushw %d(%%ebx)\n", CONTEXTOFFSET(sc_es) ); /* Push new es */
1267 printf( "\tpushl %d(%%ebx)\n", CONTEXTOFFSET(sc_eflags) );
1269 printf( "\tpushl %d(%%ebx)\n", CONTEXTOFFSET(sc_efl) );
1271 printf( "\tpopfl\n" );
1272 printf( "\tmovl %d(%%ebx),%%eax\n", CONTEXTOFFSET(sc_eax) );
1273 printf( "\tmovl %d(%%ebx),%%ebx\n", CONTEXTOFFSET(sc_ebx) );
1277 /*******************************************************************
1280 * Build a 32-bit callback function. The syntax of the function
1281 * profile is: type_xxxxx, where 'type' is one of 'regs', 'word' or
1282 * 'long' and each 'x' is an argument ('w'=word, 's'=signed word,
1283 * 'l'=long, 'p'=pointer).
1284 * For register functions, the arguments are ignored, but they are still
1285 * removed from the stack upon return.
1287 * Stack layout upon entry to the callback function:
1289 * (sp+14) first 16-bit arg
1293 * (sp+4) dll_id+ordinal (long)
1294 * (sp) entrypoint (long)
1297 static void BuildCall32Func( char *profile )
1302 char *args = profile + 5;
1304 /* Parse function type */
1306 if (!strncmp( "word_", profile, 5 )) short_ret = 1;
1307 else if (!strncmp( "regs_", profile, 5 )) reg_func = 1;
1308 else if (strncmp( "long_", profile, 5 ))
1310 fprintf( stderr, "Invalid function name '%s', ignored\n", profile );
1314 /* Function header */
1316 printf( "/**********\n" );
1317 printf( " * " PREFIX "CallTo32_%s\n", profile );
1318 printf( " **********/\n" );
1319 printf( "\t.align 4\n" );
1320 printf( "\t.globl " PREFIX "CallTo32_%s\n\n", profile );
1321 printf( PREFIX "CallTo32_%s:\n", profile );
1323 /* Setup bp to point to its copy on the stack */
1325 printf( "\tmovzwl %%sp,%%ebp\n" );
1326 printf( "\taddw $8,%%bp\n" );
1328 /* Save 16-bit ds and es */
1330 printf( "\tpushw %%ds\n" );
1331 printf( "\tpushw %%es\n" );
1333 /* Restore 32-bit ds and es */
1335 printf( "\tpushl $0x%04x%04x\n", WINE_DATA_SELECTOR, WINE_DATA_SELECTOR );
1336 printf( "\tpopw %%ds\n" );
1337 printf( "\tpopw %%es\n" );
1340 /* Save the 16-bit stack */
1342 printf( "\tpushw " PREFIX "IF1632_Saved16_sp\n" );
1343 printf( "\tpushw " PREFIX "IF1632_Saved16_ss\n" );
1345 printf("\tdata16\n");
1347 printf( "\tmovw %%ss," PREFIX "IF1632_Saved16_ss\n" );
1348 printf( "\tmovw %%sp," PREFIX "IF1632_Saved16_sp\n" );
1350 /* Transfer the arguments */
1352 if (reg_func) BuildContext();
1353 else if (*args) argsize = TransferArgs16To32( args );
1355 /* Get the address of the API function */
1357 printf( "\tmovl -8(%%ebp),%%eax\n" );
1359 /* If necessary, save %edx over the API function address */
1361 if (!reg_func && short_ret)
1362 printf( "\tmovl %%edx,-8(%%ebp)\n" );
1364 /* Switch to the 32-bit stack */
1366 printf( "\tmovl " PREFIX "IF1632_Saved32_esp,%%ebp\n" );
1367 printf( "\tpushw %%ds\n" );
1368 printf( "\tpopw %%ss\n" );
1369 printf( "\tleal -%d(%%ebp),%%esp\n",
1370 reg_func ? sizeof(struct sigcontext_struct) : 4 * strlen(args) );
1372 /* Setup %ebp to point to the previous stack frame (built by CallTo16) */
1374 printf( "\taddl $24,%%ebp\n" );
1376 /* Print the debug information before the call */
1380 printf( "\tpushl %%eax\n" );
1381 printf( "\tpushl $CALL32_Str_%s\n", profile );
1382 printf( "\tpushl $%d\n", reg_func ? 2 : (short_ret ? 1 : 0) );
1383 printf( "\tcall " PREFIX "RELAY_DebugCall32\n" );
1384 printf( "\tpopl %%eax\n" );
1385 printf( "\tpopl %%eax\n" );
1386 printf( "\tpopl %%eax\n" );
1389 /* Call the entry point */
1391 printf( "\tcall %%eax\n" );
1393 /* Print the debug information after the call */
1397 printf( "\tpushl %%eax\n" );
1398 printf( "\tpushl $%d\n", reg_func ? 2 : (short_ret ? 1 : 0) );
1399 printf( "\tcall " PREFIX "RELAY_DebugReturn\n" );
1400 printf( "\tpopl %%eax\n" );
1401 printf( "\tpopl %%eax\n" );
1404 /* Restore the 16-bit stack */
1407 printf( "\tdata16\n");
1409 printf( "\tmovw " PREFIX "IF1632_Saved16_ss,%%ss\n" );
1410 printf( "\tmovw " PREFIX "IF1632_Saved16_sp,%%sp\n" );
1412 printf( "\tdata16\n");
1414 printf( "\tpopw " PREFIX "IF1632_Saved16_ss\n" );
1416 printf( "\tdata16\n");
1418 printf( "\tpopw " PREFIX "IF1632_Saved16_sp\n" );
1422 /* Restore registers from the context structure */
1425 /* Calc the arguments size */
1439 fprintf( stderr, "Unknown arg type '%c'\n", *args );
1445 /* Restore ds and es */
1447 printf( "\tpopw %%es\n" );
1448 printf( "\tpopw %%ds\n" );
1450 /* Get the return value into dx:ax and clean up the stack */
1456 printf( "\tpopl %%edx\n" ); /* Restore %edx */
1457 printf( "\taddl $4,%%esp\n" ); /* Remove DLL id and ordinal */
1461 printf( "\tpushl %%eax\n" );
1462 printf( "\tpopw %%ax\n" );
1463 printf( "\tpopw %%dx\n" );
1464 /* Remove API entry point, DLL id and ordinal from the stack */
1465 printf( "\taddl $8,%%esp\n" );
1470 /* Remove API entry point, DLL id and ordinal from the stack, */
1471 /* but take care not to change the value of the carry flag. */
1473 printf( "\tpopl %%ebp\n" );
1474 printf( "\tpopl %%ebp\n" );
1479 printf( "\tpopw %%bp\n" );
1481 /* Remove the arguments and return */
1485 printf( "\t.byte 0x66\n" );
1486 printf( "\tlret $%d\n", argsize );
1490 printf( "\t.byte 0x66\n" );
1491 printf( "\tlret\n" );
1496 /*******************************************************************
1499 * Build a 16-bit callback function.
1501 * Stack frame of the callback function:
1505 * (ebp+16) 16-bit ds
1506 * (ebp+12) func to call
1507 * (ebp+8) code selector
1508 * (ebp+4) return address
1509 * (ebp) previous ebp
1511 * Prototypes for the CallTo16 functions:
1512 * extern WORD CallTo16_word_xxx( FARPROC func, WORD ds, args... );
1513 * extern LONG CallTo16_long_xxx( FARPROC func, WORD ds, args... );
1514 * extern void CallTo16_regs_( FARPROC func, WORD ds, WORD es, WORD bp,
1515 * WORD ax, WORD bx, WORD cx, WORD dx,
1516 * WORD si, WORD di );
1518 static void BuildCall16Func( char *profile )
1522 char *args = profile + 5;
1524 if (!strncmp( "word_", profile, 5 )) short_ret = 1;
1525 else if (!strncmp( "regs_", profile, 5 )) reg_func = short_ret = 1;
1526 else if (strncmp( "long_", profile, 5 ))
1528 fprintf( stderr, "Invalid function name '%s', ignored\n", profile );
1532 /* Function header */
1534 printf( "/**********\n" );
1535 printf( " * " PREFIX "CallTo16_%s\n", profile );
1536 printf( " **********/\n" );
1537 printf( "\t.align 4\n" );
1538 printf( "\t.globl " PREFIX "CallTo16_%s\n\n", profile );
1539 printf( PREFIX "CallTo16_%s:\n", profile );
1541 /* Push code selector before return address to simulate a lcall */
1543 printf( "\tpopl %%eax\n" );
1544 printf( "\tpushl $0x%04x\n", WINE_CODE_SELECTOR );
1545 printf( "\tpushl %%eax\n" );
1549 printf( "\tpushl %%ebp\n" );
1550 printf( "\tmovl %%esp,%%ebp\n" );
1552 /* Save the 32-bit registers */
1554 printf( "\tpushl %%ebx\n" );
1555 printf( "\tpushl %%ecx\n" );
1556 printf( "\tpushl %%edx\n" );
1557 printf( "\tpushl %%esi\n" );
1558 printf( "\tpushl %%edi\n" );
1560 /* Save the 32-bit stack */
1562 printf( "\tpushl " PREFIX "IF1632_Saved32_esp\n" );
1563 printf( "\tmovl %%esp," PREFIX "IF1632_Saved32_esp\n" );
1564 printf( "\tmovl %%ebp,%%ebx\n" );
1566 /* Print debugging info */
1570 /* Push the address of the first argument */
1571 printf( "\tmovl %%ebx,%%eax\n" );
1572 printf( "\taddl $12,%%eax\n" );
1573 printf( "\tpushl $%d\n", reg_func ? 8 : strlen(args) );
1574 printf( "\tpushl %%eax\n" );
1575 printf( "\tcall " PREFIX "RELAY_DebugCall16\n" );
1576 printf( "\tpopl %%eax\n" );
1577 printf( "\tpopl %%eax\n" );
1580 /* Switch to the 16-bit stack */
1583 printf("\tdata16\n");
1585 printf( "\tmovw " PREFIX "IF1632_Saved16_ss,%%ss\n" );
1586 printf( "\tmovw " PREFIX "IF1632_Saved16_sp,%%sp\n" );
1588 /* Transfer the arguments */
1592 /* Get the registers. ebx is handled later on. */
1593 printf( "\tpushw 20(%%ebx)\n" );
1594 printf( "\tpopw %%es\n" );
1595 printf( "\tmovl 24(%%ebx),%%ebp\n" );
1596 printf( "\tmovl 28(%%ebx),%%eax\n" );
1597 printf( "\tmovl 36(%%ebx),%%ecx\n" );
1598 printf( "\tmovl 40(%%ebx),%%edx\n" );
1599 printf( "\tmovl 44(%%ebx),%%esi\n" );
1600 printf( "\tmovl 48(%%ebx),%%edi\n" );
1602 else /* not a register function */
1604 int pos = 20; /* first argument position */
1606 /* Make %bp point to the previous stackframe (built by CallTo32) */
1607 printf( "\tmovw %%sp,%%bp\n" );
1608 printf( "\taddw $16,%%bp\n" );
1614 case 'w': /* word */
1615 printf( "\tpushw %d(%%ebx)\n", pos );
1617 case 'l': /* long */
1618 printf( "\tpushl %d(%%ebx)\n", pos );
1625 /* Push the return address */
1627 printf( "\tpushl " PREFIX "CALL16_RetAddr_%s\n",
1628 short_ret ? "word" : "long" );
1630 /* Push the called routine address */
1632 printf( "\tpushl 12(%%ebx)\n" );
1634 /* Get the 16-bit ds */
1638 printf( "\tpushw 16(%%ebx)\n" );
1639 printf( "\tmovl 32(%%ebx),%%ebx\n" ); /*Get ebx from the 32-bit stack*/
1640 printf( "\tpopw %%ds\n" );
1644 /* Set ax equal to ds for window procedures */
1645 printf( "\tmovw 16(%%ebx),%%ax\n" );
1647 printf( "\tdata16\n");
1649 printf( "\tmovw %%ax,%%ds\n" );
1652 /* Jump to the called routine */
1654 printf( "\t.byte 0x66\n" );
1655 printf( "\tlret\n" );
1659 /*******************************************************************
1662 * Build the return code for 16-bit callbacks
1664 static void BuildRet16Func()
1666 printf( "\t.globl " PREFIX "CALL16_Ret_word\n" );
1667 printf( "\t.globl " PREFIX "CALL16_Ret_long\n" );
1669 /* Put return value into eax */
1671 printf( PREFIX "CALL16_Ret_long:\n" );
1672 printf( "\tpushw %%dx\n" );
1673 printf( "\tpushw %%ax\n" );
1674 printf( "\tpopl %%eax\n" );
1675 printf( PREFIX "CALL16_Ret_word:\n" );
1677 /* Restore 32-bit segment registers */
1679 printf( "\tmovw $0x%04x,%%bx\n", WINE_DATA_SELECTOR );
1681 printf( "\tdata16\n");
1683 printf( "\tmovw %%bx,%%ds\n" );
1685 printf( "\tdata16\n");
1687 printf( "\tmovw %%bx,%%es\n" );
1689 printf( "\tdata16\n");
1691 printf( "\tmovw %%bx,%%ss\n" );
1693 /* Restore the 32-bit stack */
1695 printf( "\tmovl " PREFIX "IF1632_Saved32_esp,%%esp\n" );
1696 printf( "\tpopl " PREFIX "IF1632_Saved32_esp\n" );
1698 /* Restore the 32-bit registers */
1700 printf( "\tpopl %%edi\n" );
1701 printf( "\tpopl %%esi\n" );
1702 printf( "\tpopl %%edx\n" );
1703 printf( "\tpopl %%ecx\n" );
1704 printf( "\tpopl %%ebx\n" );
1706 /* Return to caller */
1708 printf( "\tpopl %%ebp\n" );
1709 printf( "\tlret\n" );
1711 /* Declare the return address variables */
1713 printf( "\t.data\n" );
1714 printf( "\t.globl " PREFIX "CALL16_RetAddr_word\n" );
1715 printf( "\t.globl " PREFIX "CALL16_RetAddr_long\n" );
1716 printf( PREFIX "CALL16_RetAddr_word:\t.long 0\n" );
1717 printf( PREFIX "CALL16_RetAddr_long:\t.long 0\n" );
1718 printf( "\t.text\n" );
1722 static void usage(void)
1724 fprintf(stderr, "usage: build -spec SPECNAMES\n"
1725 " build -call32 FUNCTION_PROFILES\n"
1726 " build -call16 FUNCTION_PROFILES\n" );
1731 int main(int argc, char **argv)
1735 if (argc <= 2) usage();
1737 if (!strcmp( argv[1], "-spec16" ))
1739 for (i = 2; i < argc; i++) BuildSpec16Files( argv[i] );
1741 else if (!strcmp( argv[1], "-spec32" ))
1743 for (i = 2; i < argc; i++) BuildSpec32Files( argv[i] );
1745 else if (!strcmp( argv[1], "-call32" )) /* 32-bit callbacks */
1749 printf( "/* File generated automatically. Do not edit! */\n\n" );
1750 printf( "\t.text\n" );
1752 /* Build the 32-bit large stack callback */
1754 BuildCall32LargeStack();
1756 /* Build the callback functions */
1758 for (i = 2; i < argc; i++) BuildCall32Func( argv[i] );
1760 /* Output the argument debugging strings */
1764 printf( "/* Argument strings */\n" );
1765 for (i = 2; i < argc; i++)
1767 printf( "CALL32_Str_%s:\n", argv[i] );
1768 printf( "\t.ascii \"%s\\0\"\n", argv[i] + 5 );
1772 else if (!strcmp( argv[1], "-call16" )) /* 16-bit callbacks */
1776 printf( "/* File generated automatically. Do not edit! */\n\n" );
1777 printf( "\t.text\n" );
1778 printf( "\t.globl " PREFIX "CALL16_Start\n" );
1779 printf( PREFIX "CALL16_Start:\n" );
1781 /* Build the callback functions */
1783 for (i = 2; i < argc; i++) BuildCall16Func( argv[i] );
1785 /* Output the 16-bit return code */
1789 printf( "\t.globl " PREFIX "CALL16_End\n" );
1790 printf( PREFIX "CALL16_End:\n" );