[ia32rtools.git] / tools / asmproc.c

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

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

struct sl_item {
	char *name;
	unsigned int callsites:1;
	unsigned int found:1;
};

static int cmp_sym(const void *p1_, const void *p2_)
{
	const struct sl_item *p1 = p1_, *p2 = p2_;
	const char *s1 = p1->name, *s2 = p2->name;
	int i;

	for (i = 0; ; i++) {
		if ((s1[i] | s2[i]) == 0)
			break;

		if (s1[i] == s2[i])
			continue;

		if (s1[i] ==  0  && s2[i] == '@')
			break;
		if (s1[i] == '@' && s2[i] ==  0)
			break;

		return s1[i] - s2[i];
	}

	return 0;
}

static int cmp_sym_sort(const void *p1_, const void *p2_)
{
	const struct sl_item *p1 = p1_, *p2 = p2_;
	const char *s1 = p1->name, *s2 = p2->name;
	int ret;
	
	ret = cmp_sym(p1_, p2_);
	if (ret == 0) {
		printf("%s: dupe sym: '%s' '%s'\n", __func__, s1, s2);
		exit(1);
	}
	return ret;
}

void read_list(struct sl_item **sl_in, int *cnt, int *alloc,
	FILE *f, int callsites)
{
	struct sl_item *sl = *sl_in;
	int c = *cnt;
	char line[256];
	char word[256];

	while (fgets(line, sizeof(line), f) != NULL) {
		next_word(word, sizeof(word), line);
		if (word[0] == 0 || word[0] == ';' || word[0] == '#')
			continue;

		sl[c].name = strdup(word);
		sl[c].callsites = callsites;
		sl[c].found = 0;
		c++;

		if (c >= *alloc) {
			*alloc *= 2;
			sl = realloc(sl, *alloc * sizeof(sl[0]));
			my_assert_not(sl, NULL);
			memset(sl + c, 0, (*alloc - c) * sizeof(sl[0]));
		}
	}

	*sl_in = sl;
	*cnt = c;
}

const char *sym_use(const struct sl_item *sym)
{
	static char buf[256+3];
	int ret;

	ret = snprintf(buf, sizeof(buf), "rm_%s", sym->name);
	if (ret >= sizeof(buf)) {
		printf("truncation detected: '%s'\n", buf);
		exit(1);
	}

	return buf;
}

#define IS(w, y) !strcasecmp(w, y)
#define IS_OR2(w, x, y) (IS(w, x) || IS(w, y))
#define IS_OR3(w, x, y, z) (IS(w, x) || IS(w, y) || IS(w, z))

int main(int argc, char *argv[])
{
	struct sl_item *symlist, *sym, ssym = { NULL, };
	int patch_callsites = 0;
	FILE *fout, *fin, *f;
	int symlist_alloc;
	int symlist_cnt;
	char line[256];
	char word[256];
	char word2[256];
	char word3[256];
	char word4[256];
	char word5[256];
	char word6[256];
	char *p;
	int i;

	if (argc < 4) {
		// -c - patch callsites
		printf("usage:\n%s <asmf_out> <asmf_in> [[-c] <listf>]*>\n",
			argv[0]);
		return 1;
	}

	symlist_alloc = 16;
	symlist_cnt = 0;
	symlist = calloc(symlist_alloc, sizeof(symlist[0]));
	my_assert_not(symlist, NULL);

	for (i = 3; i < argc; i++) {
		if (strcmp(argv[i], "-c") == 0) {
			patch_callsites = 1;
			continue;
		}

		f = fopen(argv[i], "r");
		my_assert_not(f, NULL);
		read_list(&symlist, &symlist_cnt, &symlist_alloc,
			f, patch_callsites);
		fclose(f);

		patch_callsites = 0;
	}

	qsort(symlist, symlist_cnt, sizeof(symlist[0]), cmp_sym_sort);

#if 0
	printf("symlist:\n");
	for (i = 0; i < symlist_cnt; i++)
		printf("%d '%s'\n", symlist[i].callsites, symlist[i].name);
#endif

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

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

	while (fgets(line, sizeof(line), fin))
	{
		p = sskip(line);
		if (*p == 0 || *p == ';')
			goto pass;

		p = sskip(next_word(word, sizeof(word), p));
		if (*p == 0 || *p == ';')
			goto pass; // need at least 2 words

		p = next_word(word2, sizeof(word2), p);

		if (IS_OR2(word2, "proc", "endp")) {
			ssym.name = word;
			sym = bsearch(&ssym, symlist, symlist_cnt,
				sizeof(symlist[0]), cmp_sym);
			if (sym != NULL) {
				sym->found = 1;
				fprintf(fout, "rm_%s\t%s%s", word, word2, p);
				continue;
			}
		}

		if (IS_OR3(word, "call", "jmp", "public")) {
			ssym.name = word2;
			sym = bsearch(&ssym, symlist, symlist_cnt,
				sizeof(symlist[0]), cmp_sym);
			if (sym != NULL && sym->callsites) {
				fprintf(fout, "\t\t%s\t%s%s", word,
					sym_use(sym), p);
				continue;
			}
		}

		p = sskip(p);
		if (*p == 0 || *p == ';')
			goto pass; // need at least 3 words

		p = next_word(word3, sizeof(word3), p);

		// dd offset <sym>
		// push offset <sym>
		// jcc short <sym>
		if ( (IS_OR2(word, "dd", "push") && IS(word2, "offset"))
		  || (word[0] == 'j' && IS(word2, "short")) ) {
			ssym.name = word3;
			sym = bsearch(&ssym, symlist, symlist_cnt,
				sizeof(symlist[0]), cmp_sym);
			if (sym != NULL && sym->callsites) {
				fprintf(fout, "\t\t%s %s %s%s",
					word, word2, sym_use(sym), p);
				continue;
			}
		}

		p = sskip(p);
		if (*p == 0 || *p == ';')
			goto pass; // need at least 4 words

		p = next_word(word4, sizeof(word4), p);

		// <name> dd offset <sym>
		if (IS(word2, "dd") && IS(word3, "offset")) {
			ssym.name = word4;
			sym = bsearch(&ssym, symlist, symlist_cnt,
				sizeof(symlist[0]), cmp_sym);
			if (sym != NULL && sym->callsites) {
				fprintf(fout, "%s\tdd offset %s%s", word,
					sym_use(sym), p);
				continue;
			}
		}

		// mov <something>, offset <sym>
		// jcc <some> ptr <sym>
		if ( (IS(word, "mov") && IS(word3, "offset"))
		  || (word[0] == 'j' && IS(word3, "ptr")) ) {
			ssym.name = word4;
			sym = bsearch(&ssym, symlist, symlist_cnt,
				sizeof(symlist[0]), cmp_sym);
			if (sym != NULL && sym->callsites) {
				fprintf(fout, "\t\t%s\t%s %s %s%s",
					word, word2, word3,
					sym_use(sym), p);
				continue;
			}
		}

		p = sskip(p);
		if (*p == 0 || *p == ';')
			goto pass; // need at least 5 words

		p = next_word(word5, sizeof(word5), p);

		p = sskip(p);
		if (*p == 0 || *p == ';')
			goto pass; // need at least 6 words

		p = next_word(word6, sizeof(word6), p);

		// <op> dword ptr <something>, offset <sym>
		if ( IS(word2, "dword") && IS(word3, "ptr")
		  && IS(word5, "offset") ) {
			ssym.name = word6;
			sym = bsearch(&ssym, symlist, symlist_cnt,
				sizeof(symlist[0]), cmp_sym);
			if (sym != NULL && sym->callsites) {
				fprintf(fout, "\t\t%s\tdword ptr %s offset %s%s",
					word, word4, sym_use(sym), p);
				continue;
			}
		}

pass:
		fwrite(line, 1, strlen(line), fout);
	}

	for (i = 0; i < symlist_cnt; i++) {
		if (!symlist[i].found)
			printf("warning: sym '%s' not found\n", symlist[i].name);
	}

	fclose(fin);
	fclose(fout);

	return 0;
}
Commit	Line	Data
ede51255	1	#include <stdio.h>
	2	#include <stdlib.h>
	3	#include <string.h>
	4
	5	#include "my_assert.h"
57e4efe9	6	#include "my_str.h"
ede51255	7
	8	struct sl_item {
	9	char *name;
368deb23	10	unsigned int callsites:1;
8022df01	11	unsigned int found:1;
ede51255	12	};
	13
	14	static int cmp_sym(const void p1_, const void p2_)
	15	{
	16	const struct sl_item p1 = p1_, p2 = p2_;
	17	const char s1 = p1->name, s2 = p2->name;
	18	int i;
	19
	20	for (i = 0; ; i++) {
0c5547d1	21	if ((s1[i] \| s2[i]) == 0)
	22	break;
	23
ede51255	24	if (s1[i] == s2[i])
	25	continue;
	26
0c5547d1	27	if (s1[i] == 0 && s2[i] == '@')
	28	break;
	29	if (s1[i] == '@' && s2[i] == 0)
ede51255	30	break;
	31
	32	return s1[i] - s2[i];
	33	}
	34
	35	return 0;
	36	}
	37
	38	static int cmp_sym_sort(const void p1_, const void p2_)
	39	{
	40	const struct sl_item p1 = p1_, p2 = p2_;
	41	const char s1 = p1->name, s2 = p2->name;
	42	int ret;
	43
	44	ret = cmp_sym(p1_, p2_);
	45	if (ret == 0) {
	46	printf("%s: dupe sym: '%s' '%s'\n", __func__, s1, s2);
	47	exit(1);
	48	}
	49	return ret;
	50	}
	51
368deb23	52	void read_list(struct sl_item *sl_in, int cnt, int *alloc,
368deb23	53	FILE *f, int callsites)
ede51255	54	{
	55	struct sl_item sl = sl_in;
	56	int c = *cnt;
	57	char line[256];
	58	char word[256];
ede51255	59
ede51255	60	while (fgets(line, sizeof(line), f) != NULL) {
0c5547d1	61	next_word(word, sizeof(word), line);
0c5547d1	62	if (word[0] == 0 \|\| word[0] == ';' \|\| word[0] == '#')
ede51255	63	continue;
	64
	65	sl[c].name = strdup(word);
368deb23	66	sl[c].callsites = callsites;
8022df01	67	sl[c].found = 0;
ede51255	68	c++;
	69
	70	if (c >= *alloc) {
	71	alloc = 2;
	72	sl = realloc(sl, alloc sizeof(sl[0]));
	73	my_assert_not(sl, NULL);
8022df01	74	memset(sl + c, 0, (alloc - c) sizeof(sl[0]));
ede51255	75	}
	76	}
	77
	78	*sl_in = sl;
	79	*cnt = c;
	80	}
	81
8022df01	82	const char sym_use(const struct sl_item sym)
	83	{
	84	static char buf[256+3];
	85	int ret;
	86
0c5547d1	87	ret = snprintf(buf, sizeof(buf), "rm_%s", sym->name);
8022df01	88	if (ret >= sizeof(buf)) {
	89	printf("truncation detected: '%s'\n", buf);
	90	exit(1);
	91	}
	92
	93	return buf;
	94	}
	95
28023f83	96	#define IS(w, y) !strcasecmp(w, y)
	97	#define IS_OR2(w, x, y) (IS(w, x) \|\| IS(w, y))
	98	#define IS_OR3(w, x, y, z) (IS(w, x) \|\| IS(w, y) \|\| IS(w, z))
	99
ede51255	100	int main(int argc, char *argv[])
ede51255	101	{
8022df01	102	struct sl_item symlist, sym, ssym = { NULL, };
368deb23	103	int patch_callsites = 0;
ede51255	104	FILE fout, fin, *f;
	105	int symlist_alloc;
	106	int symlist_cnt;
	107	char line[256];
	108	char word[256];
	109	char word2[256];
	110	char word3[256];
	111	char word4[256];
28023f83	112	char word5[256];
28023f83	113	char word6[256];
ede51255	114	char *p;
8022df01	115	int i;
ede51255	116
368deb23	117	if (argc < 4) {
	118	// -c - patch callsites
	119	printf("usage:\n%s <asmf_out> <asmf_in> [[-c] <listf>]*>\n",
ede51255	120	argv[0]);
	121	return 1;
	122	}
	123
	124	symlist_alloc = 16;
	125	symlist_cnt = 0;
8022df01	126	symlist = calloc(symlist_alloc, sizeof(symlist[0]));
ede51255	127	my_assert_not(symlist, NULL);
ede51255	128
368deb23	129	for (i = 3; i < argc; i++) {
0c5547d1	130	if (strcmp(argv[i], "-c") == 0) {
368deb23	131	patch_callsites = 1;
	132	continue;
	133	}
	134
	135	f = fopen(argv[i], "r");
	136	my_assert_not(f, NULL);
	137	read_list(&symlist, &symlist_cnt, &symlist_alloc,
	138	f, patch_callsites);
	139	fclose(f);
ede51255	140
368deb23	141	patch_callsites = 0;
368deb23	142	}
ede51255	143
	144	qsort(symlist, symlist_cnt, sizeof(symlist[0]), cmp_sym_sort);
	145
8022df01	146	#if 0
	147	printf("symlist:\n");
	148	for (i = 0; i < symlist_cnt; i++)
368deb23	149	printf("%d '%s'\n", symlist[i].callsites, symlist[i].name);
8022df01	150	#endif
ede51255	151
	152	fin = fopen(argv[2], "r");
	153	my_assert_not(fin, NULL);
	154
	155	fout = fopen(argv[1], "w");
	156	my_assert_not(fout, NULL);
	157
	158	while (fgets(line, sizeof(line), fin))
	159	{
	160	p = sskip(line);
	161	if (p == 0 \|\| p == ';')
	162	goto pass;
	163
	164	p = sskip(next_word(word, sizeof(word), p));
	165	if (p == 0 \|\| p == ';')
	166	goto pass; // need at least 2 words
	167
	168	p = next_word(word2, sizeof(word2), p);
	169
28023f83	170	if (IS_OR2(word2, "proc", "endp")) {
ede51255	171	ssym.name = word;
	172	sym = bsearch(&ssym, symlist, symlist_cnt,
	173	sizeof(symlist[0]), cmp_sym);
	174	if (sym != NULL) {
8022df01	175	sym->found = 1;
ede51255	176	fprintf(fout, "rm_%s\t%s%s", word, word2, p);
	177	continue;
	178	}
	179	}
	180
28023f83	181	if (IS_OR3(word, "call", "jmp", "public")) {
ede51255	182	ssym.name = word2;
	183	sym = bsearch(&ssym, symlist, symlist_cnt,
	184	sizeof(symlist[0]), cmp_sym);
368deb23	185	if (sym != NULL && sym->callsites) {
8022df01	186	fprintf(fout, "\t\t%s\t%s%s", word,
8022df01	187	sym_use(sym), p);
ede51255	188	continue;
	189	}
	190	}
	191
	192	p = sskip(p);
	193	if (p == 0 \|\| p == ';')
	194	goto pass; // need at least 3 words
	195
	196	p = next_word(word3, sizeof(word3), p);
	197
28023f83	198	// dd offset <sym>
	199	// push offset <sym>
	200	// jcc short <sym>
	201	if ( (IS_OR2(word, "dd", "push") && IS(word2, "offset"))
	202	\|\| (word[0] == 'j' && IS(word2, "short")) ) {
ede51255	203	ssym.name = word3;
	204	sym = bsearch(&ssym, symlist, symlist_cnt,
	205	sizeof(symlist[0]), cmp_sym);
368deb23	206	if (sym != NULL && sym->callsites) {
28023f83	207	fprintf(fout, "\t\t%s %s %s%s",
28023f83	208	word, word2, sym_use(sym), p);
ede51255	209	continue;
	210	}
	211	}
	212
	213	p = sskip(p);
	214	if (p == 0 \|\| p == ';')
	215	goto pass; // need at least 4 words
	216
	217	p = next_word(word4, sizeof(word4), p);
	218
28023f83	219	// <name> dd offset <sym>
28023f83	220	if (IS(word2, "dd") && IS(word3, "offset")) {
ede51255	221	ssym.name = word4;
	222	sym = bsearch(&ssym, symlist, symlist_cnt,
	223	sizeof(symlist[0]), cmp_sym);
368deb23	224	if (sym != NULL && sym->callsites) {
8022df01	225	fprintf(fout, "%s\tdd offset %s%s", word,
8022df01	226	sym_use(sym), p);
ede51255	227	continue;
	228	}
	229	}
	230
28023f83	231	// mov <something>, offset <sym>
	232	// jcc <some> ptr <sym>
	233	if ( (IS(word, "mov") && IS(word3, "offset"))
	234	\|\| (word[0] == 'j' && IS(word3, "ptr")) ) {
	235	ssym.name = word4;
	236	sym = bsearch(&ssym, symlist, symlist_cnt,
	237	sizeof(symlist[0]), cmp_sym);
	238	if (sym != NULL && sym->callsites) {
	239	fprintf(fout, "\t\t%s\t%s %s %s%s",
	240	word, word2, word3,
	241	sym_use(sym), p);
	242	continue;
	243	}
	244	}
	245
	246	p = sskip(p);
	247	if (p == 0 \|\| p == ';')
	248	goto pass; // need at least 5 words
	249
	250	p = next_word(word5, sizeof(word5), p);
	251
	252	p = sskip(p);
	253	if (p == 0 \|\| p == ';')
	254	goto pass; // need at least 6 words
	255
	256	p = next_word(word6, sizeof(word6), p);
	257
	258	// <op> dword ptr <something>, offset <sym>
	259	if ( IS(word2, "dword") && IS(word3, "ptr")
	260	&& IS(word5, "offset") ) {
	261	ssym.name = word6;
	262	sym = bsearch(&ssym, symlist, symlist_cnt,
	263	sizeof(symlist[0]), cmp_sym);
	264	if (sym != NULL && sym->callsites) {
	265	fprintf(fout, "\t\t%s\tdword ptr %s offset %s%s",
	266	word, word4, sym_use(sym), p);
	267	continue;
	268	}
	269	}
	270
ede51255	271	pass:
	272	fwrite(line, 1, strlen(line), fout);
	273	}
	274
8022df01	275	for (i = 0; i < symlist_cnt; i++) {
	276	if (!symlist[i].found)
	277	printf("warning: sym '%s' not found\n", symlist[i].name);
	278	}
	279
ede51255	280	fclose(fin);
	281	fclose(fout);
	282
	283	return 0;
	284	}