[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;
	unsigned int ignore_missing: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;

	if (*s1 == '_')
		s1++;
	if (*s2 == '_')
		s2++;

	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, int ignore_missing)
{
	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].ignore_missing = ignore_missing;
		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, int is_rm)
{
	static char buf[256+3];
	int ret;

	ret = snprintf(buf, sizeof(buf), "%s%s",
	  is_rm ? "rm_" : "", 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;
	int ignore_missing = 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, *p2;
	int i;

	if (argc < 4) {
		printf("usage:\n%s <asmf_out> <asmf_in> [[-c][-i] <listf>]*>\n",
			argv[0]);
		printf("  -c - patch callsites\n"
					 "  -i - ignore missing syms\n");
		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;
		}
		if (strcmp(argv[i], "-i") == 0) {
			ignore_missing = 1;
			continue;
		}

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

		patch_callsites = 0;
		ignore_missing = 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, "%s\t%s%s", sym_use(sym, 1), word2, p);
				continue;
			}
		}

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

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

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

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

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

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

		// dd offset <sym>
		if (IS(word, "dd")
			&& (IS(word2, "offset") || strstr(p, "offset")))
		{
			fprintf(fout, "\t\tdd");
			p = next_word(word, sizeof(word), line);
			goto offset_loop;
		}

		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") || strstr(p, "offset")))
		{
			fprintf(fout, "%s\tdd", word);
			p = next_word(word, sizeof(word), line);
			p = next_word(word, sizeof(word), p);
			goto offset_loop;
		}

		// 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) {
				fprintf(fout, "\t\t%s\t%s %s %s%s",
					word, word2, word3,
					sym_use(sym, sym->callsites), 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) {
				fprintf(fout, "\t\t%s\tdword ptr %s offset %s%s",
					word, word4, sym_use(sym, sym->callsites), p);
				continue;
			}
		}

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

offset_loop:
		while (1) {
			p2 = next_word(word, sizeof(word), p);
			if (word[0] == 0 || word[0] == ';') {
				break;
			}
			if (!IS(word, "offset")) {
				// pass through
				p2 = strstr(p, "offset");
				if (p2 == NULL)
					break;
				fwrite(p, 1, p2 - p, fout);
				p2 = next_word(word, sizeof(word), p2);
			}
			p = next_word(word, sizeof(word), p2);
			p2 = strchr(word, ',');
			if (p2)
				*p2 = 0;

			ssym.name = word;
			sym = bsearch(&ssym, symlist, symlist_cnt,
				sizeof(symlist[0]), cmp_sym);
			fprintf(fout, " offset %s%s",
				(sym != NULL) ? sym_use(sym, sym->callsites) : word,
				p2 ? "," : "");
		}
		fprintf(fout, "%s", p);
		continue;
	}

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

	fclose(fin);
	fclose(fout);

	return 0;
}

// vim:ts=2:shiftwidth=2
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	struct sl_item {
	9	char *name;
	10	unsigned int callsites:1;
	11	unsigned int found:1;
	12	unsigned int ignore_missing:1;
	13	};
	14
	15	static int cmp_sym(const void p1_, const void p2_)
	16	{
	17	const struct sl_item p1 = p1_, p2 = p2_;
	18	const char s1 = p1->name, s2 = p2->name;
	19	int i;
	20
	21	if (*s1 == '_')
	22	s1++;
	23	if (*s2 == '_')
	24	s2++;
	25
	26	for (i = 0; ; i++) {
	27	if ((s1[i] \| s2[i]) == 0)
	28	break;
	29
	30	if (s1[i] == s2[i])
	31	continue;
	32
	33	if (s1[i] == 0 && s2[i] == '@')
	34	break;
	35	if (s1[i] == '@' && s2[i] == 0)
	36	break;
	37
	38	return s1[i] - s2[i];
	39	}
	40
	41	return 0;
	42	}
	43
	44	static int cmp_sym_sort(const void p1_, const void p2_)
	45	{
	46	const struct sl_item p1 = p1_, p2 = p2_;
	47	const char s1 = p1->name, s2 = p2->name;
	48	int ret;
	49
	50	ret = cmp_sym(p1_, p2_);
	51	if (ret == 0) {
	52	printf("%s: dupe sym: '%s' '%s'\n", __func__, s1, s2);
	53	exit(1);
	54	}
	55	return ret;
	56	}
	57
	58	void read_list(struct sl_item *sl_in, int cnt, int *alloc,
	59	FILE *f, int callsites, int ignore_missing)
	60	{
	61	struct sl_item sl = sl_in;
	62	int c = *cnt;
	63	char line[256];
	64	char word[256];
	65
	66	while (fgets(line, sizeof(line), f) != NULL) {
	67	next_word(word, sizeof(word), line);
	68	if (word[0] == 0 \|\| word[0] == ';' \|\| word[0] == '#')
	69	continue;
	70
	71	sl[c].name = strdup(word);
	72	sl[c].callsites = callsites;
	73	sl[c].ignore_missing = ignore_missing;
	74	sl[c].found = 0;
	75	c++;
	76
	77	if (c >= *alloc) {
	78	alloc = 2;
	79	sl = realloc(sl, alloc sizeof(sl[0]));
	80	my_assert_not(sl, NULL);
	81	memset(sl + c, 0, (alloc - c) sizeof(sl[0]));
	82	}
	83	}
	84
	85	*sl_in = sl;
	86	*cnt = c;
	87	}
	88
	89	const char sym_use(const struct sl_item sym, int is_rm)
	90	{
	91	static char buf[256+3];
	92	int ret;
	93
	94	ret = snprintf(buf, sizeof(buf), "%s%s",
	95	is_rm ? "rm_" : "", sym->name);
	96	if (ret >= sizeof(buf)) {
	97	printf("truncation detected: '%s'\n", buf);
	98	exit(1);
	99	}
	100
	101	return buf;
	102	}
	103
	104	#define IS(w, y) !strcasecmp(w, y)
	105	#define IS_OR2(w, x, y) (IS(w, x) \|\| IS(w, y))
	106	#define IS_OR3(w, x, y, z) (IS(w, x) \|\| IS(w, y) \|\| IS(w, z))
	107
	108	int main(int argc, char *argv[])
	109	{
	110	struct sl_item symlist, sym, ssym = { NULL, };
	111	int patch_callsites = 0;
	112	int ignore_missing = 0;
	113	FILE fout, fin, *f;
	114	int symlist_alloc;
	115	int symlist_cnt;
	116	char line[256];
	117	char word[256];
	118	char word2[256];
	119	char word3[256];
	120	char word4[256];
	121	char word5[256];
	122	char word6[256];
	123	char func[256];
	124	char p, p2;
	125	int i;
	126
	127	if (argc < 4) {
	128	printf("usage:\n%s <asmf_out> <asmf_in> [[-c][-i] <listf>]*>\n",
	129	argv[0]);
	130	printf(" -c - patch callsites\n"
	131	" -i - ignore missing syms\n");
	132	return 1;
	133	}
	134
	135	symlist_alloc = 16;
	136	symlist_cnt = 0;
	137	symlist = calloc(symlist_alloc, sizeof(symlist[0]));
	138	my_assert_not(symlist, NULL);
	139
	140	for (i = 3; i < argc; i++) {
	141	if (strcmp(argv[i], "-c") == 0) {
	142	patch_callsites = 1;
	143	continue;
	144	}
	145	if (strcmp(argv[i], "-i") == 0) {
	146	ignore_missing = 1;
	147	continue;
	148	}
	149
	150	f = fopen(argv[i], "r");
	151	my_assert_not(f, NULL);
	152	read_list(&symlist, &symlist_cnt, &symlist_alloc,
	153	f, patch_callsites, ignore_missing);
	154	fclose(f);
	155
	156	patch_callsites = 0;
	157	ignore_missing = 0;
	158	}
	159
	160	qsort(symlist, symlist_cnt, sizeof(symlist[0]), cmp_sym_sort);
	161
	162	#if 0
	163	printf("symlist:\n");
	164	for (i = 0; i < symlist_cnt; i++)
	165	printf("%d '%s'\n", symlist[i].callsites, symlist[i].name);
	166	#endif
	167
	168	fin = fopen(argv[2], "r");
	169	my_assert_not(fin, NULL);
	170
	171	fout = fopen(argv[1], "w");
	172	my_assert_not(fout, NULL);
	173
	174	while (fgets(line, sizeof(line), fin))
	175	{
	176	p = sskip(line);
	177	if (p == 0 \|\| p == ';')
	178	goto pass;
	179
	180	p = sskip(next_word(word, sizeof(word), p));
	181	if (p == 0 \|\| p == ';')
	182	goto pass; // need at least 2 words
	183
	184	p = next_word(word2, sizeof(word2), p);
	185
	186	if (IS_OR2(word2, "proc", "endp")) {
	187	if (IS(word2, "proc"))
	188	strcpy(func, word);
	189	else
	190	func[0] = 0;
	191
	192	ssym.name = word;
	193	sym = bsearch(&ssym, symlist, symlist_cnt,
	194	sizeof(symlist[0]), cmp_sym);
	195	if (sym != NULL) {
	196	sym->found = 1;
	197	fprintf(fout, "%s\t%s%s", sym_use(sym, 1), word2, p);
	198	continue;
	199	}
	200	}
	201
	202	if (IS_OR2(word, "call", "jmp")) {
	203	ssym.name = word2;
	204	sym = bsearch(&ssym, symlist, symlist_cnt,
	205	sizeof(symlist[0]), cmp_sym);
	206	if (sym != NULL) {
	207	fprintf(fout, "\t\t%s\t%s%s", word,
	208	sym_use(sym, sym->callsites \|\| IS(word2, func)), p);
	209	continue;
	210	}
	211	}
	212
	213	if (IS(word, "public")) {
	214	ssym.name = word2;
	215	sym = bsearch(&ssym, symlist, symlist_cnt,
	216	sizeof(symlist[0]), cmp_sym);
	217	if (sym != NULL) {
	218	fprintf(fout, "\t\tpublic %s%s", sym_use(sym, 1), p);
	219	continue;
	220	}
	221	}
	222
	223	p = sskip(p);
	224	if (p == 0 \|\| p == ';')
	225	goto pass; // need at least 3 words
	226
	227	p = next_word(word3, sizeof(word3), p);
	228
	229	// push offset <sym>
	230	if (IS(word, "push") && IS(word2, "offset")) {
	231	ssym.name = word3;
	232	sym = bsearch(&ssym, symlist, symlist_cnt,
	233	sizeof(symlist[0]), cmp_sym);
	234	if (sym != NULL) {
	235	fprintf(fout, "\t\t%s %s %s%s", word, word2,
	236	sym_use(sym, sym->callsites \|\| IS(word3, func)), p);
	237	continue;
	238	}
	239	}
	240
	241	// jcc short <sym>
	242	if (word[0] == 'j' && IS(word2, "short") && !IS(word3, "exit")) {
	243	ssym.name = word3;
	244	sym = bsearch(&ssym, symlist, symlist_cnt,
	245	sizeof(symlist[0]), cmp_sym);
	246	if (sym != NULL) {
	247	fprintf(fout, "\t\t%s ", word);
	248	// for conditional "call", don't print 'short'
	249	if (IS(word3, func))
	250	fprintf(fout, "short ");
	251	fprintf(fout, "%s%s",
	252	sym_use(sym, sym->callsites \|\| IS(word3, func)), p);
	253	continue;
	254	}
	255	}
	256
	257	// dd offset <sym>
	258	if (IS(word, "dd")
	259	&& (IS(word2, "offset") \|\| strstr(p, "offset")))
	260	{
	261	fprintf(fout, "\t\tdd");
	262	p = next_word(word, sizeof(word), line);
	263	goto offset_loop;
	264	}
	265
	266	p = sskip(p);
	267	if (p == 0 \|\| p == ';')
	268	goto pass; // need at least 4 words
	269
	270	p = next_word(word4, sizeof(word4), p);
	271
	272	// <name> dd offset <sym>
	273	if (IS(word2, "dd")
	274	&& (IS(word3, "offset") \|\| strstr(p, "offset")))
	275	{
	276	fprintf(fout, "%s\tdd", word);
	277	p = next_word(word, sizeof(word), line);
	278	p = next_word(word, sizeof(word), p);
	279	goto offset_loop;
	280	}
	281
	282	// mov <something>, offset <sym>
	283	// jcc <some> ptr <sym>
	284	if ( (IS(word, "mov") && IS(word3, "offset"))
	285	\|\| (word[0] == 'j' && IS(word3, "ptr")) ) {
	286	ssym.name = word4;
	287	sym = bsearch(&ssym, symlist, symlist_cnt,
	288	sizeof(symlist[0]), cmp_sym);
	289	if (sym != NULL) {
	290	fprintf(fout, "\t\t%s\t%s %s %s%s",
	291	word, word2, word3,
	292	sym_use(sym, sym->callsites), p);
	293	continue;
	294	}
	295	}
	296
	297	p = sskip(p);
	298	if (p == 0 \|\| p == ';')
	299	goto pass; // need at least 5 words
	300
	301	p = next_word(word5, sizeof(word5), p);
	302
	303	p = sskip(p);
	304	if (p == 0 \|\| p == ';')
	305	goto pass; // need at least 6 words
	306
	307	p = next_word(word6, sizeof(word6), p);
	308
	309	// <op> dword ptr <something>, offset <sym>
	310	if ( IS(word2, "dword") && IS(word3, "ptr")
	311	&& IS(word5, "offset") ) {
	312	ssym.name = word6;
	313	sym = bsearch(&ssym, symlist, symlist_cnt,
	314	sizeof(symlist[0]), cmp_sym);
	315	if (sym != NULL) {
	316	fprintf(fout, "\t\t%s\tdword ptr %s offset %s%s",
	317	word, word4, sym_use(sym, sym->callsites), p);
	318	continue;
	319	}
	320	}
	321
	322	pass:
	323	fwrite(line, 1, strlen(line), fout);
	324	continue;
	325
	326	offset_loop:
	327	while (1) {
	328	p2 = next_word(word, sizeof(word), p);
	329	if (word[0] == 0 \|\| word[0] == ';') {
	330	break;
	331	}
	332	if (!IS(word, "offset")) {
	333	// pass through
	334	p2 = strstr(p, "offset");
	335	if (p2 == NULL)
	336	break;
	337	fwrite(p, 1, p2 - p, fout);
	338	p2 = next_word(word, sizeof(word), p2);
	339	}
	340	p = next_word(word, sizeof(word), p2);
	341	p2 = strchr(word, ',');
	342	if (p2)
	343	*p2 = 0;
	344
	345	ssym.name = word;
	346	sym = bsearch(&ssym, symlist, symlist_cnt,
	347	sizeof(symlist[0]), cmp_sym);
	348	fprintf(fout, " offset %s%s",
	349	(sym != NULL) ? sym_use(sym, sym->callsites) : word,
	350	p2 ? "," : "");
	351	}
	352	fprintf(fout, "%s", p);
	353	continue;
	354	}
	355
	356	for (i = 0; i < symlist_cnt; i++) {
	357	if (!symlist[i].found && !symlist[i].ignore_missing)
	358	printf("warning: sym '%s' not found\n", symlist[i].name);
	359	}
	360
	361	fclose(fin);
	362	fclose(fout);
	363
	364	return 0;
	365	}
	366
	367	// vim:ts=2:shiftwidth=2