Module Name:    src
Committed By:   christos
Date:           Thu Mar 20 18:01:19 UTC 2014

Modified Files:
        src/sys/arch/sh3/sh3: db_disasm.c

Log Message:
kill sprintf


To generate a diff of this commit:
cvs rdiff -u -r1.21 -r1.22 src/sys/arch/sh3/sh3/db_disasm.c

Please note that diffs are not public domain; they are subject to the
copyright notices on the relevant files.

Modified files:

Index: src/sys/arch/sh3/sh3/db_disasm.c
diff -u src/sys/arch/sh3/sh3/db_disasm.c:1.21 src/sys/arch/sh3/sh3/db_disasm.c:1.22
--- src/sys/arch/sh3/sh3/db_disasm.c:1.21	Fri Jun  6 22:43:10 2008
+++ src/sys/arch/sh3/sh3/db_disasm.c	Thu Mar 20 14:01:19 2014
@@ -1,4 +1,4 @@
-/*	$NetBSD: db_disasm.c,v 1.21 2008/06/07 02:43:10 uwe Exp $	*/
+/*	$NetBSD: db_disasm.c,v 1.22 2014/03/20 18:01:19 christos Exp $	*/
 
 /*
  * Copyright (c) 1998-2000 Internet Initiative Japan Inc.
@@ -29,7 +29,7 @@
  */
 
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: db_disasm.c,v 1.21 2008/06/07 02:43:10 uwe Exp $");
+__KERNEL_RCSID(0, "$NetBSD: db_disasm.c,v 1.22 2014/03/20 18:01:19 christos Exp $");
 
 #include <sys/param.h>
 #include <sys/systm.h>
@@ -42,62 +42,62 @@ __KERNEL_RCSID(0, "$NetBSD: db_disasm.c,
 
 static uint16_t	get_insn(const void *);
 
-static void	get_opcode(const uint16_t *, char *);
+static void	get_opcode(const uint16_t *, char *, size_t);
 
-static void	f_02(const uint16_t *, char *);
-static void	f_03(const uint16_t *, char *);
-static void	f_04(const uint16_t *, char *);
-static void	f_08(const uint16_t *, char *);
-static void	f_09(const uint16_t *, char *);
-static void	f_0a(const uint16_t *, char *);
-static void	f_0b(const uint16_t *, char *);
-static void	f_0c(const uint16_t *, char *);
-static void	f_10(const uint16_t *, char *);
-static void	f_20(const uint16_t *, char *);
-static void	f_24(const uint16_t *, char *);
-static void	f_28(const uint16_t *, char *);
-static void	f_2c(const uint16_t *, char *);
-static void	f_30(const uint16_t *, char *);
-static void	f_34(const uint16_t *, char *);
-static void	f_38(const uint16_t *, char *);
-static void	f_3c(const uint16_t *, char *);
-static void	f_40(const uint16_t *, char *);
-static void	f_41(const uint16_t *, char *);
-static void	f_42(const uint16_t *, char *);
-static void	f_43(const uint16_t *, char *);
-static void	f_44(const uint16_t *, char *);
-static void	f_45(const uint16_t *, char *);
-static void	f_46(const uint16_t *, char *);
-static void	f_47(const uint16_t *, char *);
-static void	f_48(const uint16_t *, char *);
-static void	f_49(const uint16_t *, char *);
-static void	f_4a(const uint16_t *, char *);
-static void	f_4b(const uint16_t *, char *);
-static void	f_4c(const uint16_t *, char *);
-static void	f_4d(const uint16_t *, char *);
-static void	f_4e(const uint16_t *, char *);
-static void	f_4f(const uint16_t *, char *);
-static void	f_50(const uint16_t *, char *);
-static void	f_60(const uint16_t *, char *);
-static void	f_64(const uint16_t *, char *);
-static void	f_68(const uint16_t *, char *);
-static void	f_6c(const uint16_t *, char *);
-static void	f_70(const uint16_t *, char *);
-static void	f_80(const uint16_t *, char *);
-static void	f_90(const uint16_t *, char *);
-static void	f_a0(const uint16_t *, char *);
-static void	f_b0(const uint16_t *, char *);
-static void	f_c0(const uint16_t *, char *);
-static void	f_d0(const uint16_t *, char *);
-static void	f_e0(const uint16_t *, char *);
-static void	f_f0(const uint16_t *, char *);
-static void	f_f4(const uint16_t *, char *);
-static void	f_f8(const uint16_t *, char *);
-static void	f_fc(const uint16_t *, char *);
-static void	f_fd(const uint16_t *, char *);
-static void	f_fe(const uint16_t *, char *);
+static void	f_02(const uint16_t *, char *, size_t);
+static void	f_03(const uint16_t *, char *, size_t);
+static void	f_04(const uint16_t *, char *, size_t);
+static void	f_08(const uint16_t *, char *, size_t);
+static void	f_09(const uint16_t *, char *, size_t);
+static void	f_0a(const uint16_t *, char *, size_t);
+static void	f_0b(const uint16_t *, char *, size_t);
+static void	f_0c(const uint16_t *, char *, size_t);
+static void	f_10(const uint16_t *, char *, size_t);
+static void	f_20(const uint16_t *, char *, size_t);
+static void	f_24(const uint16_t *, char *, size_t);
+static void	f_28(const uint16_t *, char *, size_t);
+static void	f_2c(const uint16_t *, char *, size_t);
+static void	f_30(const uint16_t *, char *, size_t);
+static void	f_34(const uint16_t *, char *, size_t);
+static void	f_38(const uint16_t *, char *, size_t);
+static void	f_3c(const uint16_t *, char *, size_t);
+static void	f_40(const uint16_t *, char *, size_t);
+static void	f_41(const uint16_t *, char *, size_t);
+static void	f_42(const uint16_t *, char *, size_t);
+static void	f_43(const uint16_t *, char *, size_t);
+static void	f_44(const uint16_t *, char *, size_t);
+static void	f_45(const uint16_t *, char *, size_t);
+static void	f_46(const uint16_t *, char *, size_t);
+static void	f_47(const uint16_t *, char *, size_t);
+static void	f_48(const uint16_t *, char *, size_t);
+static void	f_49(const uint16_t *, char *, size_t);
+static void	f_4a(const uint16_t *, char *, size_t);
+static void	f_4b(const uint16_t *, char *, size_t);
+static void	f_4c(const uint16_t *, char *, size_t);
+static void	f_4d(const uint16_t *, char *, size_t);
+static void	f_4e(const uint16_t *, char *, size_t);
+static void	f_4f(const uint16_t *, char *, size_t);
+static void	f_50(const uint16_t *, char *, size_t);
+static void	f_60(const uint16_t *, char *, size_t);
+static void	f_64(const uint16_t *, char *, size_t);
+static void	f_68(const uint16_t *, char *, size_t);
+static void	f_6c(const uint16_t *, char *, size_t);
+static void	f_70(const uint16_t *, char *, size_t);
+static void	f_80(const uint16_t *, char *, size_t);
+static void	f_90(const uint16_t *, char *, size_t);
+static void	f_a0(const uint16_t *, char *, size_t);
+static void	f_b0(const uint16_t *, char *, size_t);
+static void	f_c0(const uint16_t *, char *, size_t);
+static void	f_d0(const uint16_t *, char *, size_t);
+static void	f_e0(const uint16_t *, char *, size_t);
+static void	f_f0(const uint16_t *, char *, size_t);
+static void	f_f4(const uint16_t *, char *, size_t);
+static void	f_f8(const uint16_t *, char *, size_t);
+static void	f_fc(const uint16_t *, char *, size_t);
+static void	f_fd(const uint16_t *, char *, size_t);
+static void	f_fe(const uint16_t *, char *, size_t);
 
-typedef	void (*rasm_t)(const uint16_t *, char *);
+typedef	void (*rasm_t)(const uint16_t *, char *, size_t);
 static	rasm_t	f[16][16] = {
 	{ /* [0][0-7] */	NULL, NULL, f_02, f_03, f_04, f_04, f_04, f_04,
 	  /* [0][8-f] */	f_08, f_09, f_0a, f_0b, f_0c, f_0c, f_0c, f_0c },
@@ -139,7 +139,7 @@ db_disasm(db_addr_t loc, bool altfmt)
 	const void *pc = (void *)loc;
 	char line[40];
 
-	get_opcode(pc, line);
+	get_opcode(pc, line, sizeof(line));
 	db_printf("%s\n", line);
 
 	return (loc + 2);
@@ -175,23 +175,23 @@ get_insn(const void *pc)
 }
 
 static void
-get_opcode(const uint16_t *pc, char *buf)
+get_opcode(const uint16_t *pc, char *buf, size_t len)
 {
 	uint16_t insn = get_insn(pc);
 	int n0, n3;
 
-	strcpy(buf, "????");
+	strlcpy(buf, "????", len);
 
 	n0 = (insn & 0xf000) >> 12;
 	n3 = (insn & 0x000f);
 
 	if (f[n0][n3] != NULL) {
-		(*f[n0][n3])(pc, buf);
+		(*f[n0][n3])(pc, buf, len);
 	}
 }
 
 static void
-f_02(const uint16_t *pc, char *buf)
+f_02(const uint16_t *pc, char *buf, size_t len)
 {
 	uint16_t insn = get_insn(pc);
 	int rn, type, md;
@@ -204,19 +204,19 @@ f_02(const uint16_t *pc, char *buf)
 	case 0:
 		switch (md) {
 		case 0:
-			sprintf(buf, "stc     sr, r%d", rn);
+			snprintf(buf, len, "stc     sr, r%d", rn);
 			break;
 
 		case 1:
-			sprintf(buf, "stc     gbr, r%d", rn);
+			snprintf(buf, len, "stc     gbr, r%d", rn);
 			break;
 
 		case 2:
-			sprintf(buf, "stc     vbr, r%d", rn);
+			snprintf(buf, len, "stc     vbr, r%d", rn);
 			break;
 
 		case 3:
-			sprintf(buf, "stc     ssr, r%d", rn);
+			snprintf(buf, len, "stc     ssr, r%d", rn);
 			break;
 
 		}
@@ -225,23 +225,23 @@ f_02(const uint16_t *pc, char *buf)
 	case 1:
 		switch (md) {
 		case 0:
-			sprintf(buf, "stc     spc, r%d", rn);
+			snprintf(buf, len, "stc     spc, r%d", rn);
 			break;
 		}
 		break;
 
 	case 2:
-		sprintf(buf, "stc     r%d_bank, r%d", md, rn);
+		snprintf(buf, len, "stc     r%d_bank, r%d", md, rn);
 		break;
 
 	case 3:
-		sprintf(buf, "stc     r%d_bank, r%d", md+4, rn);
+		snprintf(buf, len, "stc     r%d_bank, r%d", md+4, rn);
 		break;
 	} /* end of switch (type) */
 }
 
 static void
-f_03(const uint16_t *pc, char *buf)
+f_03(const uint16_t *pc, char *buf, size_t len)
 {
 	uint16_t insn = get_insn(pc);
 	int rn, type, md;
@@ -254,11 +254,11 @@ f_03(const uint16_t *pc, char *buf)
 	case 0:
 		switch (md) {
 		case 0:
-			sprintf(buf, "bsrf    r%d", rn);
+			snprintf(buf, len, "bsrf    r%d", rn);
 			break;
 
 		case 2:
-			sprintf(buf, "braf    r%d", rn);
+			snprintf(buf, len, "braf    r%d", rn);
 			break;
 		}
 		break;
@@ -266,7 +266,7 @@ f_03(const uint16_t *pc, char *buf)
 	case 2:
 		switch (md) {
 		case 0:
-			sprintf(buf, "pref    @r%d", rn);
+			snprintf(buf, len, "pref    @r%d", rn);
 			break;
 		}
 		break;
@@ -275,7 +275,7 @@ f_03(const uint16_t *pc, char *buf)
 
 
 static void
-f_04(const uint16_t *pc, char *buf)
+f_04(const uint16_t *pc, char *buf, size_t len)
 {
 	uint16_t insn = get_insn(pc);
 	int rn, rm, md;
@@ -286,25 +286,25 @@ f_04(const uint16_t *pc, char *buf)
 
 	switch (md) {
 	case 0:
-		sprintf(buf, "mov.b   r%d, @(r0, r%d)", rm, rn);
+		snprintf(buf, len, "mov.b   r%d, @(r0, r%d)", rm, rn);
 		break;
 
 	case 1:
-		sprintf(buf, "mov.w   r%d, @(r0, r%d)", rm, rn);
+		snprintf(buf, len, "mov.w   r%d, @(r0, r%d)", rm, rn);
 		break;
 
 	case 2:
-		sprintf(buf, "mov.l   r%d, @(r0, r%d)", rm, rn);
+		snprintf(buf, len, "mov.l   r%d, @(r0, r%d)", rm, rn);
 		break;
 
 	case 3:
-		sprintf(buf, "mul.l   r%d, r%d)", rm, rn);
+		snprintf(buf, len, "mul.l   r%d, r%d)", rm, rn);
 		break;
 	} /* end of switch (md) */
 }
 
 static void
-f_08(const uint16_t *pc, char *buf)
+f_08(const uint16_t *pc, char *buf, size_t len)
 {
 	uint16_t insn = get_insn(pc);
 	int n1, type, md;
@@ -320,19 +320,19 @@ f_08(const uint16_t *pc, char *buf)
 	case 0:
 		switch (md) {
 		case 0:
-			sprintf(buf, "clrt");
+			snprintf(buf, len, "clrt");
 			break;
 
 		case 1:
-			sprintf(buf, "sett");
+			snprintf(buf, len, "sett");
 			break;
 
 		case 2:
-			sprintf(buf, "clrmac");
+			snprintf(buf, len, "clrmac");
 			break;
 
 		case 3:
-			sprintf(buf, "ldtlb");
+			snprintf(buf, len, "ldtlb");
 			break;
 		}
 		break;
@@ -340,11 +340,11 @@ f_08(const uint16_t *pc, char *buf)
 	case 1:
 		switch (md) {
 		case 0:
-			sprintf(buf, "clrs");
+			snprintf(buf, len, "clrs");
 			break;
 
 		case 1:
-			sprintf(buf, "sets");
+			snprintf(buf, len, "sets");
 			break;
 		}
 		break;
@@ -352,7 +352,7 @@ f_08(const uint16_t *pc, char *buf)
 }
 
 static void
-f_09(const uint16_t *pc, char *buf)
+f_09(const uint16_t *pc, char *buf, size_t len)
 {
 	uint16_t insn = get_insn(pc);
 	int rn, fx;
@@ -364,23 +364,23 @@ f_09(const uint16_t *pc, char *buf)
 	case 0:
 		if (rn != 0)
 			return;
-		sprintf(buf, "nop");
+		snprintf(buf, len, "nop");
 		break;
 
 	case 1:
 		if (rn != 0)
 			return;
-		sprintf(buf, "div0u");
+		snprintf(buf, len, "div0u");
 		break;
 
 	case 2:
-		sprintf(buf, "movt    r%d", rn);
+		snprintf(buf, len, "movt    r%d", rn);
 		break;
 	} /* end of switch (fx) */
 }
 
 static void
-f_0a(const uint16_t *pc, char *buf)
+f_0a(const uint16_t *pc, char *buf, size_t len)
 {
 	uint16_t insn = get_insn(pc);
 	int rn, type, md;
@@ -393,15 +393,15 @@ f_0a(const uint16_t *pc, char *buf)
 	case 0:
 		switch (md) {
 		case 0:
-			sprintf(buf, "sts     mach, r%d", rn);
+			snprintf(buf, len, "sts     mach, r%d", rn);
 			break;
 
 		case 1:
-			sprintf(buf, "sts     macl, r%d", rn);
+			snprintf(buf, len, "sts     macl, r%d", rn);
 			break;
 
 		case 2:
-			sprintf(buf, "sts     pr, r%d", rn);
+			snprintf(buf, len, "sts     pr, r%d", rn);
 			break;
 		}
 		break;
@@ -409,11 +409,11 @@ f_0a(const uint16_t *pc, char *buf)
 	case 1:
 		switch (md) {
 		case 1:
-			sprintf(buf, "sts     fpul, r%d", rn);
+			snprintf(buf, len, "sts     fpul, r%d", rn);
 			break;
 
 		case 2:
-			sprintf(buf, "sts     fpscr, r%d", rn);
+			snprintf(buf, len, "sts     fpscr, r%d", rn);
 			break;
 		}
 		break;
@@ -421,7 +421,7 @@ f_0a(const uint16_t *pc, char *buf)
 }
 
 static void
-f_0b(const uint16_t *pc, char *buf)
+f_0b(const uint16_t *pc, char *buf, size_t len)
 {
 	uint16_t insn = get_insn(pc);
 	int n1, fx;
@@ -433,21 +433,21 @@ f_0b(const uint16_t *pc, char *buf)
 	fx = (insn & 0x00f0) >> 4;
 	switch (fx) {
 	case 0:
-		sprintf(buf, "rts");
+		snprintf(buf, len, "rts");
 		break;
 
 	case 1:
-		sprintf(buf, "sleep");
+		snprintf(buf, len, "sleep");
 		break;
 
 	case 2:
-		sprintf(buf, "rte");
+		snprintf(buf, len, "rte");
 		break;
 	} /* end of switch (fx) */
 }
 
 static void
-f_0c(const uint16_t *pc, char *buf)
+f_0c(const uint16_t *pc, char *buf, size_t len)
 {
 	uint16_t insn = get_insn(pc);
 	int rn, rm, md;
@@ -458,25 +458,25 @@ f_0c(const uint16_t *pc, char *buf)
 
 	switch (md) {
 	case 0:
-		sprintf(buf, "mov.b   @(r0, r%d), r%d", rm, rn);
+		snprintf(buf, len, "mov.b   @(r0, r%d), r%d", rm, rn);
 		break;
 
 	case 1:
-		sprintf(buf, "mov.w   @(r0, r%d), r%d", rm, rn);
+		snprintf(buf, len, "mov.w   @(r0, r%d), r%d", rm, rn);
 		break;
 
 	case 2:
-		sprintf(buf, "mov.l   @(r0, r%d), r%d", rm, rn);
+		snprintf(buf, len, "mov.l   @(r0, r%d), r%d", rm, rn);
 		break;
 
 	case 3:
-		sprintf(buf, "mac.l   @r%d+, r%d+", rm, rn);
+		snprintf(buf, len, "mac.l   @r%d+, r%d+", rm, rn);
 		break;
 	} /* end of switch (md) */
 }
 
 static void
-f_10(const uint16_t *pc, char *buf)
+f_10(const uint16_t *pc, char *buf, size_t len)
 {
 	uint16_t insn = get_insn(pc);
 	int rn, rm, disp;
@@ -486,11 +486,11 @@ f_10(const uint16_t *pc, char *buf)
 	disp = (insn & 0x000f);
 	disp *= 4;
 
-	sprintf(buf, "mov.l   r%d, @(%d, r%d)", rm, disp, rn);
+	snprintf(buf, len, "mov.l   r%d, @(%d, r%d)", rm, disp, rn);
 }
 
 static void
-f_20(const uint16_t *pc, char *buf)
+f_20(const uint16_t *pc, char *buf, size_t len)
 {
 	uint16_t insn = get_insn(pc);
 	int rn, rm, md;
@@ -501,22 +501,22 @@ f_20(const uint16_t *pc, char *buf)
 
 	switch (md) {
 	case 0:
-		sprintf(buf, "mov.b   r%d, @r%d", rm, rn);
+		snprintf(buf, len, "mov.b   r%d, @r%d", rm, rn);
 		break;
 
 	case 1:
-		sprintf(buf, "mov.w   r%d, @r%d", rm, rn);
+		snprintf(buf, len, "mov.w   r%d, @r%d", rm, rn);
 		break;
 
 	case 2:
-		sprintf(buf, "mov.l   r%d, @r%d", rm, rn);
+		snprintf(buf, len, "mov.l   r%d, @r%d", rm, rn);
 		break;
 	} /* end of switch (md) */
 }
 
 
 static void
-f_24(const uint16_t *pc, char *buf)
+f_24(const uint16_t *pc, char *buf, size_t len)
 {
 	uint16_t insn = get_insn(pc);
 	int rn, rm, md;
@@ -527,25 +527,25 @@ f_24(const uint16_t *pc, char *buf)
 
 	switch (md) {
 	case 0:
-		sprintf(buf, "mov.b   r%d, @-r%d", rm, rn);
+		snprintf(buf, len, "mov.b   r%d, @-r%d", rm, rn);
 		break;
 
 	case 1:
-		sprintf(buf, "mov.w   r%d, @-r%d", rm, rn);
+		snprintf(buf, len, "mov.w   r%d, @-r%d", rm, rn);
 		break;
 
 	case 2:
-		sprintf(buf, "mov.l   r%d, @-r%d", rm, rn);
+		snprintf(buf, len, "mov.l   r%d, @-r%d", rm, rn);
 		break;
 
 	case 3:
-		sprintf(buf, "div0s   r%d, r%d)", rm, rn);
+		snprintf(buf, len, "div0s   r%d, r%d)", rm, rn);
 		break;
 	} /* end of switch (md) */
 }
 
 static void
-f_28(const uint16_t *pc, char *buf)
+f_28(const uint16_t *pc, char *buf, size_t len)
 {
 	uint16_t insn = get_insn(pc);
 	int rn, rm, md;
@@ -556,26 +556,26 @@ f_28(const uint16_t *pc, char *buf)
 
 	switch (md) {
 	case 0:
-		sprintf(buf, "tst     r%d, r%d", rm, rn);
+		snprintf(buf, len, "tst     r%d, r%d", rm, rn);
 		break;
 
 	case 1:
-		sprintf(buf, "and     r%d, r%d", rm, rn);
+		snprintf(buf, len, "and     r%d, r%d", rm, rn);
 		break;
 
 	case 2:
-		sprintf(buf, "xor     r%d, r%d", rm, rn);
+		snprintf(buf, len, "xor     r%d, r%d", rm, rn);
 		break;
 
 	case 3:
-		sprintf(buf, "or      r%d, r%d", rm, rn);
+		snprintf(buf, len, "or      r%d, r%d", rm, rn);
 		break;
 	} /* end of switch (md) */
 }
 
 
 static void
-f_2c(const uint16_t *pc, char *buf)
+f_2c(const uint16_t *pc, char *buf, size_t len)
 {
 	uint16_t insn = get_insn(pc);
 	int rn, rm, md;
@@ -586,25 +586,25 @@ f_2c(const uint16_t *pc, char *buf)
 
 	switch (md) {
 	case 0:
-		sprintf(buf, "cmp/str r%d, r%d", rm, rn);
+		snprintf(buf, len, "cmp/str r%d, r%d", rm, rn);
 		break;
 
 	case 1:
-		sprintf(buf, "xtrct   r%d, r%d", rm, rn);
+		snprintf(buf, len, "xtrct   r%d, r%d", rm, rn);
 		break;
 
 	case 2:
-		sprintf(buf, "mulu.w  r%d, r%d", rm, rn);
+		snprintf(buf, len, "mulu.w  r%d, r%d", rm, rn);
 		break;
 
 	case 3:
-		sprintf(buf, "muls.w  r%d, r%d", rm, rn);
+		snprintf(buf, len, "muls.w  r%d, r%d", rm, rn);
 		break;
 	} /* end of switch (md) */
 }
 
 static void
-f_30(const uint16_t *pc, char *buf)
+f_30(const uint16_t *pc, char *buf, size_t len)
 {
 	uint16_t insn = get_insn(pc);
 	int rn, rm, md;
@@ -615,22 +615,22 @@ f_30(const uint16_t *pc, char *buf)
 
 	switch (md) {
 	case 0:
-		sprintf(buf, "cmp/eq  r%d, r%d", rm, rn);
+		snprintf(buf, len, "cmp/eq  r%d, r%d", rm, rn);
 		break;
 
 	case 2:
-		sprintf(buf, "cmp/hs  r%d, r%d", rm, rn);
+		snprintf(buf, len, "cmp/hs  r%d, r%d", rm, rn);
 		break;
 
 	case 3:
-		sprintf(buf, "cmp/ge  r%d, r%d", rm, rn);
+		snprintf(buf, len, "cmp/ge  r%d, r%d", rm, rn);
 		break;
 	} /* end of switch (md) */
 }
 
 
 static void
-f_34(const uint16_t *pc, char *buf)
+f_34(const uint16_t *pc, char *buf, size_t len)
 {
 	uint16_t insn = get_insn(pc);
 	int rn, rm, md;
@@ -641,25 +641,25 @@ f_34(const uint16_t *pc, char *buf)
 
 	switch (md) {
 	case 0:
-		sprintf(buf, "div1    r%d, r%d", rm, rn);
+		snprintf(buf, len, "div1    r%d, r%d", rm, rn);
 		break;
 
 	case 1:
-		sprintf(buf, "dmulu.l r%d, r%d", rm, rn);
+		snprintf(buf, len, "dmulu.l r%d, r%d", rm, rn);
 		break;
 
 	case 2:
-		sprintf(buf, "cmp/hi  r%d, r%d", rm, rn);
+		snprintf(buf, len, "cmp/hi  r%d, r%d", rm, rn);
 		break;
 
 	case 3:
-		sprintf(buf, "cmp/gt  r%d, r%d", rm, rn);
+		snprintf(buf, len, "cmp/gt  r%d, r%d", rm, rn);
 		break;
 	} /* end of switch (md) */
 }
 
 static void
-f_38(const uint16_t *pc, char *buf)
+f_38(const uint16_t *pc, char *buf, size_t len)
 {
 	uint16_t insn = get_insn(pc);
 	int rn, rm, md;
@@ -670,22 +670,22 @@ f_38(const uint16_t *pc, char *buf)
 
 	switch (md) {
 	case 0:
-		sprintf(buf, "sub     r%d, r%d", rm, rn);
+		snprintf(buf, len, "sub     r%d, r%d", rm, rn);
 		break;
 
 	case 2:
-		sprintf(buf, "subc    r%d, r%d", rm, rn);
+		snprintf(buf, len, "subc    r%d, r%d", rm, rn);
 		break;
 
 	case 3:
-		sprintf(buf, "subv    r%d, r%d", rm, rn);
+		snprintf(buf, len, "subv    r%d, r%d", rm, rn);
 		break;
 	} /* end of switch (md) */
 }
 
 
 static void
-f_3c(const uint16_t *pc, char *buf)
+f_3c(const uint16_t *pc, char *buf, size_t len)
 {
 	uint16_t insn = get_insn(pc);
 	int rn, rm, md;
@@ -696,26 +696,26 @@ f_3c(const uint16_t *pc, char *buf)
 
 	switch (md) {
 	case 0:
-		sprintf(buf, "add     r%d, r%d", rm, rn);
+		snprintf(buf, len, "add     r%d, r%d", rm, rn);
 		break;
 
 	case 1:
-		sprintf(buf, "dmulu.l r%d, r%d", rm, rn);
+		snprintf(buf, len, "dmulu.l r%d, r%d", rm, rn);
 		break;
 
 	case 2:
-		sprintf(buf, "addc    r%d, r%d", rm, rn);
+		snprintf(buf, len, "addc    r%d, r%d", rm, rn);
 		break;
 
 	case 3:
-		sprintf(buf, "addv    r%d, r%d", rm, rn);
+		snprintf(buf, len, "addv    r%d, r%d", rm, rn);
 		break;
 	} /* end of switch (md) */
 }
 
 
 static void
-f_40(const uint16_t *pc, char *buf)
+f_40(const uint16_t *pc, char *buf, size_t len)
 {
 	uint16_t insn = get_insn(pc);
 	int rn, fx;
@@ -725,21 +725,21 @@ f_40(const uint16_t *pc, char *buf)
 
 	switch (fx) {
 	case 0:
-		sprintf(buf, "shll    r%d", rn);
+		snprintf(buf, len, "shll    r%d", rn);
 		break;
 
 	case 1:
-		sprintf(buf, "dt      r%d", rn);
+		snprintf(buf, len, "dt      r%d", rn);
 		break;
 
 	case 2:
-		sprintf(buf, "shal    r%d", rn);
+		snprintf(buf, len, "shal    r%d", rn);
 		break;
 	} /* end of switch (fx) */
 }
 
 static void
-f_41(const uint16_t *pc, char *buf)
+f_41(const uint16_t *pc, char *buf, size_t len)
 {
 	uint16_t insn = get_insn(pc);
 	int rn, fx;
@@ -749,22 +749,22 @@ f_41(const uint16_t *pc, char *buf)
 
 	switch (fx) {
 	case 0:
-		sprintf(buf, "shlr    r%d", rn);
+		snprintf(buf, len, "shlr    r%d", rn);
 		break;
 
 	case 1:
-		sprintf(buf, "cmp/pz  r%d", rn);
+		snprintf(buf, len, "cmp/pz  r%d", rn);
 		break;
 
 	case 2:
-		sprintf(buf, "shar    r%d", rn);
+		snprintf(buf, len, "shar    r%d", rn);
 		break;
 	} /* end of switch (fx) */
 }
 
 
 static void
-f_42(const uint16_t *pc, char *buf)
+f_42(const uint16_t *pc, char *buf, size_t len)
 {
 	uint16_t insn = get_insn(pc);
 	int rn, type, md;
@@ -777,15 +777,15 @@ f_42(const uint16_t *pc, char *buf)
 	case 0:
 		switch (md) {
 		case 0:
-			sprintf(buf, "sts.l   mach, @-r%d", rn);
+			snprintf(buf, len, "sts.l   mach, @-r%d", rn);
 			break;
 
 		case 1:
-			sprintf(buf, "sts.l   macl, @-r%d", rn);
+			snprintf(buf, len, "sts.l   macl, @-r%d", rn);
 			break;
 
 		case 2:
-			sprintf(buf, "sts.l   pr, @-r%d", rn);
+			snprintf(buf, len, "sts.l   pr, @-r%d", rn);
 			break;
 		}
 		break;
@@ -793,11 +793,11 @@ f_42(const uint16_t *pc, char *buf)
 	case 1:
 		switch (md) {
 		case 1:
-			sprintf(buf, "sts.l   fpul, @-r%d", rn);
+			snprintf(buf, len, "sts.l   fpul, @-r%d", rn);
 			break;
 
 		case 2:
-			sprintf(buf, "sts.l   fpscr, @-r%d", rn);
+			snprintf(buf, len, "sts.l   fpscr, @-r%d", rn);
 			break;
 		}
 		break;
@@ -805,7 +805,7 @@ f_42(const uint16_t *pc, char *buf)
 }
 
 static void
-f_43(const uint16_t *pc, char *buf)
+f_43(const uint16_t *pc, char *buf, size_t len)
 {
 	uint16_t insn = get_insn(pc);
 	int rn, type, md;
@@ -818,19 +818,19 @@ f_43(const uint16_t *pc, char *buf)
 	case 0:
 		switch (md) {
 		case 0:
-			sprintf(buf, "stc.l   sr, @-r%d", rn);
+			snprintf(buf, len, "stc.l   sr, @-r%d", rn);
 			break;
 
 		case 1:
-			sprintf(buf, "stc.l   gbr, @-r%d", rn);
+			snprintf(buf, len, "stc.l   gbr, @-r%d", rn);
 			break;
 
 		case 2:
-			sprintf(buf, "stc.l   vbr, @-r%d", rn);
+			snprintf(buf, len, "stc.l   vbr, @-r%d", rn);
 			break;
 
 		case 3:
-			sprintf(buf, "stc.l   ssr, @-r%d", rn);
+			snprintf(buf, len, "stc.l   ssr, @-r%d", rn);
 			break;
 		}
 		break;
@@ -838,23 +838,23 @@ f_43(const uint16_t *pc, char *buf)
 	case 1:
 		switch (md) {
 		case 0:
-			sprintf(buf, "stc.l   spc, @-r%d", rn);
+			snprintf(buf, len, "stc.l   spc, @-r%d", rn);
 			break;
 		}
 		break;
 
 	case 2:
-		sprintf(buf, "stc.l   r%d_bank, @-r%d", md, rn);
+		snprintf(buf, len, "stc.l   r%d_bank, @-r%d", md, rn);
 		break;
 
 	case 3:
-		sprintf(buf, "stc.l   r%d_bank, @-r%d", md+4, rn);
+		snprintf(buf, len, "stc.l   r%d_bank, @-r%d", md+4, rn);
 		break;
 	} /* end of switch (type) */
 }
 
 static void
-f_44(const uint16_t *pc, char *buf)
+f_44(const uint16_t *pc, char *buf, size_t len)
 {
 	uint16_t insn = get_insn(pc);
 	int rn, fx;
@@ -864,17 +864,17 @@ f_44(const uint16_t *pc, char *buf)
 
 	switch (fx) {
 	case 0:
-		sprintf(buf, "rotl    r%d", rn);
+		snprintf(buf, len, "rotl    r%d", rn);
 		break;
 
 	case 2:
-		sprintf(buf, "rotcl   r%d", rn);
+		snprintf(buf, len, "rotcl   r%d", rn);
 		break;
 	} /* end of switch (fx) */
 }
 
 static void
-f_45(const uint16_t *pc, char *buf)
+f_45(const uint16_t *pc, char *buf, size_t len)
 {
 	uint16_t insn = get_insn(pc);
 	int rn, fx;
@@ -884,21 +884,21 @@ f_45(const uint16_t *pc, char *buf)
 
 	switch (fx) {
 	case 0:
-		sprintf(buf, "rotr    r%d", rn);
+		snprintf(buf, len, "rotr    r%d", rn);
 		break;
 
 	case 1:
-		sprintf(buf, "cmp/pl  r%d", rn);
+		snprintf(buf, len, "cmp/pl  r%d", rn);
 		break;
 
 	case 2:
-		sprintf(buf, "rotcr   r%d", rn);
+		snprintf(buf, len, "rotcr   r%d", rn);
 		break;
 	} /* end of switch (fx) */
 }
 
 static void
-f_46(const uint16_t *pc, char *buf)
+f_46(const uint16_t *pc, char *buf, size_t len)
 {
 	uint16_t insn = get_insn(pc);
 	int rm, type, md;
@@ -911,15 +911,15 @@ f_46(const uint16_t *pc, char *buf)
 	case 0:
 		switch (md) {
 		case 0:
-			sprintf(buf, "lds.l   @r%d+, mach", rm);
+			snprintf(buf, len, "lds.l   @r%d+, mach", rm);
 			break;
 
 		case 1:
-			sprintf(buf, "lds.l   @r%d+, macl", rm);
+			snprintf(buf, len, "lds.l   @r%d+, macl", rm);
 			break;
 
 		case 2:
-			sprintf(buf, "lds.l   @r%d+, pr", rm);
+			snprintf(buf, len, "lds.l   @r%d+, pr", rm);
 			break;
 		}
 		break;
@@ -927,11 +927,11 @@ f_46(const uint16_t *pc, char *buf)
 	case 1:
 		switch (md) {
 		case 1:
-			sprintf(buf, "lds.l   @r%d+, fpul", rm);
+			snprintf(buf, len, "lds.l   @r%d+, fpul", rm);
 			break;
 
 		case 2:
-			sprintf(buf, "lds.l   @r%d+, fpscr", rm);
+			snprintf(buf, len, "lds.l   @r%d+, fpscr", rm);
 			break;
 		}
 		break;
@@ -939,7 +939,7 @@ f_46(const uint16_t *pc, char *buf)
 }
 
 static void
-f_47(const uint16_t *pc, char *buf)
+f_47(const uint16_t *pc, char *buf, size_t len)
 {
 	uint16_t insn = get_insn(pc);
 	int rm, type, md;
@@ -952,19 +952,19 @@ f_47(const uint16_t *pc, char *buf)
 	case 0:
 		switch (md) {
 		case 0:
-			sprintf(buf, "ldc.l   @r%d+, sr", rm);
+			snprintf(buf, len, "ldc.l   @r%d+, sr", rm);
 			break;
 
 		case 1:
-			sprintf(buf, "ldc.l   @r%d+, gbr", rm);
+			snprintf(buf, len, "ldc.l   @r%d+, gbr", rm);
 			break;
 
 		case 2:
-			sprintf(buf, "ldc.l   @r%d+, vbr", rm);
+			snprintf(buf, len, "ldc.l   @r%d+, vbr", rm);
 			break;
 
 		case 3:
-			sprintf(buf, "ldc.l   @r%d+, ssr", rm);
+			snprintf(buf, len, "ldc.l   @r%d+, ssr", rm);
 			break;
 		}
 		break;
@@ -972,23 +972,23 @@ f_47(const uint16_t *pc, char *buf)
 	case 1:
 		switch (md) {
 		case 0:
-			sprintf(buf, "ldc.l   @r%d+, spc", rm);
+			snprintf(buf, len, "ldc.l   @r%d+, spc", rm);
 			break;
 		}
 		break;
 
 	case 2:
-		sprintf(buf, "ldc.l   @r%d+, r%d_bank", rm, md);
+		snprintf(buf, len, "ldc.l   @r%d+, r%d_bank", rm, md);
 		break;
 
 	case 3:
-		sprintf(buf, "ldc.l   @r%d+, r%d_bank", rm, md+4);
+		snprintf(buf, len, "ldc.l   @r%d+, r%d_bank", rm, md+4);
 		break;
 	} /* end of switch (type) */
 }
 
 static void
-f_48(const uint16_t *pc, char *buf)
+f_48(const uint16_t *pc, char *buf, size_t len)
 {
 	uint16_t insn = get_insn(pc);
 	int rn, fx;
@@ -998,21 +998,21 @@ f_48(const uint16_t *pc, char *buf)
 
 	switch (fx) {
 	case 0:
-		sprintf(buf, "shll2   r%d", rn);
+		snprintf(buf, len, "shll2   r%d", rn);
 		break;
 
 	case 1:
-		sprintf(buf, "shll8   r%d", rn);
+		snprintf(buf, len, "shll8   r%d", rn);
 		break;
 
 	case 2:
-		sprintf(buf, "shll16  r%d", rn);
+		snprintf(buf, len, "shll16  r%d", rn);
 		break;
 	} /* end of switch (fx) */
 }
 
 static void
-f_49(const uint16_t *pc, char *buf)
+f_49(const uint16_t *pc, char *buf, size_t len)
 {
 	uint16_t insn = get_insn(pc);
 	int rn, fx;
@@ -1022,21 +1022,21 @@ f_49(const uint16_t *pc, char *buf)
 
 	switch (fx) {
 	case 0:
-		sprintf(buf, "shlr2   r%d", rn);
+		snprintf(buf, len, "shlr2   r%d", rn);
 		break;
 
 	case 1:
-		sprintf(buf, "shlr8   r%d", rn);
+		snprintf(buf, len, "shlr8   r%d", rn);
 		break;
 
 	case 2:
-		sprintf(buf, "shlr16  r%d", rn);
+		snprintf(buf, len, "shlr16  r%d", rn);
 		break;
 	} /* end of switch (fx) */
 }
 
 static void
-f_4a(const uint16_t *pc, char *buf)
+f_4a(const uint16_t *pc, char *buf, size_t len)
 {
 	uint16_t insn = get_insn(pc);
 	int rm, type, md;
@@ -1049,15 +1049,15 @@ f_4a(const uint16_t *pc, char *buf)
 	case 0:
 		switch (md) {
 		case 0:
-			sprintf(buf, "lds     r%d, mach", rm);
+			snprintf(buf, len, "lds     r%d, mach", rm);
 			break;
 
 		case 1:
-			sprintf(buf, "lds     r%d, macl", rm);
+			snprintf(buf, len, "lds     r%d, macl", rm);
 			break;
 
 		case 2:
-			sprintf(buf, "lds     r%d, pr", rm);
+			snprintf(buf, len, "lds     r%d, pr", rm);
 			break;
 		}
 		break;
@@ -1065,11 +1065,11 @@ f_4a(const uint16_t *pc, char *buf)
 	case 1:
 		switch (md) {
 		case 1:
-			sprintf(buf, "lds     r%d, fpul", rm);
+			snprintf(buf, len, "lds     r%d, fpul", rm);
 			break;
 
 		case 2:
-			sprintf(buf, "lds     r%d, fpscr", rm);
+			snprintf(buf, len, "lds     r%d, fpscr", rm);
 			break;
 		}
 		break;
@@ -1077,7 +1077,7 @@ f_4a(const uint16_t *pc, char *buf)
 }
 
 static void
-f_4b(const uint16_t *pc, char *buf)
+f_4b(const uint16_t *pc, char *buf, size_t len)
 {
 	uint16_t insn = get_insn(pc);
 	int rm, fx;
@@ -1087,43 +1087,43 @@ f_4b(const uint16_t *pc, char *buf)
 
 	switch (fx) {
 	case 0:
-		sprintf(buf, "jsr     @r%d", rm);
+		snprintf(buf, len, "jsr     @r%d", rm);
 		break;
 
 	case 1:
-		sprintf(buf, "tas.b   @r%d", rm);
+		snprintf(buf, len, "tas.b   @r%d", rm);
 		break;
 
 	case 2:
-		sprintf(buf, "jmp     @r%d", rm);
+		snprintf(buf, len, "jmp     @r%d", rm);
 		break;
 	} /* end of switch (fx) */
 }
 
 static void
-f_4c(const uint16_t *pc, char *buf)
+f_4c(const uint16_t *pc, char *buf, size_t len)
 {
 	uint16_t insn = get_insn(pc);
 	int rn, rm;
 
 	rn   = (insn & 0x0f00) >> 8;
 	rm   = (insn & 0x00f0) >> 4;
-	sprintf(buf, "shad    r%d, r%d", rm, rn);
+	snprintf(buf, len, "shad    r%d, r%d", rm, rn);
 }
 
 static void
-f_4d(const uint16_t *pc, char *buf)
+f_4d(const uint16_t *pc, char *buf, size_t len)
 {
 	uint16_t insn = get_insn(pc);
 	int rn, rm;
 
 	rn   = (insn & 0x0f00) >> 8;
 	rm   = (insn & 0x00f0) >> 4;
-	sprintf(buf, "shld    r%d, r%d", rm, rn);
+	snprintf(buf, len, "shld    r%d, r%d", rm, rn);
 }
 
 static void
-f_4e(const uint16_t *pc, char *buf)
+f_4e(const uint16_t *pc, char *buf, size_t len)
 {
 	uint16_t insn = get_insn(pc);
 	int rm, type, md;
@@ -1136,19 +1136,19 @@ f_4e(const uint16_t *pc, char *buf)
 	case 0:
 		switch (md) {
 		case 0:
-			sprintf(buf, "ldc     r%d, sr", rm);
+			snprintf(buf, len, "ldc     r%d, sr", rm);
 			break;
 
 		case 1:
-			sprintf(buf, "ldc     r%d, gbr", rm);
+			snprintf(buf, len, "ldc     r%d, gbr", rm);
 			break;
 
 		case 2:
-			sprintf(buf, "ldc     r%d, vbr", rm);
+			snprintf(buf, len, "ldc     r%d, vbr", rm);
 			break;
 
 		case 3:
-			sprintf(buf, "ldc     r%d, ssr", rm);
+			snprintf(buf, len, "ldc     r%d, ssr", rm);
 			break;
 		}
 		break;
@@ -1156,34 +1156,34 @@ f_4e(const uint16_t *pc, char *buf)
 	case 1:
 		switch (md) {
 		case 0:
-			sprintf(buf, "ldc     r%d, spc", rm);
+			snprintf(buf, len, "ldc     r%d, spc", rm);
 			break;
 		}
 		break;
 
 	case 2:
-		sprintf(buf, "ldc     r%d, r%d_bank", rm, md);
+		snprintf(buf, len, "ldc     r%d, r%d_bank", rm, md);
 		break;
 
 	case 3:
-		sprintf(buf, "ldc     r%d, r%d_bank", rm, md+4);
+		snprintf(buf, len, "ldc     r%d, r%d_bank", rm, md+4);
 		break;
 	} /* end of switch (type) */
 }
 
 static void
-f_4f(const uint16_t *pc, char *buf)
+f_4f(const uint16_t *pc, char *buf, size_t len)
 {
 	uint16_t insn = get_insn(pc);
 	int rn, rm;
 
 	rn   = (insn & 0x0f00) >> 8;
 	rm   = (insn & 0x00f0) >> 4;
-	sprintf(buf, "mac.w   @r%d+, @r%d+", rm, rn);
+	snprintf(buf, len, "mac.w   @r%d+, @r%d+", rm, rn);
 }
 
 static void
-f_50(const uint16_t *pc, char *buf)
+f_50(const uint16_t *pc, char *buf, size_t len)
 {
 	uint16_t insn = get_insn(pc);
 	int rn, rm, disp;
@@ -1193,11 +1193,11 @@ f_50(const uint16_t *pc, char *buf)
 	disp = (insn & 0x000f);
 	disp *= 4;
 
-	sprintf(buf, "mov.l   @(%d, r%d), r%d", disp, rm, rn);
+	snprintf(buf, len, "mov.l   @(%d, r%d), r%d", disp, rm, rn);
 }
 
 static void
-f_60(const uint16_t *pc, char *buf)
+f_60(const uint16_t *pc, char *buf, size_t len)
 {
 	uint16_t insn = get_insn(pc);
 	int rn, rm, md;
@@ -1208,25 +1208,25 @@ f_60(const uint16_t *pc, char *buf)
 
 	switch (md) {
 	case 0:
-		sprintf(buf, "mov.b   @r%d, r%d", rm, rn);
+		snprintf(buf, len, "mov.b   @r%d, r%d", rm, rn);
 		break;
 
 	case 1:
-		sprintf(buf, "mov.w   @r%d, r%d", rm, rn);
+		snprintf(buf, len, "mov.w   @r%d, r%d", rm, rn);
 		break;
 
 	case 2:
-		sprintf(buf, "mov.l   @r%d, r%d", rm, rn);
+		snprintf(buf, len, "mov.l   @r%d, r%d", rm, rn);
 		break;
 
 	case 3:
-		sprintf(buf, "mov     r%d, r%d", rm, rn);
+		snprintf(buf, len, "mov     r%d, r%d", rm, rn);
 		break;
 	} /* end of switch (md) */
 }
 
 static void
-f_64(const uint16_t *pc, char *buf)
+f_64(const uint16_t *pc, char *buf, size_t len)
 {
 	uint16_t insn = get_insn(pc);
 	int rn, rm, md;
@@ -1237,25 +1237,25 @@ f_64(const uint16_t *pc, char *buf)
 
 	switch (md) {
 	case 0:
-		sprintf(buf, "mov.b   @r%d+, r%d", rm, rn);
+		snprintf(buf, len, "mov.b   @r%d+, r%d", rm, rn);
 		break;
 
 	case 1:
-		sprintf(buf, "mov.w   @r%d+, r%d", rm, rn);
+		snprintf(buf, len, "mov.w   @r%d+, r%d", rm, rn);
 		break;
 
 	case 2:
-		sprintf(buf, "mov.l   @r%d+, r%d", rm, rn);
+		snprintf(buf, len, "mov.l   @r%d+, r%d", rm, rn);
 		break;
 
 	case 3:
-		sprintf(buf, "not     r%d, r%d", rm, rn);
+		snprintf(buf, len, "not     r%d, r%d", rm, rn);
 		break;
 	} /* end of switch (md) */
 }
 
 static void
-f_68(const uint16_t *pc, char *buf)
+f_68(const uint16_t *pc, char *buf, size_t len)
 {
 	uint16_t insn = get_insn(pc);
 	int rn, rm, md;
@@ -1266,25 +1266,25 @@ f_68(const uint16_t *pc, char *buf)
 
 	switch (md) {
 	case 0:
-		sprintf(buf, "swap.b  r%d, r%d", rm, rn);
+		snprintf(buf, len, "swap.b  r%d, r%d", rm, rn);
 		break;
 
 	case 1:
-		sprintf(buf, "swap.w  r%d, r%d", rm, rn);
+		snprintf(buf, len, "swap.w  r%d, r%d", rm, rn);
 		break;
 
 	case 2:
-		sprintf(buf, "negc    r%d, r%d", rm, rn);
+		snprintf(buf, len, "negc    r%d, r%d", rm, rn);
 		break;
 
 	case 3:
-		sprintf(buf, "neg     r%d, r%d", rm, rn);
+		snprintf(buf, len, "neg     r%d, r%d", rm, rn);
 		break;
 	} /* end of switch (md) */
 }
 
 static void
-f_6c(const uint16_t *pc, char *buf)
+f_6c(const uint16_t *pc, char *buf, size_t len)
 {
 	uint16_t insn = get_insn(pc);
 	int rn, rm, md;
@@ -1295,25 +1295,25 @@ f_6c(const uint16_t *pc, char *buf)
 
 	switch (md) {
 	case 0:
-		sprintf(buf, "extu.b  r%d, r%d", rm, rn);
+		snprintf(buf, len, "extu.b  r%d, r%d", rm, rn);
 		break;
 
 	case 1:
-		sprintf(buf, "extu.w  r%d, r%d", rm, rn);
+		snprintf(buf, len, "extu.w  r%d, r%d", rm, rn);
 		break;
 
 	case 2:
-		sprintf(buf, "exts.b  r%d, r%d", rm, rn);
+		snprintf(buf, len, "exts.b  r%d, r%d", rm, rn);
 		break;
 
 	case 3:
-		sprintf(buf, "exts.w  r%d, r%d", rm, rn);
+		snprintf(buf, len, "exts.w  r%d, r%d", rm, rn);
 		break;
 	} /* end of switch (md) */
 }
 
 static void
-f_70(const uint16_t *pc, char *buf)
+f_70(const uint16_t *pc, char *buf, size_t len)
 {
 	uint16_t insn = get_insn(pc);
 	int rn, imm;
@@ -1321,11 +1321,11 @@ f_70(const uint16_t *pc, char *buf)
 	rn   = (insn & 0x0f00) >> 8;
 	imm  = (int) ((char) (insn & 0x00ff));
 
-	sprintf(buf, "add     #0x%x, r%d", imm, rn);
+	snprintf(buf, len, "add     #0x%x, r%d", imm, rn);
 }
 
 static void
-f_80(const uint16_t *pc, char *buf)
+f_80(const uint16_t *pc, char *buf, size_t len)
 {
 	uint16_t insn = get_insn(pc);
 	int type, md, rn, disp;
@@ -1340,12 +1340,12 @@ f_80(const uint16_t *pc, char *buf)
 
 		switch (md) {
 		case 0:
-			sprintf(buf, "mov.b   r0, @(%d, r%d)", disp, rn);
+			snprintf(buf, len, "mov.b   r0, @(%d, r%d)", disp, rn);
 			break;
 
 		case 1:
 			disp *= 2;
-			sprintf(buf, "mov.w   r0, @(%d, r%d)", disp, rn);
+			snprintf(buf, len, "mov.w   r0, @(%d, r%d)", disp, rn);
 			break;
 		}
 		break;
@@ -1356,12 +1356,12 @@ f_80(const uint16_t *pc, char *buf)
 
 		switch (md) {
 		case 0:
-			sprintf(buf, "mov.b   @(%d, r%d), r0", disp, rn);
+			snprintf(buf, len, "mov.b   @(%d, r%d), r0", disp, rn);
 			break;
 
 		case 1:
 			disp *= 2;
-			sprintf(buf, "mov.w   @(%d, r%d), r0", disp, rn);
+			snprintf(buf, len, "mov.w   @(%d, r%d), r0", disp, rn);
 			break;
 		}
 		break;
@@ -1371,19 +1371,19 @@ f_80(const uint16_t *pc, char *buf)
 
 		switch (md) {
 		case 0:
-			sprintf(buf, "cmp/eq  #%d, r0", disp);
+			snprintf(buf, len, "cmp/eq  #%d, r0", disp);
 			break;
 
 		case 1:
 			disp = (int) ((char) disp);
 			disp *= 2;
-			sprintf(buf, "bt      0x%x", disp);
+			snprintf(buf, len, "bt      0x%x", disp);
 			break;
 
 		case 3:
 			disp = (int) ((char) disp);
 			disp *= 2;
-			sprintf(buf, "bf      0x%x", disp);
+			snprintf(buf, len, "bf      0x%x", disp);
 			break;
 		}
 		break;
@@ -1394,11 +1394,11 @@ f_80(const uint16_t *pc, char *buf)
 
 		switch (md) {
 		case 1:
-			sprintf(buf, "bt/s    0x%x", disp);
+			snprintf(buf, len, "bt/s    0x%x", disp);
 			break;
 
 		case 3:
-			sprintf(buf, "bf/s    0x%x", disp);
+			snprintf(buf, len, "bf/s    0x%x", disp);
 			break;
 		}
 		break;
@@ -1406,7 +1406,7 @@ f_80(const uint16_t *pc, char *buf)
 }
 
 static void
-f_90(const uint16_t *pc, char *buf)
+f_90(const uint16_t *pc, char *buf, size_t len)
 {
 	uint16_t insn = get_insn(pc);
 	int rn, disp;
@@ -1415,11 +1415,11 @@ f_90(const uint16_t *pc, char *buf)
 	disp = (insn & 0x00ff);
 	disp *= 2;
 
-	sprintf(buf, "mov.w   @(%d, pc), r%d", disp, rn);
+	snprintf(buf, len, "mov.w   @(%d, pc), r%d", disp, rn);
 }
 
 static void
-f_a0(const uint16_t *pc, char *buf)
+f_a0(const uint16_t *pc, char *buf, size_t len)
 {
 	uint16_t insn = get_insn(pc);
 	int disp;
@@ -1429,11 +1429,11 @@ f_a0(const uint16_t *pc, char *buf)
 		disp |= 0xfffff000; /* sign extend */
 	disp *= 2;
 
-	sprintf(buf, "bra     %d(0x%x)", disp, disp);
+	snprintf(buf, len, "bra     %d(0x%x)", disp, disp);
 }
 
 static void
-f_b0(const uint16_t *pc, char *buf)
+f_b0(const uint16_t *pc, char *buf, size_t len)
 {
 	uint16_t insn = get_insn(pc);
 	int disp;
@@ -1443,11 +1443,11 @@ f_b0(const uint16_t *pc, char *buf)
 		disp |= 0xfffff000; /* sign extend */
 	disp *= 2;
 
-	sprintf(buf, "bsr     %d(0x%x)", disp, disp);
+	snprintf(buf, len, "bsr     %d(0x%x)", disp, disp);
 }
 
 static void
-f_c0(const uint16_t *pc, char *buf)
+f_c0(const uint16_t *pc, char *buf, size_t len)
 {
 	uint16_t insn = get_insn(pc);
 	int type, md, imm;
@@ -1460,21 +1460,21 @@ f_c0(const uint16_t *pc, char *buf)
 	case 0:
 		switch (md) {
 		case 0:
-			sprintf(buf, "mov.b   r0, @(%d, gbr)", imm);
+			snprintf(buf, len, "mov.b   r0, @(%d, gbr)", imm);
 			break;
 
 		case 1:
 			imm *= 2;
-			sprintf(buf, "mov.w   r0, @(%d, gbr)", imm);
+			snprintf(buf, len, "mov.w   r0, @(%d, gbr)", imm);
 			break;
 
 		case 2:
 			imm *= 4;
-			sprintf(buf, "mov.l   r0, @(%d, gbr)", imm);
+			snprintf(buf, len, "mov.l   r0, @(%d, gbr)", imm);
 			break;
 
 		case 3:
-			sprintf(buf, "trapa   #0x%x", imm);
+			snprintf(buf, len, "trapa   #0x%x", imm);
 			break;
 		}
 		break;
@@ -1482,22 +1482,22 @@ f_c0(const uint16_t *pc, char *buf)
 	case 1:
 		switch (md) {
 		case 0:
-			sprintf(buf, "mov.b   @(%d, gbr), r0", imm);
+			snprintf(buf, len, "mov.b   @(%d, gbr), r0", imm);
 			break;
 
 		case 1:
 			imm *= 2;
-			sprintf(buf, "mov.w   @(%d, gbr), r0", imm);
+			snprintf(buf, len, "mov.w   @(%d, gbr), r0", imm);
 			break;
 
 		case 2:
 			imm *= 4;
-			sprintf(buf, "mov.l   @(%d, gbr), r0", imm);
+			snprintf(buf, len, "mov.l   @(%d, gbr), r0", imm);
 			break;
 
 		case 3:
 			imm *= 4;
-			sprintf(buf, "mova    @(%d, pc), r0", imm);
+			snprintf(buf, len, "mova    @(%d, pc), r0", imm);
 			break;
 		}
 		break;
@@ -1505,19 +1505,19 @@ f_c0(const uint16_t *pc, char *buf)
 	case 2:
 		switch (md) {
 		case 0:
-			sprintf(buf, "tst     #%d, r0", imm);
+			snprintf(buf, len, "tst     #%d, r0", imm);
 			break;
 
 		case 1:
-			sprintf(buf, "and     #%d, r0", imm);
+			snprintf(buf, len, "and     #%d, r0", imm);
 			break;
 
 		case 2:
-			sprintf(buf, "xor     #%d, r0", imm);
+			snprintf(buf, len, "xor     #%d, r0", imm);
 			break;
 
 		case 3:
-			sprintf(buf, "or      #%d, r0", imm);
+			snprintf(buf, len, "or      #%d, r0", imm);
 			break;
 		}
 		break;
@@ -1525,19 +1525,19 @@ f_c0(const uint16_t *pc, char *buf)
 	case 3:
 		switch (md) {
 		case 0:
-			sprintf(buf, "tst.b   #%d, @(r0, gbr)", imm);
+			snprintf(buf, len, "tst.b   #%d, @(r0, gbr)", imm);
 			break;
 
 		case 1:
-			sprintf(buf, "and.b   #%d, @(r0, gbr)", imm);
+			snprintf(buf, len, "and.b   #%d, @(r0, gbr)", imm);
 			break;
 
 		case 2:
-			sprintf(buf, "xor.b   #%d, @(r0, gbr)", imm);
+			snprintf(buf, len, "xor.b   #%d, @(r0, gbr)", imm);
 			break;
 
 		case 3:
-			sprintf(buf, "or.b    #%d, @(r0, gbr)", imm);
+			snprintf(buf, len, "or.b    #%d, @(r0, gbr)", imm);
 			break;
 		}
 		break;
@@ -1546,7 +1546,7 @@ f_c0(const uint16_t *pc, char *buf)
 
 
 static void
-f_d0(const uint16_t *pc, char *buf)
+f_d0(const uint16_t *pc, char *buf, size_t len)
 {
 	uint16_t insn = get_insn(pc);
 	int rn, disp;
@@ -1555,11 +1555,11 @@ f_d0(const uint16_t *pc, char *buf)
 	disp = (insn & 0x00ff);
 	disp *= 4;
 
-	sprintf(buf, "mov.l   @(%d, pc), r%d", disp, rn);
+	snprintf(buf, len, "mov.l   @(%d, pc), r%d", disp, rn);
 }
 
 static void
-f_e0(const uint16_t *pc, char *buf)
+f_e0(const uint16_t *pc, char *buf, size_t len)
 {
 	uint16_t insn = get_insn(pc);
 	int rn, imm;
@@ -1567,11 +1567,11 @@ f_e0(const uint16_t *pc, char *buf)
 	rn   = (insn & 0x0f00) >> 8;
 	imm  = (int) ((char) (insn & 0x00ff));
 
-	sprintf(buf, "mov     #0x%x, r%d", imm, rn);
+	snprintf(buf, len, "mov     #0x%x, r%d", imm, rn);
 }
 
 static void
-f_f0(const uint16_t *pc, char *buf)
+f_f0(const uint16_t *pc, char *buf, size_t len)
 {
 	uint16_t insn = get_insn(pc);
 	int rn, rm, md;
@@ -1582,25 +1582,25 @@ f_f0(const uint16_t *pc, char *buf)
 
 	switch (md) {
 	case 0:
-		sprintf(buf, "fadd    fr%d, fr%d", rm, rn);
+		snprintf(buf, len, "fadd    fr%d, fr%d", rm, rn);
 		break;
 
 	case 1:
-		sprintf(buf, "fsub    fr%d, fr%d", rm, rn);
+		snprintf(buf, len, "fsub    fr%d, fr%d", rm, rn);
 		break;
 
 	case 2:
-		sprintf(buf, "fmul    fr%d, fr%d", rm, rn);
+		snprintf(buf, len, "fmul    fr%d, fr%d", rm, rn);
 		break;
 
 	case 3:
-		sprintf(buf, "fdiv    fr%d, fr%d", rm, rn);
+		snprintf(buf, len, "fdiv    fr%d, fr%d", rm, rn);
 		break;
 	} /* end of switch (md) */
 }
 
 static void
-f_f4(const uint16_t *pc, char *buf)
+f_f4(const uint16_t *pc, char *buf, size_t len)
 {
 	uint16_t insn = get_insn(pc);
 	int rn, rm, md;
@@ -1611,25 +1611,25 @@ f_f4(const uint16_t *pc, char *buf)
 
 	switch (md) {
 	case 0:
-		sprintf(buf, "fcmp/eq fr%d, fr%d", rm, rn);
+		snprintf(buf, len, "fcmp/eq fr%d, fr%d", rm, rn);
 		break;
 
 	case 1:
-		sprintf(buf, "fcmp/gt fr%d, fr%d", rm, rn);
+		snprintf(buf, len, "fcmp/gt fr%d, fr%d", rm, rn);
 		break;
 
 	case 2:
-		sprintf(buf, "fmov.s  @(r0, r%d), fr%d", rm, rn);
+		snprintf(buf, len, "fmov.s  @(r0, r%d), fr%d", rm, rn);
 		break;
 
 	case 3:
-		sprintf(buf, "fmov.s  fr%d, @(r0, r%d)", rm, rn);
+		snprintf(buf, len, "fmov.s  fr%d, @(r0, r%d)", rm, rn);
 		break;
 	} /* end of switch (md) */
 }
 
 static void
-f_f8(const uint16_t *pc, char *buf)
+f_f8(const uint16_t *pc, char *buf, size_t len)
 {
 	uint16_t insn = get_insn(pc);
 	int rn, rm, md;
@@ -1640,25 +1640,25 @@ f_f8(const uint16_t *pc, char *buf)
 
 	switch (md) {
 	case 0:
-		sprintf(buf, "fmov.s  @r%d, fr%d", rm, rn);
+		snprintf(buf, len, "fmov.s  @r%d, fr%d", rm, rn);
 		break;
 
 	case 1:
-		sprintf(buf, "fmov.s  @r%d+, fr%d", rm, rn);
+		snprintf(buf, len, "fmov.s  @r%d+, fr%d", rm, rn);
 		break;
 
 	case 2:
-		sprintf(buf, "fmov.s  fr%d, @r%d", rm, rn);
+		snprintf(buf, len, "fmov.s  fr%d, @r%d", rm, rn);
 		break;
 
 	case 3:
-		sprintf(buf, "fmov.s  fr%d, @-r%d", rm, rn);
+		snprintf(buf, len, "fmov.s  fr%d, @-r%d", rm, rn);
 		break;
 	} /* end of switch (md) */
 }
 
 static void
-f_fc(const uint16_t *pc, char *buf)
+f_fc(const uint16_t *pc, char *buf, size_t len)
 {
 	uint16_t insn = get_insn(pc);
 	int rn, rm;
@@ -1666,11 +1666,11 @@ f_fc(const uint16_t *pc, char *buf)
 	rn   = (insn & 0x0f00) >> 8;
 	rm   = (insn & 0x00f0) >> 4;
 
-	sprintf(buf, "fmov    fr%d, fr%d", rm, rn);
+	snprintf(buf, len, "fmov    fr%d, fr%d", rm, rn);
 }
 
 static void
-f_fd(const uint16_t *pc, char *buf)
+f_fd(const uint16_t *pc, char *buf, size_t len)
 {
 	uint16_t insn = get_insn(pc);
 	int rn, type, md;
@@ -1683,19 +1683,19 @@ f_fd(const uint16_t *pc, char *buf)
 	case 0:
 		switch (md) {
 		case 0:
-			sprintf(buf, "fsts    fpul, fr%d", rn);
+			snprintf(buf, len, "fsts    fpul, fr%d", rn);
 			break;
 
 		case 1:
-			sprintf(buf, "flds    fr%d, fpul", rn);
+			snprintf(buf, len, "flds    fr%d, fpul", rn);
 			break;
 
 		case 2:
-			sprintf(buf, "float   fpul, fr%d", rn);
+			snprintf(buf, len, "float   fpul, fr%d", rn);
 			break;
 
 		case 3:
-			sprintf(buf, "ftrc    fr%d, fpul", rn);
+			snprintf(buf, len, "ftrc    fr%d, fpul", rn);
 			break;
 		}
 		break;
@@ -1703,15 +1703,15 @@ f_fd(const uint16_t *pc, char *buf)
 	case 1:
 		switch (md) {
 		case 0:
-			sprintf(buf, "fneg    fr%d", rn);
+			snprintf(buf, len, "fneg    fr%d", rn);
 			break;
 
 		case 1:
-			sprintf(buf, "fabs    fr%d", rn);
+			snprintf(buf, len, "fabs    fr%d", rn);
 			break;
 
 		case 2:
-			sprintf(buf, "fsqrt   fr%d", rn);
+			snprintf(buf, len, "fsqrt   fr%d", rn);
 			break;
 		}
 		break;
@@ -1720,7 +1720,7 @@ f_fd(const uint16_t *pc, char *buf)
 		switch (md) {
 		case 0:
 		case 1:
-			sprintf(buf, "fldi%d   fr%d", md, rn);
+			snprintf(buf, len, "fldi%d   fr%d", md, rn);
 			break;
 		}
 		break;
@@ -1728,7 +1728,7 @@ f_fd(const uint16_t *pc, char *buf)
 }
 
 static void
-f_fe(const uint16_t *pc, char *buf)
+f_fe(const uint16_t *pc, char *buf, size_t len)
 {
 	uint16_t insn = get_insn(pc);
 	int rn, rm;
@@ -1736,5 +1736,5 @@ f_fe(const uint16_t *pc, char *buf)
 	rn   = (insn & 0x0f00) >> 8;
 	rm   = (insn & 0x00f0) >> 4;
 
-	sprintf(buf, "fmac    fr0, fr%d, fr%d", rm, rn);
+	snprintf(buf, len, "fmac    fr0, fr%d, fr%d", rm, rn);
 }

Reply via email to