[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>
		// jcc short <sym>
		if ( (IS(word, "push") && IS(word2, "offset"))
		  || (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 %s %s%s", word, word2,
				  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	// jcc short <sym>
	231	if ( (IS(word, "push") && IS(word2, "offset"))
	232	\|\| (word[0] == 'j' && IS(word2, "short") && !IS(word3, "exit")) ) {
	233	ssym.name = word3;
	234	sym = bsearch(&ssym, symlist, symlist_cnt,
	235	sizeof(symlist[0]), cmp_sym);
	236	if (sym != NULL) {
	237	fprintf(fout, "\t\t%s %s %s%s", word, word2,
	238	sym_use(sym, sym->callsites \|\| IS(word3, func)), p);
	239	continue;
	240	}
	241	}
	242
	243	// dd offset <sym>
	244	if (IS(word, "dd")
	245	&& (IS(word2, "offset") \|\| strstr(p, "offset")))
	246	{
	247	fprintf(fout, "\t\tdd");
	248	p = next_word(word, sizeof(word), line);
	249	goto offset_loop;
	250	}
	251
	252	p = sskip(p);
	253	if (p == 0 \|\| p == ';')
	254	goto pass; // need at least 4 words
	255
	256	p = next_word(word4, sizeof(word4), p);
	257
	258	// <name> dd offset <sym>
	259	if (IS(word2, "dd")
	260	&& (IS(word3, "offset") \|\| strstr(p, "offset")))
	261	{
	262	fprintf(fout, "%s\tdd", word);
	263	p = next_word(word, sizeof(word), line);
	264	p = next_word(word, sizeof(word), p);
	265	goto offset_loop;
	266	}
	267
	268	// mov <something>, offset <sym>
	269	// jcc <some> ptr <sym>
	270	if ( (IS(word, "mov") && IS(word3, "offset"))
	271	\|\| (word[0] == 'j' && IS(word3, "ptr")) ) {
	272	ssym.name = word4;
	273	sym = bsearch(&ssym, symlist, symlist_cnt,
	274	sizeof(symlist[0]), cmp_sym);
	275	if (sym != NULL) {
	276	fprintf(fout, "\t\t%s\t%s %s %s%s",
	277	word, word2, word3,
	278	sym_use(sym, sym->callsites), p);
	279	continue;
	280	}
	281	}
	282
	283	p = sskip(p);
	284	if (p == 0 \|\| p == ';')
	285	goto pass; // need at least 5 words
	286
	287	p = next_word(word5, sizeof(word5), p);
	288
	289	p = sskip(p);
	290	if (p == 0 \|\| p == ';')
	291	goto pass; // need at least 6 words
	292
	293	p = next_word(word6, sizeof(word6), p);
	294
	295	// <op> dword ptr <something>, offset <sym>
	296	if ( IS(word2, "dword") && IS(word3, "ptr")
	297	&& IS(word5, "offset") ) {
	298	ssym.name = word6;
	299	sym = bsearch(&ssym, symlist, symlist_cnt,
	300	sizeof(symlist[0]), cmp_sym);
	301	if (sym != NULL) {
	302	fprintf(fout, "\t\t%s\tdword ptr %s offset %s%s",
	303	word, word4, sym_use(sym, sym->callsites), p);
	304	continue;
	305	}
	306	}
	307
	308	pass:
	309	fwrite(line, 1, strlen(line), fout);
	310	continue;
	311
	312	offset_loop:
	313	while (1) {
	314	p2 = next_word(word, sizeof(word), p);
	315	if (word[0] == 0 \|\| word[0] == ';') {
	316	break;
	317	}
	318	if (!IS(word, "offset")) {
	319	// pass through
	320	p2 = strstr(p, "offset");
	321	if (p2 == NULL)
	322	break;
	323	fwrite(p, 1, p2 - p, fout);
	324	p2 = next_word(word, sizeof(word), p2);
	325	}
	326	p = next_word(word, sizeof(word), p2);
	327	p2 = strchr(word, ',');
	328	if (p2)
	329	*p2 = 0;
	330
	331	ssym.name = word;
	332	sym = bsearch(&ssym, symlist, symlist_cnt,
	333	sizeof(symlist[0]), cmp_sym);
	334	fprintf(fout, " offset %s%s",
	335	(sym != NULL) ? sym_use(sym, sym->callsites) : word,
	336	p2 ? "," : "");
	337	}
	338	fprintf(fout, "%s", p);
	339	continue;
	340	}
	341
	342	for (i = 0; i < symlist_cnt; i++) {
	343	if (!symlist[i].found && !symlist[i].ignore_missing)
	344	printf("warning: sym '%s' not found\n", symlist[i].name);
	345	}
	346
	347	fclose(fin);
	348	fclose(fout);
	349
	350	return 0;
	351	}
	352
	353	// vim:ts=2:shiftwidth=2