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

	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)
{
	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;
	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, "rm_%s\t%s%s", word, 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
			    && (sym->callsites || IS(word2, func)))
			{
				fprintf(fout, "\t\t%s\t%s%s", word,
					sym_use(sym), 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), 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")) ) {
			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;
			}
		}

		// dd offset <sym>
		if (IS(word, "dd") && IS(word2, "offset")) {
			fprintf(fout, "\t\tdd");
			strcpy(word, word3);
			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")) {
			fprintf(fout, "%s\tdd", word);
			strcpy(word, word4);
			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 && 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);
		continue;

offset_loop:
		while (1) {
			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->callsites) ? sym_use(sym) : word,
				p2 ? "," : "");

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