[ia32rtools.git] / tools / mkbridge.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "my_assert.h"
#include "my_str.h"

#define ARRAY_SIZE(x) (sizeof(x) / sizeof(x[0]))
#define IS(w, y) !strcmp(w, y)

static int find_protostr(char *dst, size_t dlen, FILE *fhdr,
	const char *sym, int *pline)
{
	int line = 0;
	char *p;

	rewind(fhdr);

	while (fgets(dst, dlen, fhdr))
	{
		line++;
		if (strstr(dst, sym) != NULL)
			break;
	}
	*pline = line;

	if (feof(fhdr))
		return -1;

	p = dst + strlen(dst);
	for (p--; p > dst && my_isblank(*p); --p)
		*p = 0;

	return 0;
}

static int get_regparm(char *dst, size_t dlen, char *p)
{
	int i, o;

	if (*p != '<')
		return 0;

	for (o = 0, i = 1; o < dlen; i++) {
		if (p[i] == 0)
			return 0;
		if (p[i] == '>')
			break;
		dst[o++] = p[i];
	}
	dst[o] = 0;
	return i + 1;
}

// hmh..
static const char *known_types[] = {
	"const void *",
	"void *",
	"char *",
	"FILE *",
	"unsigned __int8",
	"unsigned __int16",
	"unsigned int",
	"signed int",
	"char",
	"__int8",
	"__int16",
	"int",
	"bool",
	"void",
	"BYTE",
	"WORD",
	"DWORD",
	"HMODULE",
	"HANDLE",
	"HWND",
	"LPCSTR",
	"size_t",
};

static int check_type(const char *name)
{
	int i, l;

	for (i = 0; i < ARRAY_SIZE(known_types); i++) {
		l = strlen(known_types[i]);
		if (strncmp(known_types[i], name, l) == 0)
			return l;
	}

	return 0;
}

/* args are always expanded to 32bit */
static const char *map_reg(const char *reg)
{
	const char *regs_f[] = { "eax", "ebx", "ecx", "edx", "esi", "edi" };
	const char *regs_w[] = { "ax",  "bx",  "cx",  "dx",  "si",  "di" };
	const char *regs_b[] = { "al",  "bl",  "cl",  "dl" };
	int i;

	for (i = 0; i < ARRAY_SIZE(regs_w); i++)
		if (IS(reg, regs_w[i]))
			return regs_f[i];

	for (i = 0; i < ARRAY_SIZE(regs_b); i++)
		if (IS(reg, regs_b[i]))
			return regs_f[i];

	return reg;
}

static const char *hdrfn;
static int pline = 0;

static int parse_protostr(char *protostr, char **reglist, int *cnt_out,
	int *is_stdcall)
{
	char regparm[16];
	char buf[256];
	char cconv[32];
	int xarg = 0;
	int ret;
	char *p;

	p = protostr;
	if (p[0] == '/' && p[1] == '/') {
		//printf("warning: decl for sym '%s' is commented out\n", sym);
		p = sskip(p + 2);
	}

	ret = check_type(p);
	if (ret <= 0) {
		printf("%s:%d:%ld: unhandled return in '%s'\n",
				hdrfn, pline, (p - protostr) + 1, protostr);
		return 1;
	}
	p += ret;
	p = sskip(p);

	p = next_word(cconv, sizeof(cconv), p);
	p = sskip(p);
	if (cconv[0] == 0) {
		printf("%s:%d:%ld: cconv missing\n",
			hdrfn, pline, (p - protostr) + 1);
		return 1;
	}
	if      (IS(cconv, "__cdecl"))
		*is_stdcall = 0;
	else if (IS(cconv, "__stdcall"))
		*is_stdcall = 1;
	else if (IS(cconv, "__fastcall"))
		*is_stdcall = 1;
	else if (IS(cconv, "__thiscall"))
		*is_stdcall = 1;
	else if (IS(cconv, "__userpurge"))
		*is_stdcall = 1; // in all cases seen..
	else if (IS(cconv, "__usercall"))
		*is_stdcall = 0; // ..or is it?
	else {
		printf("%s:%d:%ld: unhandled cconv: '%s'\n",
			hdrfn, pline, (p - protostr) + 1, cconv);
		return 1;
	}

	p = next_idt(buf, sizeof(buf), p);
	p = sskip(p);
	if (buf[0] == 0) {
		printf("%s:%d:%ld: func name missing\n",
				hdrfn, pline, (p - protostr) + 1);
		return 1;
	}

	ret = get_regparm(regparm, sizeof(regparm), p);
	if (ret > 0) {
		if (!IS(regparm, "eax") && !IS(regparm, "ax")
		 && !IS(regparm, "al"))
		{
			printf("%s:%d:%ld: bad regparm: %s\n",
				hdrfn, pline, (p - protostr) + 1, regparm);
			return 1;
		}
		p += ret;
		p = sskip(p);
	}

	if (*p != '(') {
		printf("%s:%d:%ld: '(' expected, got '%c'\n",
				hdrfn, pline, (p - protostr) + 1, *p);
		return 1;
	}
	p++;

	while (1) {
		p = sskip(p);
		if (*p == ')')
			break;
		if (*p == ',')
			p = sskip(p + 1);

		xarg++;

		ret = check_type(p);
		if (ret <= 0) {
			printf("%s:%d:%ld: unhandled type for arg%d\n",
					hdrfn, pline, (p - protostr) + 1, xarg);
			return 1;
		}
		p += ret;
		p = sskip(p);

		p = next_idt(buf, sizeof(buf), p);
		p = sskip(p);
#if 0
		if (buf[0] == 0) {
			printf("%s:%d:%ld: idt missing for arg%d\n",
					hdrfn, pline, (p - protostr) + 1, xarg);
			return 1;
		}
#endif
		reglist[xarg - 1] = NULL;

		ret = get_regparm(regparm, sizeof(regparm), p);
		if (ret > 0) {
			p += ret;
			p = sskip(p);

			reglist[xarg - 1] = strdup(map_reg(regparm));
		}
	}

	if (xarg > 0 && (IS(cconv, "__fastcall") || IS(cconv, "__thiscall"))) {
		if (reglist[0] != NULL) {
			printf("%s:%d: %s with arg1 spec %s?\n",
				hdrfn, pline, cconv, reglist[0]);
		}
		reglist[0] = strdup("ecx");
	}

	if (xarg > 1 && IS(cconv, "__fastcall")) {
		if (reglist[1] != NULL) {
			printf("%s:%d: %s with arg2 spec %s?\n",
				hdrfn, pline, cconv, reglist[1]);
		}
		reglist[1] = strdup("edx");
	}

	*cnt_out = xarg;

	return 0;
}

static int is_x86_reg_saved(const char *reg)
{
	static const char *nosave_regs[] = { "eax", "edx", "ecx" };
	int nosave = 0;
	int r;

	for (r = 0; r < ARRAY_SIZE(nosave_regs); r++)
		if (strcmp(reg, nosave_regs[r]) == 0)
			nosave = 1;

	return !nosave;
}

static void out_toasm_x86(FILE *f, char *sym, char *reg_list[], int reg_cnt,
	int is_stdcall)
{
	int have_normal = 0; // normal args
	int have_regs = 0;
	int must_save = 0;
	int sarg_ofs = 1; // stack offset to args, in DWORDs
	int args_repushed = 0;
	int i;

	for (i = 0; i < reg_cnt; i++) {
		if (reg_list[i] == NULL) {
			have_normal++;
			continue;
		}

		have_regs++;
		must_save |= is_x86_reg_saved(reg_list[i]);
	}

	fprintf(f, ".global _%s\n", sym);
	fprintf(f, "_%s:\n", sym);

	if (!have_regs && !is_stdcall) {
		fprintf(f, "\tjmp %s\n\n", sym);
		return;
	}

	if (!have_normal && !must_save && !is_stdcall) {
		// load arg regs
		for (i = 0; i < reg_cnt; i++) {
			fprintf(f, "\tmovl %d(%%esp), %%%s\n",
				(i + sarg_ofs) * 4, reg_list[i]);
		}
		fprintf(f, "\tjmp %s\n\n", sym);
		return;
	}

	// save the regs
	for (i = 0; i < reg_cnt; i++) {
		if (reg_list[i] != NULL && is_x86_reg_saved(reg_list[i])) {
			fprintf(f, "\tpushl %%%s\n", reg_list[i]);
			sarg_ofs++;
		}
	}

	// reconstruct arg stack
	for (i = reg_cnt - 1; i >= 0; i--) {
		if (reg_list[i] == NULL) {
			fprintf(f, "\tmovl %d(%%esp), %%eax\n",
				(i + sarg_ofs) * 4);
			fprintf(f, "\tpushl %%eax\n");
			sarg_ofs++;
			args_repushed++;
		}
	}
	my_assert(args_repushed, have_normal);

	// load arg regs
	for (i = 0; i < reg_cnt; i++) {
		if (reg_list[i] != NULL) {
			fprintf(f, "\tmovl %d(%%esp), %%%s\n",
				(i + sarg_ofs) * 4, reg_list[i]);
		}
	}

	fprintf(f, "\n\t# %s\n", is_stdcall ? "__stdcall" : "__cdecl");
	fprintf(f, "\tcall %s\n\n", sym);

	if (args_repushed && !is_stdcall)
		fprintf(f, "\tadd $%d,%%esp\n", args_repushed * 4);

	// restore regs
	for (i = reg_cnt - 1; i >= 0; i--) {
		if (reg_list[i] != NULL && is_x86_reg_saved(reg_list[i]))
			fprintf(f, "\tpopl %%%s\n", reg_list[i]);
	}

	fprintf(f, "\tret\n\n");
}

static void out_fromasm_x86(FILE *f, char *sym, char *reg_list[], int reg_cnt,
	int is_stdcall)
{
	int have_normal = 0; // normal args
	int have_regs = 0;
	int sarg_ofs = 1; // stack offset to args, in DWORDs
	int stack_args;
	int i;

	for (i = 0; i < reg_cnt; i++) {
		if (reg_list[i] == NULL) {
			have_normal++;
			continue;
		}

		have_regs++;
	}

	fprintf(f, "# %s\n", is_stdcall ? "__stdcall" : "__cdecl");
	fprintf(f, ".global %s\n", sym);
	fprintf(f, "%s:\n", sym);

	if (!have_regs && !is_stdcall) {
		fprintf(f, "\tjmp _%s\n\n", sym);
		return;
	}

	fprintf(f, "\tpushl %%edx\n"); // just in case..
	sarg_ofs++;

	// construct arg stack
	stack_args = have_normal;
	for (i = reg_cnt - 1; i >= 0; i--) {
		if (reg_list[i] == NULL) {
			fprintf(f, "\tmovl %d(%%esp), %%edx\n",
				(sarg_ofs + stack_args - 1) * 4);
			fprintf(f, "\tpushl %%edx\n");
			stack_args--;
		}
		else {
			fprintf(f, "\tpushl %%%s\n", reg_list[i]);
		}
		sarg_ofs++;
	}

	// no worries about calling conventions - always __cdecl
	fprintf(f, "\n\tcall _%s\n\n", sym);

	if (sarg_ofs > 2)
		fprintf(f, "\tadd $%d,%%esp\n", (sarg_ofs - 2) * 4);

	fprintf(f, "\tpopl %%edx\n");

	if (is_stdcall && have_normal)
		fprintf(f, "\tret $%d\n\n", have_normal * 4);
	else
		fprintf(f, "\tret\n\n");
}

static void free_reglist(char *reg_list[], int reg_cnt)
{
	int i;

	for (i = 0; i < reg_cnt; i++) {
		if (reg_list[i] == NULL) {
			free(reg_list[i]);
			reg_list[i] = NULL;
		}
	}
}

int main(int argc, char *argv[])
{
	FILE *fout, *fsyms_to, *fsyms_from, *fhdr;
	char protostr[256];
	char line[256];
	char sym[256];
	char *reg_list[16];
	int is_stdcall = 0;
	int reg_cnt = 0;
	int ret;

	if (argc != 5) {
		printf("usage:\n%s <bridge.s> <toasm_symf> <fromasm_symf> <hdrf>\n",
			argv[0]);
		return 1;
	}

	hdrfn = argv[4];
	fhdr = fopen(hdrfn, "r");
	my_assert_not(fhdr, NULL);

	fsyms_from = fopen(argv[3], "r");
	my_assert_not(fsyms_from, NULL);

	fsyms_to = fopen(argv[2], "r");
	my_assert_not(fsyms_to, NULL);

	fout = fopen(argv[1], "w");
	my_assert_not(fout, NULL);

	fprintf(fout, ".text\n\n");
	fprintf(fout, "# to asm\n\n");

	while (fgets(line, sizeof(line), fsyms_to))
	{
		next_word(sym, sizeof(sym), line);
		if (sym[0] == 0 || sym[0] == ';' || sym[0] == '#')
			continue;

		ret = find_protostr(protostr, sizeof(protostr), fhdr,
			sym, &pline);
		if (ret != 0) {
			printf("%s: sym '%s' is missing\n",
				hdrfn, sym);
			goto out;
		}

		ret = parse_protostr(protostr, reg_list, &reg_cnt, &is_stdcall);
		if (ret)
			goto out;

		out_toasm_x86(fout, sym, reg_list, reg_cnt, is_stdcall);
		free_reglist(reg_list, reg_cnt);
	}

	fprintf(fout, "# from asm\n\n");

	while (fgets(line, sizeof(line), fsyms_from))
	{
		next_word(sym, sizeof(sym), line);
		if (sym[0] == 0 || sym[0] == ';' || sym[0] == '#')
			continue;

		ret = find_protostr(protostr, sizeof(protostr), fhdr,
			sym, &pline);
		if (ret != 0) {
			printf("%s: sym '%s' is missing\n",
				hdrfn, sym);
			goto out;
		}

		ret = parse_protostr(protostr, reg_list, &reg_cnt, &is_stdcall);
		if (ret)
			goto out;

		out_fromasm_x86(fout, sym, reg_list, reg_cnt, is_stdcall);
		free_reglist(reg_list, reg_cnt);
	}

	ret = 0;
out:
	fclose(fout);
	fclose(fsyms_to);
	fclose(fsyms_from);
	fclose(fhdr);
	if (ret)
		remove(argv[1]);

	return ret;
}
Commit	Line	Data
57e4efe9	1	#include <stdio.h>
	2	#include <stdlib.h>
	3	#include <string.h>
	4
	5	#include "my_assert.h"
	6	#include "my_str.h"
	7
232aca37	8	#define ARRAY_SIZE(x) (sizeof(x) / sizeof(x[0]))
3e52f54c	9	#define IS(w, y) !strcmp(w, y)
232aca37	10
57e4efe9	11	static int find_protostr(char dst, size_t dlen, FILE fhdr,
	12	const char sym, int pline)
	13	{
	14	int line = 0;
	15	char *p;
	16
232aca37	17	rewind(fhdr);
232aca37	18
57e4efe9	19	while (fgets(dst, dlen, fhdr))
	20	{
	21	line++;
	22	if (strstr(dst, sym) != NULL)
	23	break;
	24	}
	25	*pline = line;
	26
	27	if (feof(fhdr))
	28	return -1;
	29
	30	p = dst + strlen(dst);
	31	for (p--; p > dst && my_isblank(*p); --p)
	32	*p = 0;
	33
	34	return 0;
	35	}
	36
	37	static int get_regparm(char dst, size_t dlen, char p)
	38	{
	39	int i, o;
	40
	41	if (*p != '<')
	42	return 0;
	43
	44	for (o = 0, i = 1; o < dlen; i++) {
	45	if (p[i] == 0)
	46	return 0;
	47	if (p[i] == '>')
	48	break;
	49	dst[o++] = p[i];
	50	}
	51	dst[o] = 0;
	52	return i + 1;
	53	}
	54
232aca37	55	// hmh..
57e4efe9	56	static const char *known_types[] = {
3e52f54c	57	"const void *",
	58	"void *",
	59	"char *",
	60	"FILE *",
232aca37	61	"unsigned __int8",
3e52f54c	62	"unsigned __int16",
232aca37	63	"unsigned int",
3e52f54c	64	"signed int",
	65	"char",
	66	"__int8",
	67	"__int16",
	68	"int",
	69	"bool",
57e4efe9	70	"void",
232aca37	71	"BYTE",
232aca37	72	"WORD",
57e4efe9	73	"DWORD",
	74	"HMODULE",
	75	"HANDLE",
	76	"HWND",
232aca37	77	"LPCSTR",
232aca37	78	"size_t",
57e4efe9	79	};
	80
	81	static int check_type(const char *name)
	82	{
	83	int i, l;
	84
232aca37	85	for (i = 0; i < ARRAY_SIZE(known_types); i++) {
57e4efe9	86	l = strlen(known_types[i]);
	87	if (strncmp(known_types[i], name, l) == 0)
	88	return l;
	89	}
	90
	91	return 0;
	92	}
	93
3e52f54c	94	/* args are always expanded to 32bit */
	95	static const char map_reg(const char reg)
	96	{
	97	const char *regs_f[] = { "eax", "ebx", "ecx", "edx", "esi", "edi" };
	98	const char *regs_w[] = { "ax", "bx", "cx", "dx", "si", "di" };
	99	const char *regs_b[] = { "al", "bl", "cl", "dl" };
	100	int i;
	101
	102	for (i = 0; i < ARRAY_SIZE(regs_w); i++)
	103	if (IS(reg, regs_w[i]))
	104	return regs_f[i];
	105
	106	for (i = 0; i < ARRAY_SIZE(regs_b); i++)
	107	if (IS(reg, regs_b[i]))
	108	return regs_f[i];
	109
	110	return reg;
	111	}
	112
232aca37	113	static const char *hdrfn;
	114	static int pline = 0;
	115
	116	static int parse_protostr(char protostr, char reglist, int cnt_out,
	117	int *is_stdcall)
	118	{
	119	char regparm[16];
	120	char buf[256];
3e52f54c	121	char cconv[32];
232aca37	122	int xarg = 0;
	123	int ret;
	124	char *p;
	125
	126	p = protostr;
	127	if (p[0] == '/' && p[1] == '/') {
	128	//printf("warning: decl for sym '%s' is commented out\n", sym);
	129	p = sskip(p + 2);
	130	}
	131
	132	ret = check_type(p);
	133	if (ret <= 0) {
	134	printf("%s:%d:%ld: unhandled return in '%s'\n",
	135	hdrfn, pline, (p - protostr) + 1, protostr);
	136	return 1;
	137	}
	138	p += ret;
	139	p = sskip(p);
	140
3e52f54c	141	p = next_word(cconv, sizeof(cconv), p);
232aca37	142	p = sskip(p);
3e52f54c	143	if (cconv[0] == 0) {
232aca37	144	printf("%s:%d:%ld: cconv missing\n",
	145	hdrfn, pline, (p - protostr) + 1);
	146	return 1;
	147	}
3e52f54c	148	if (IS(cconv, "__cdecl"))
232aca37	149	*is_stdcall = 0;
3e52f54c	150	else if (IS(cconv, "__stdcall"))
	151	*is_stdcall = 1;
	152	else if (IS(cconv, "__fastcall"))
	153	*is_stdcall = 1;
	154	else if (IS(cconv, "__thiscall"))
232aca37	155	*is_stdcall = 1;
3e52f54c	156	else if (IS(cconv, "__userpurge"))
232aca37	157	*is_stdcall = 1; // in all cases seen..
3e52f54c	158	else if (IS(cconv, "__usercall"))
232aca37	159	*is_stdcall = 0; // ..or is it?
232aca37	160	else {
232aca37	161	printf("%s:%d:%ld: unhandled cconv: '%s'\n",
3e52f54c	162	hdrfn, pline, (p - protostr) + 1, cconv);
232aca37	163	return 1;
	164	}
	165
	166	p = next_idt(buf, sizeof(buf), p);
	167	p = sskip(p);
	168	if (buf[0] == 0) {
	169	printf("%s:%d:%ld: func name missing\n",
	170	hdrfn, pline, (p - protostr) + 1);
	171	return 1;
	172	}
	173
	174	ret = get_regparm(regparm, sizeof(regparm), p);
	175	if (ret > 0) {
3e52f54c	176	if (!IS(regparm, "eax") && !IS(regparm, "ax")
3e52f54c	177	&& !IS(regparm, "al"))
232aca37	178	{
	179	printf("%s:%d:%ld: bad regparm: %s\n",
	180	hdrfn, pline, (p - protostr) + 1, regparm);
	181	return 1;
	182	}
	183	p += ret;
	184	p = sskip(p);
	185	}
	186
	187	if (*p != '(') {
	188	printf("%s:%d:%ld: '(' expected, got '%c'\n",
	189	hdrfn, pline, (p - protostr) + 1, *p);
	190	return 1;
	191	}
	192	p++;
	193
	194	while (1) {
	195	p = sskip(p);
	196	if (*p == ')')
	197	break;
	198	if (*p == ',')
	199	p = sskip(p + 1);
	200
	201	xarg++;
	202
	203	ret = check_type(p);
	204	if (ret <= 0) {
	205	printf("%s:%d:%ld: unhandled type for arg%d\n",
	206	hdrfn, pline, (p - protostr) + 1, xarg);
	207	return 1;
	208	}
	209	p += ret;
	210	p = sskip(p);
	211
	212	p = next_idt(buf, sizeof(buf), p);
	213	p = sskip(p);
	214	#if 0
	215	if (buf[0] == 0) {
	216	printf("%s:%d:%ld: idt missing for arg%d\n",
	217	hdrfn, pline, (p - protostr) + 1, xarg);
	218	return 1;
	219	}
	220	#endif
	221	reglist[xarg - 1] = NULL;
	222
	223	ret = get_regparm(regparm, sizeof(regparm), p);
	224	if (ret > 0) {
	225	p += ret;
	226	p = sskip(p);
	227
3e52f54c	228	reglist[xarg - 1] = strdup(map_reg(regparm));
	229	}
	230	}
	231
	232	if (xarg > 0 && (IS(cconv, "__fastcall") \|\| IS(cconv, "__thiscall"))) {
	233	if (reglist[0] != NULL) {
	234	printf("%s:%d: %s with arg1 spec %s?\n",
	235	hdrfn, pline, cconv, reglist[0]);
232aca37	236	}
3e52f54c	237	reglist[0] = strdup("ecx");
	238	}
	239
	240	if (xarg > 1 && IS(cconv, "__fastcall")) {
	241	if (reglist[1] != NULL) {
	242	printf("%s:%d: %s with arg2 spec %s?\n",
	243	hdrfn, pline, cconv, reglist[1]);
	244	}
	245	reglist[1] = strdup("edx");
232aca37	246	}
	247
	248	*cnt_out = xarg;
	249
	250	return 0;
	251	}
	252
	253	static int is_x86_reg_saved(const char *reg)
	254	{
	255	static const char *nosave_regs[] = { "eax", "edx", "ecx" };
	256	int nosave = 0;
	257	int r;
	258
	259	for (r = 0; r < ARRAY_SIZE(nosave_regs); r++)
	260	if (strcmp(reg, nosave_regs[r]) == 0)
	261	nosave = 1;
	262
	263	return !nosave;
	264	}
	265
	266	static void out_toasm_x86(FILE f, char sym, char *reg_list[], int reg_cnt,
	267	int is_stdcall)
	268	{
	269	int have_normal = 0; // normal args
	270	int have_regs = 0;
	271	int must_save = 0;
	272	int sarg_ofs = 1; // stack offset to args, in DWORDs
	273	int args_repushed = 0;
	274	int i;
	275
	276	for (i = 0; i < reg_cnt; i++) {
	277	if (reg_list[i] == NULL) {
	278	have_normal++;
	279	continue;
	280	}
	281
	282	have_regs++;
	283	must_save \|= is_x86_reg_saved(reg_list[i]);
	284	}
	285
a51421fa	286	fprintf(f, ".global _%s\n", sym);
a51421fa	287	fprintf(f, "_%s:\n", sym);
232aca37	288
	289	if (!have_regs && !is_stdcall) {
	290	fprintf(f, "\tjmp %s\n\n", sym);
	291	return;
	292	}
	293
	294	if (!have_normal && !must_save && !is_stdcall) {
	295	// load arg regs
	296	for (i = 0; i < reg_cnt; i++) {
	297	fprintf(f, "\tmovl %d(%%esp), %%%s\n",
	298	(i + sarg_ofs) * 4, reg_list[i]);
	299	}
	300	fprintf(f, "\tjmp %s\n\n", sym);
	301	return;
	302	}
	303
	304	// save the regs
	305	for (i = 0; i < reg_cnt; i++) {
	306	if (reg_list[i] != NULL && is_x86_reg_saved(reg_list[i])) {
	307	fprintf(f, "\tpushl %%%s\n", reg_list[i]);
	308	sarg_ofs++;
	309	}
	310	}
	311
	312	// reconstruct arg stack
	313	for (i = reg_cnt - 1; i >= 0; i--) {
	314	if (reg_list[i] == NULL) {
	315	fprintf(f, "\tmovl %d(%%esp), %%eax\n",
	316	(i + sarg_ofs) * 4);
	317	fprintf(f, "\tpushl %%eax\n");
	318	sarg_ofs++;
	319	args_repushed++;
	320	}
	321	}
	322	my_assert(args_repushed, have_normal);
	323
	324	// load arg regs
	325	for (i = 0; i < reg_cnt; i++) {
	326	if (reg_list[i] != NULL) {
	327	fprintf(f, "\tmovl %d(%%esp), %%%s\n",
	328	(i + sarg_ofs) * 4, reg_list[i]);
	329	}
	330	}
	331
	332	fprintf(f, "\n\t# %s\n", is_stdcall ? "__stdcall" : "__cdecl");
	333	fprintf(f, "\tcall %s\n\n", sym);
	334
	335	if (args_repushed && !is_stdcall)
a51421fa	336	fprintf(f, "\tadd $%d,%%esp\n", args_repushed * 4);
232aca37	337
	338	// restore regs
	339	for (i = reg_cnt - 1; i >= 0; i--) {
	340	if (reg_list[i] != NULL && is_x86_reg_saved(reg_list[i]))
	341	fprintf(f, "\tpopl %%%s\n", reg_list[i]);
	342	}
	343
	344	fprintf(f, "\tret\n\n");
	345	}
	346
	347	static void out_fromasm_x86(FILE f, char sym, char *reg_list[], int reg_cnt,
	348	int is_stdcall)
	349	{
	350	int have_normal = 0; // normal args
	351	int have_regs = 0;
	352	int sarg_ofs = 1; // stack offset to args, in DWORDs
	353	int stack_args;
	354	int i;
	355
	356	for (i = 0; i < reg_cnt; i++) {
	357	if (reg_list[i] == NULL) {
	358	have_normal++;
	359	continue;
	360	}
	361
	362	have_regs++;
	363	}
	364
	365	fprintf(f, "# %s\n", is_stdcall ? "__stdcall" : "__cdecl");
	366	fprintf(f, ".global %s\n", sym);
	367	fprintf(f, "%s:\n", sym);
	368
3e52f54c	369	if (!have_regs && !is_stdcall) {
232aca37	370	fprintf(f, "\tjmp _%s\n\n", sym);
	371	return;
	372	}
	373
	374	fprintf(f, "\tpushl %%edx\n"); // just in case..
	375	sarg_ofs++;
	376
	377	// construct arg stack
	378	stack_args = have_normal;
	379	for (i = reg_cnt - 1; i >= 0; i--) {
	380	if (reg_list[i] == NULL) {
	381	fprintf(f, "\tmovl %d(%%esp), %%edx\n",
	382	(sarg_ofs + stack_args - 1) * 4);
	383	fprintf(f, "\tpushl %%edx\n");
	384	stack_args--;
	385	}
	386	else {
	387	fprintf(f, "\tpushl %%%s\n", reg_list[i]);
	388	}
	389	sarg_ofs++;
	390	}
	391
	392	// no worries about calling conventions - always __cdecl
	393	fprintf(f, "\n\tcall _%s\n\n", sym);
	394
	395	if (sarg_ofs > 2)
a51421fa	396	fprintf(f, "\tadd $%d,%%esp\n", (sarg_ofs - 2) * 4);
232aca37	397
	398	fprintf(f, "\tpopl %%edx\n");
	399
	400	if (is_stdcall && have_normal)
	401	fprintf(f, "\tret $%d\n\n", have_normal * 4);
	402	else
	403	fprintf(f, "\tret\n\n");
	404	}
	405
3e52f54c	406	static void free_reglist(char *reg_list[], int reg_cnt)
	407	{
	408	int i;
	409
	410	for (i = 0; i < reg_cnt; i++) {
	411	if (reg_list[i] == NULL) {
	412	free(reg_list[i]);
	413	reg_list[i] = NULL;
	414	}
	415	}
	416	}
	417
57e4efe9	418	int main(int argc, char *argv[])
57e4efe9	419	{
232aca37	420	FILE fout, fsyms_to, fsyms_from, fhdr;
57e4efe9	421	char protostr[256];
	422	char line[256];
	423	char sym[256];
232aca37	424	char *reg_list[16];
	425	int is_stdcall = 0;
	426	int reg_cnt = 0;
57e4efe9	427	int ret;
57e4efe9	428
232aca37	429	if (argc != 5) {
232aca37	430	printf("usage:\n%s <bridge.s> <toasm_symf> <fromasm_symf> <hdrf>\n",
57e4efe9	431	argv[0]);
	432	return 1;
	433	}
	434
232aca37	435	hdrfn = argv[4];
57e4efe9	436	fhdr = fopen(hdrfn, "r");
	437	my_assert_not(fhdr, NULL);
	438
232aca37	439	fsyms_from = fopen(argv[3], "r");
	440	my_assert_not(fsyms_from, NULL);
	441
	442	fsyms_to = fopen(argv[2], "r");
	443	my_assert_not(fsyms_to, NULL);
57e4efe9	444
	445	fout = fopen(argv[1], "w");
	446	my_assert_not(fout, NULL);
	447
	448	fprintf(fout, ".text\n\n");
232aca37	449	fprintf(fout, "# to asm\n\n");
57e4efe9	450
232aca37	451	while (fgets(line, sizeof(line), fsyms_to))
57e4efe9	452	{
	453	next_word(sym, sizeof(sym), line);
	454	if (sym[0] == 0 \|\| sym[0] == ';' \|\| sym[0] == '#')
	455	continue;
	456
	457	ret = find_protostr(protostr, sizeof(protostr), fhdr,
	458	sym, &pline);
	459	if (ret != 0) {
	460	printf("%s: sym '%s' is missing\n",
	461	hdrfn, sym);
232aca37	462	goto out;
57e4efe9	463	}
57e4efe9	464
232aca37	465	ret = parse_protostr(protostr, reg_list, &reg_cnt, &is_stdcall);
	466	if (ret)
	467	goto out;
57e4efe9	468
232aca37	469	out_toasm_x86(fout, sym, reg_list, reg_cnt, is_stdcall);
3e52f54c	470	free_reglist(reg_list, reg_cnt);
232aca37	471	}
57e4efe9	472
232aca37	473	fprintf(fout, "# from asm\n\n");
57e4efe9	474
232aca37	475	while (fgets(line, sizeof(line), fsyms_from))
	476	{
	477	next_word(sym, sizeof(sym), line);
	478	if (sym[0] == 0 \|\| sym[0] == ';' \|\| sym[0] == '#')
	479	continue;
57e4efe9	480
232aca37	481	ret = find_protostr(protostr, sizeof(protostr), fhdr,
	482	sym, &pline);
	483	if (ret != 0) {
	484	printf("%s: sym '%s' is missing\n",
	485	hdrfn, sym);
	486	goto out;
57e4efe9	487	}
57e4efe9	488
232aca37	489	ret = parse_protostr(protostr, reg_list, &reg_cnt, &is_stdcall);
	490	if (ret)
	491	goto out;
57e4efe9	492
232aca37	493	out_fromasm_x86(fout, sym, reg_list, reg_cnt, is_stdcall);
3e52f54c	494	free_reglist(reg_list, reg_cnt);
57e4efe9	495	}
57e4efe9	496
232aca37	497	ret = 0;
232aca37	498	out:
57e4efe9	499	fclose(fout);
232aca37	500	fclose(fsyms_to);
	501	fclose(fsyms_from);
	502	fclose(fhdr);
	503	if (ret)
	504	remove(argv[1]);
	505
	506	return ret;
57e4efe9	507	}