[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 func[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")) {
			if (IS(word2, "proc"))
				strcpy(func, word);
			else
				func[0] = 0;

			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 || IS(word2, func)))
			{
				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 || IS(word3, func)))
			{
				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];
d4e3b5db	114	char func[256];
ede51255	115	char *p;
8022df01	116	int i;
ede51255	117
368deb23	118	if (argc < 4) {
	119	// -c - patch callsites
	120	printf("usage:\n%s <asmf_out> <asmf_in> [[-c] <listf>]*>\n",
ede51255	121	argv[0]);
	122	return 1;
	123	}
	124
	125	symlist_alloc = 16;
	126	symlist_cnt = 0;
8022df01	127	symlist = calloc(symlist_alloc, sizeof(symlist[0]));
ede51255	128	my_assert_not(symlist, NULL);
ede51255	129
368deb23	130	for (i = 3; i < argc; i++) {
0c5547d1	131	if (strcmp(argv[i], "-c") == 0) {
368deb23	132	patch_callsites = 1;
	133	continue;
	134	}
	135
	136	f = fopen(argv[i], "r");
	137	my_assert_not(f, NULL);
	138	read_list(&symlist, &symlist_cnt, &symlist_alloc,
	139	f, patch_callsites);
	140	fclose(f);
ede51255	141
368deb23	142	patch_callsites = 0;
368deb23	143	}
ede51255	144
	145	qsort(symlist, symlist_cnt, sizeof(symlist[0]), cmp_sym_sort);
	146
8022df01	147	#if 0
	148	printf("symlist:\n");
	149	for (i = 0; i < symlist_cnt; i++)
368deb23	150	printf("%d '%s'\n", symlist[i].callsites, symlist[i].name);
8022df01	151	#endif
ede51255	152
	153	fin = fopen(argv[2], "r");
	154	my_assert_not(fin, NULL);
	155
	156	fout = fopen(argv[1], "w");
	157	my_assert_not(fout, NULL);
	158
	159	while (fgets(line, sizeof(line), fin))
	160	{
	161	p = sskip(line);
	162	if (p == 0 \|\| p == ';')
	163	goto pass;
	164
	165	p = sskip(next_word(word, sizeof(word), p));
	166	if (p == 0 \|\| p == ';')
	167	goto pass; // need at least 2 words
	168
	169	p = next_word(word2, sizeof(word2), p);
	170
28023f83	171	if (IS_OR2(word2, "proc", "endp")) {
d4e3b5db	172	if (IS(word2, "proc"))
	173	strcpy(func, word);
	174	else
	175	func[0] = 0;
	176
ede51255	177	ssym.name = word;
	178	sym = bsearch(&ssym, symlist, symlist_cnt,
	179	sizeof(symlist[0]), cmp_sym);
	180	if (sym != NULL) {
8022df01	181	sym->found = 1;
ede51255	182	fprintf(fout, "rm_%s\t%s%s", word, word2, p);
	183	continue;
	184	}
	185	}
	186
28023f83	187	if (IS_OR3(word, "call", "jmp", "public")) {
ede51255	188	ssym.name = word2;
	189	sym = bsearch(&ssym, symlist, symlist_cnt,
	190	sizeof(symlist[0]), cmp_sym);
d4e3b5db	191	if (sym != NULL
	192	&& (sym->callsites \|\| IS(word2, func)))
	193	{
8022df01	194	fprintf(fout, "\t\t%s\t%s%s", word,
8022df01	195	sym_use(sym), p);
ede51255	196	continue;
	197	}
	198	}
	199
	200	p = sskip(p);
	201	if (p == 0 \|\| p == ';')
	202	goto pass; // need at least 3 words
	203
	204	p = next_word(word3, sizeof(word3), p);
	205
28023f83	206	// dd offset <sym>
	207	// push offset <sym>
	208	// jcc short <sym>
	209	if ( (IS_OR2(word, "dd", "push") && IS(word2, "offset"))
	210	\|\| (word[0] == 'j' && IS(word2, "short")) ) {
ede51255	211	ssym.name = word3;
	212	sym = bsearch(&ssym, symlist, symlist_cnt,
	213	sizeof(symlist[0]), cmp_sym);
d4e3b5db	214	if (sym != NULL
	215	&& (sym->callsites \|\| IS(word3, func)))
	216	{
28023f83	217	fprintf(fout, "\t\t%s %s %s%s",
28023f83	218	word, word2, sym_use(sym), p);
ede51255	219	continue;
	220	}
	221	}
	222
	223	p = sskip(p);
	224	if (p == 0 \|\| p == ';')
	225	goto pass; // need at least 4 words
	226
	227	p = next_word(word4, sizeof(word4), p);
	228
28023f83	229	// <name> dd offset <sym>
28023f83	230	if (IS(word2, "dd") && IS(word3, "offset")) {
ede51255	231	ssym.name = word4;
	232	sym = bsearch(&ssym, symlist, symlist_cnt,
	233	sizeof(symlist[0]), cmp_sym);
368deb23	234	if (sym != NULL && sym->callsites) {
8022df01	235	fprintf(fout, "%s\tdd offset %s%s", word,
8022df01	236	sym_use(sym), p);
ede51255	237	continue;
	238	}
	239	}
	240
28023f83	241	// mov <something>, offset <sym>
	242	// jcc <some> ptr <sym>
	243	if ( (IS(word, "mov") && IS(word3, "offset"))
	244	\|\| (word[0] == 'j' && IS(word3, "ptr")) ) {
	245	ssym.name = word4;
	246	sym = bsearch(&ssym, symlist, symlist_cnt,
	247	sizeof(symlist[0]), cmp_sym);
	248	if (sym != NULL && sym->callsites) {
	249	fprintf(fout, "\t\t%s\t%s %s %s%s",
	250	word, word2, word3,
	251	sym_use(sym), p);
	252	continue;
	253	}
	254	}
	255
	256	p = sskip(p);
	257	if (p == 0 \|\| p == ';')
	258	goto pass; // need at least 5 words
	259
	260	p = next_word(word5, sizeof(word5), p);
	261
	262	p = sskip(p);
	263	if (p == 0 \|\| p == ';')
	264	goto pass; // need at least 6 words
	265
	266	p = next_word(word6, sizeof(word6), p);
	267
	268	// <op> dword ptr <something>, offset <sym>
	269	if ( IS(word2, "dword") && IS(word3, "ptr")
	270	&& IS(word5, "offset") ) {
	271	ssym.name = word6;
	272	sym = bsearch(&ssym, symlist, symlist_cnt,
	273	sizeof(symlist[0]), cmp_sym);
	274	if (sym != NULL && sym->callsites) {
	275	fprintf(fout, "\t\t%s\tdword ptr %s offset %s%s",
	276	word, word4, sym_use(sym), p);
	277	continue;
	278	}
	279	}
	280
ede51255	281	pass:
	282	fwrite(line, 1, strlen(line), fout);
	283	}
	284
8022df01	285	for (i = 0; i < symlist_cnt; i++) {
	286	if (!symlist[i].found)
	287	printf("warning: sym '%s' not found\n", symlist[i].name);
	288	}
	289
ede51255	290	fclose(fin);
	291	fclose(fout);
	292
	293	return 0;
	294	}