[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)

#include "protoparse.h"

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, const char *sym_in,
	const char *sym_out, const struct parsed_proto *pp)
{
	int must_save = 0;
	int sarg_ofs = 1; // stack offset to args, in DWORDs
	int args_repushed = 0;
	int argc_repush;
	int i;

	argc_repush = pp->argc;
	if (pp->is_vararg)
		argc_repush = ARRAY_SIZE(pp->arg); // hopefully enough?

	for (i = 0; i < pp->argc; i++) {
		if (pp->arg[i].reg != NULL)
			must_save |= is_x86_reg_saved(pp->arg[i].reg);
	}

	fprintf(f, ".global %s%s\n", pp->is_fastcall ? "@" : "_", sym_in);
	fprintf(f, "%s%s:\n", pp->is_fastcall ? "@" : "_", sym_in);

	if (pp->argc_reg == 0 || pp->is_fastcall) {
		fprintf(f, "\t# %s\n",
		  pp->is_fastcall ? "__fastcall" :
		  (pp->is_stdcall ? "__stdcall" : "__cdecl"));
		fprintf(f, "\tjmp %s\n\n", sym_out);
		return;
	}

	if (pp->argc_stack == 0 && !must_save && !pp->is_stdcall
	     && !pp->is_vararg)
	{
		// load arg regs
		for (i = 0; i < pp->argc; i++) {
			fprintf(f, "\tmovl %d(%%esp), %%%s\n",
				(i + sarg_ofs) * 4, pp->arg[i].reg);
		}
		fprintf(f, "\tjmp %s\n\n", sym_out);
		return;
	}

	// save the regs
	for (i = 0; i < pp->argc; i++) {
		if (pp->arg[i].reg != NULL && is_x86_reg_saved(pp->arg[i].reg)) {
			fprintf(f, "\tpushl %%%s\n", pp->arg[i].reg);
			sarg_ofs++;
		}
	}

	// reconstruct arg stack
	for (i = argc_repush - 1; i >= 0; i--) {
		if (pp->arg[i].reg == 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, pp->argc_stack);

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

	fprintf(f, "\n\t# %s\n", pp->is_stdcall ? "__stdcall" : "__cdecl");
	fprintf(f, "\tcall %s\n\n", sym_out);

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

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

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

static void out_fromasm_x86(FILE *f, const char *sym,
	const struct parsed_proto *pp)
{
	int sarg_ofs = 1; // stack offset to args, in DWORDs
	int saved_regs = 0;
	int c_is_stdcall;
	int argc_repush;
	int stack_args;
	int ret64;
	int i;

	argc_repush = pp->argc;
	stack_args = pp->argc_stack;
	if (pp->is_vararg) {
		argc_repush = ARRAY_SIZE(pp->arg); // hopefully enough?
		stack_args = argc_repush - pp->argc_reg;
	}

	ret64 = strstr(pp->ret_type.name, "int64") != NULL;

	fprintf(f, "# %s",
	  pp->is_fastcall ? "__fastcall" :
	  (pp->is_stdcall ? "__stdcall" : "__cdecl"));
	if (ret64)
		 fprintf(f, " ret64");
	fprintf(f, "\n.global %s\n", sym);
	fprintf(f, "%s:\n", sym);

	if ((pp->argc_reg == 0 || pp->is_fastcall)
	    && !IS(pp->name, "storm_491")) // wants edx save :(
	{
		fprintf(f, "\tjmp %s%s",
			pp->is_fastcall ? "@" : "_", sym);
		if (pp->is_stdcall)
			fprintf(f, "@%d", pp->argc * 4);
		fprintf(f, "\n\n");
		return;
	}

	c_is_stdcall = (pp->argc_reg == 0 && pp->is_stdcall);

	// at least sc sub_47B150 needs edx to be preserved
	// int64 returns use edx:eax - no edx save
	// we use ecx also as scratch
	fprintf(f, "\tpushl %%ecx\n");
	saved_regs++;
	sarg_ofs++;
	if (!ret64) {
		fprintf(f, "\tpushl %%edx\n");
		saved_regs++;
		sarg_ofs++;
	}

	// construct arg stack
	for (i = argc_repush - 1; i >= 0; i--) {
		if (pp->arg[i].reg == NULL) {
			fprintf(f, "\tmovl %d(%%esp), %%ecx\n",
				(sarg_ofs + stack_args - 1) * 4);
			fprintf(f, "\tpushl %%ecx\n");
			stack_args--;
		}
		else {
			if (IS(pp->arg[i].reg, "ecx"))
				// must reload original ecx
				fprintf(f, "\tmovl %d(%%esp), %%ecx\n",
					(sarg_ofs - 2) * 4);

			fprintf(f, "\tpushl %%%s\n", pp->arg[i].reg);
		}
		sarg_ofs++;
	}

	fprintf(f, "\n\tcall _%s", sym);
	if (c_is_stdcall)
		fprintf(f, "@%d", pp->argc_stack * 4);
	fprintf(f, "\n\n");

	if (!c_is_stdcall && sarg_ofs > saved_regs + 1)
		fprintf(f, "\tadd $%d,%%esp\n",
			(sarg_ofs - (saved_regs + 1)) * 4);

	if (!ret64)
		fprintf(f, "\tpopl %%edx\n");
	fprintf(f, "\tpopl %%ecx\n");

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

int main(int argc, char *argv[])
{
	FILE *fout, *fsyms_to, *fsyms_from, *fhdr;
	const struct parsed_proto *pp;
	char line[256];
	char sym_noat[256];
	char sym[256];
	char *p;
	int ret = 1;

	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;

		// IDA asm doesn't do '@' notation..
		strcpy(sym_noat, sym);
		p = strchr(sym_noat, '@');
		if (p != NULL)
			*p = 0;

		pp = proto_parse(fhdr, sym_noat, 0);
		if (pp == NULL)
			goto out;

		out_toasm_x86(fout, sym, sym_noat, pp);
	}

	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;

		pp = proto_parse(fhdr, sym, 0);
		if (pp == NULL)
			goto out;

		out_fromasm_x86(fout, sym, pp);
	}

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

	return ret;
}
Commit	Line	Data
	1	#include <stdio.h>
	2	#include <stdlib.h>
	3	#include <string.h>
	4
	5	#include "my_assert.h"
	6	#include "my_str.h"
	7
	8	#define ARRAY_SIZE(x) (sizeof(x) / sizeof(x[0]))
	9	#define IS(w, y) !strcmp(w, y)
	10
	11	#include "protoparse.h"
	12
	13	static int is_x86_reg_saved(const char *reg)
	14	{
	15	static const char *nosave_regs[] = { "eax", "edx", "ecx" };
	16	int nosave = 0;
	17	int r;
	18
	19	for (r = 0; r < ARRAY_SIZE(nosave_regs); r++)
	20	if (strcmp(reg, nosave_regs[r]) == 0)
	21	nosave = 1;
	22
	23	return !nosave;
	24	}
	25
	26	static void out_toasm_x86(FILE f, const char sym_in,
	27	const char sym_out, const struct parsed_proto pp)
	28	{
	29	int must_save = 0;
	30	int sarg_ofs = 1; // stack offset to args, in DWORDs
	31	int args_repushed = 0;
	32	int argc_repush;
	33	int i;
	34
	35	argc_repush = pp->argc;
	36	if (pp->is_vararg)
	37	argc_repush = ARRAY_SIZE(pp->arg); // hopefully enough?
	38
	39	for (i = 0; i < pp->argc; i++) {
	40	if (pp->arg[i].reg != NULL)
	41	must_save \|= is_x86_reg_saved(pp->arg[i].reg);
	42	}
	43
	44	fprintf(f, ".global %s%s\n", pp->is_fastcall ? "@" : "_", sym_in);
	45	fprintf(f, "%s%s:\n", pp->is_fastcall ? "@" : "_", sym_in);
	46
	47	if (pp->argc_reg == 0 \|\| pp->is_fastcall) {
	48	fprintf(f, "\t# %s\n",
	49	pp->is_fastcall ? "__fastcall" :
	50	(pp->is_stdcall ? "__stdcall" : "__cdecl"));
	51	fprintf(f, "\tjmp %s\n\n", sym_out);
	52	return;
	53	}
	54
	55	if (pp->argc_stack == 0 && !must_save && !pp->is_stdcall
	56	&& !pp->is_vararg)
	57	{
	58	// load arg regs
	59	for (i = 0; i < pp->argc; i++) {
	60	fprintf(f, "\tmovl %d(%%esp), %%%s\n",
	61	(i + sarg_ofs) * 4, pp->arg[i].reg);
	62	}
	63	fprintf(f, "\tjmp %s\n\n", sym_out);
	64	return;
	65	}
	66
	67	// save the regs
	68	for (i = 0; i < pp->argc; i++) {
	69	if (pp->arg[i].reg != NULL && is_x86_reg_saved(pp->arg[i].reg)) {
	70	fprintf(f, "\tpushl %%%s\n", pp->arg[i].reg);
	71	sarg_ofs++;
	72	}
	73	}
	74
	75	// reconstruct arg stack
	76	for (i = argc_repush - 1; i >= 0; i--) {
	77	if (pp->arg[i].reg == NULL) {
	78	fprintf(f, "\tmovl %d(%%esp), %%eax\n",
	79	(i + sarg_ofs) * 4);
	80	fprintf(f, "\tpushl %%eax\n");
	81	sarg_ofs++;
	82	args_repushed++;
	83	}
	84	}
	85	// my_assert(args_repushed, pp->argc_stack);
	86
	87	// load arg regs
	88	for (i = 0; i < pp->argc; i++) {
	89	if (pp->arg[i].reg != NULL) {
	90	fprintf(f, "\tmovl %d(%%esp), %%%s\n",
	91	(i + sarg_ofs) * 4, pp->arg[i].reg);
	92	}
	93	}
	94
	95	fprintf(f, "\n\t# %s\n", pp->is_stdcall ? "__stdcall" : "__cdecl");
	96	fprintf(f, "\tcall %s\n\n", sym_out);
	97
	98	if (args_repushed && !pp->is_stdcall)
	99	fprintf(f, "\tadd $%d,%%esp\n", args_repushed * 4);
	100
	101	// restore regs
	102	for (i = pp->argc - 1; i >= 0; i--) {
	103	if (pp->arg[i].reg != NULL && is_x86_reg_saved(pp->arg[i].reg))
	104	fprintf(f, "\tpopl %%%s\n", pp->arg[i].reg);
	105	}
	106
	107	fprintf(f, "\tret\n\n");
	108	}
	109
	110	static void out_fromasm_x86(FILE f, const char sym,
	111	const struct parsed_proto *pp)
	112	{
	113	int sarg_ofs = 1; // stack offset to args, in DWORDs
	114	int saved_regs = 0;
	115	int c_is_stdcall;
	116	int argc_repush;
	117	int stack_args;
	118	int ret64;
	119	int i;
	120
	121	argc_repush = pp->argc;
	122	stack_args = pp->argc_stack;
	123	if (pp->is_vararg) {
	124	argc_repush = ARRAY_SIZE(pp->arg); // hopefully enough?
	125	stack_args = argc_repush - pp->argc_reg;
	126	}
	127
	128	ret64 = strstr(pp->ret_type.name, "int64") != NULL;
	129
	130	fprintf(f, "# %s",
	131	pp->is_fastcall ? "__fastcall" :
	132	(pp->is_stdcall ? "__stdcall" : "__cdecl"));
	133	if (ret64)
	134	fprintf(f, " ret64");
	135	fprintf(f, "\n.global %s\n", sym);
	136	fprintf(f, "%s:\n", sym);
	137
	138	if ((pp->argc_reg == 0 \|\| pp->is_fastcall)
	139	&& !IS(pp->name, "storm_491")) // wants edx save :(
	140	{
	141	fprintf(f, "\tjmp %s%s",
	142	pp->is_fastcall ? "@" : "_", sym);
	143	if (pp->is_stdcall)
	144	fprintf(f, "@%d", pp->argc * 4);
	145	fprintf(f, "\n\n");
	146	return;
	147	}
	148
	149	c_is_stdcall = (pp->argc_reg == 0 && pp->is_stdcall);
	150
	151	// at least sc sub_47B150 needs edx to be preserved
	152	// int64 returns use edx:eax - no edx save
	153	// we use ecx also as scratch
	154	fprintf(f, "\tpushl %%ecx\n");
	155	saved_regs++;
	156	sarg_ofs++;
	157	if (!ret64) {
	158	fprintf(f, "\tpushl %%edx\n");
	159	saved_regs++;
	160	sarg_ofs++;
	161	}
	162
	163	// construct arg stack
	164	for (i = argc_repush - 1; i >= 0; i--) {
	165	if (pp->arg[i].reg == NULL) {
	166	fprintf(f, "\tmovl %d(%%esp), %%ecx\n",
	167	(sarg_ofs + stack_args - 1) * 4);
	168	fprintf(f, "\tpushl %%ecx\n");
	169	stack_args--;
	170	}
	171	else {
	172	if (IS(pp->arg[i].reg, "ecx"))
	173	// must reload original ecx
	174	fprintf(f, "\tmovl %d(%%esp), %%ecx\n",
	175	(sarg_ofs - 2) * 4);
	176
	177	fprintf(f, "\tpushl %%%s\n", pp->arg[i].reg);
	178	}
	179	sarg_ofs++;
	180	}
	181
	182	fprintf(f, "\n\tcall _%s", sym);
	183	if (c_is_stdcall)
	184	fprintf(f, "@%d", pp->argc_stack * 4);
	185	fprintf(f, "\n\n");
	186
	187	if (!c_is_stdcall && sarg_ofs > saved_regs + 1)
	188	fprintf(f, "\tadd $%d,%%esp\n",
	189	(sarg_ofs - (saved_regs + 1)) * 4);
	190
	191	if (!ret64)
	192	fprintf(f, "\tpopl %%edx\n");
	193	fprintf(f, "\tpopl %%ecx\n");
	194
	195	if (pp->is_stdcall && pp->argc_stack)
	196	fprintf(f, "\tret $%d\n\n", pp->argc_stack * 4);
	197	else
	198	fprintf(f, "\tret\n\n");
	199	}
	200
	201	int main(int argc, char *argv[])
	202	{
	203	FILE fout, fsyms_to, fsyms_from, fhdr;
	204	const struct parsed_proto *pp;
	205	char line[256];
	206	char sym_noat[256];
	207	char sym[256];
	208	char *p;
	209	int ret = 1;
	210
	211	if (argc != 5) {
	212	printf("usage:\n%s <bridge.s> <toasm_symf> <fromasm_symf> <hdrf>\n",
	213	argv[0]);
	214	return 1;
	215	}
	216
	217	hdrfn = argv[4];
	218	fhdr = fopen(hdrfn, "r");
	219	my_assert_not(fhdr, NULL);
	220
	221	fsyms_from = fopen(argv[3], "r");
	222	my_assert_not(fsyms_from, NULL);
	223
	224	fsyms_to = fopen(argv[2], "r");
	225	my_assert_not(fsyms_to, NULL);
	226
	227	fout = fopen(argv[1], "w");
	228	my_assert_not(fout, NULL);
	229
	230	fprintf(fout, ".text\n\n");
	231	fprintf(fout, "# to asm\n\n");
	232
	233	while (fgets(line, sizeof(line), fsyms_to))
	234	{
	235	next_word(sym, sizeof(sym), line);
	236	if (sym[0] == 0 \|\| sym[0] == ';' \|\| sym[0] == '#')
	237	continue;
	238
	239	// IDA asm doesn't do '@' notation..
	240	strcpy(sym_noat, sym);
	241	p = strchr(sym_noat, '@');
	242	if (p != NULL)
	243	*p = 0;
	244
	245	pp = proto_parse(fhdr, sym_noat, 0);
	246	if (pp == NULL)
	247	goto out;
	248
	249	out_toasm_x86(fout, sym, sym_noat, pp);
	250	}
	251
	252	fprintf(fout, "# from asm\n\n");
	253
	254	while (fgets(line, sizeof(line), fsyms_from))
	255	{
	256	next_word(sym, sizeof(sym), line);
	257	if (sym[0] == 0 \|\| sym[0] == ';' \|\| sym[0] == '#')
	258	continue;
	259
	260	pp = proto_parse(fhdr, sym, 0);
	261	if (pp == NULL)
	262	goto out;
	263
	264	out_fromasm_x86(fout, sym, pp);
	265	}
	266
	267	ret = 0;
	268	out:
	269	fclose(fout);
	270	fclose(fsyms_to);
	271	fclose(fsyms_from);
	272	fclose(fhdr);
	273	if (ret)
	274	remove(argv[1]);
	275
	276	return ret;
	277	}