validate.c

omap osk环境下的bootloader,包含完整的uboot源代码

#define VAL_START_UNARY(parm_type,max,incr)                 \
{                                                           \
    parm_type   d,r,r_asm;                                  \
	u32         flags,inflags;                              \
    int         f,failed = false;                           \
    char        buf1[80],buf2[80];                          \
    for (d = 0; d < max; d += incr) {                       \
	M.x86.R_EFLG = inflags = flags = def_flags;         \
	for (f = 0; f < 2; f++) {

#define VAL_TEST_UNARY(name)                                \
	    r_asm = name##_asm(&flags,d);                   \
	    r = name(d);                                \
	    if (r != r_asm || M.x86.R_EFLG != flags) {      \
		failed = true;

#define VAL_FAIL_BYTE_UNARY(name)                                                               \
		printk("fail\n");                                                               \
		printk("0x%02X = %-15s(0x%02X), flags = %s -> %s\n",                            \
		    r, #name, d, print_flags(buf1,inflags), print_flags(buf2,M.x86.R_EFLG));    \
		printk("0x%02X = %-15s(0x%02X), flags = %s -> %s\n",                            \
		    r_asm, #name"_asm", d, print_flags(buf1,inflags), print_flags(buf2,flags));

#define VAL_FAIL_WORD_UNARY(name)                                                               \
		printk("fail\n");                                                               \
		printk("0x%04X = %-15s(0x%04X), flags = %s -> %s\n",                            \
		    r, #name, d, print_flags(buf1,inflags), print_flags(buf2,M.x86.R_EFLG));  \
		printk("0x%04X = %-15s(0x%04X), flags = %s -> %s\n",                            \
		    r_asm, #name"_asm", d, print_flags(buf1,inflags), print_flags(buf2,flags));

#define VAL_FAIL_LONG_UNARY(name)                                                               \
		printk("fail\n");                                                               \
		printk("0x%08X = %-15s(0x%08X), flags = %s -> %s\n",                            \
		    r, #name, d, print_flags(buf1,inflags), print_flags(buf2,M.x86.R_EFLG));    \
		printk("0x%08X = %-15s(0x%08X), flags = %s -> %s\n",                            \
		    r_asm, #name"_asm", d, print_flags(buf1,inflags), print_flags(buf2,flags));

#define VAL_END_UNARY()                                                 \
		}                                                       \
	    M.x86.R_EFLG = inflags = flags = def_flags | ALL_FLAGS;     \
	    if (failed)                                                 \
		break;                                                  \
	    }                                                           \
	if (failed)                                                     \
	    break;                                                      \
	}                                                               \
    if (!failed)                                                        \
	printk("passed\n");                                             \
}

#define VAL_BYTE_UNARY(name)                \
    printk("Validating %s ... ", #name);    \
    VAL_START_UNARY(u8,0xFF,0x1)            \
    VAL_TEST_UNARY(name)                    \
    VAL_FAIL_BYTE_UNARY(name)               \
    VAL_END_UNARY()

#define VAL_WORD_UNARY(name)                \
    printk("Validating %s ... ", #name);    \
    VAL_START_UNARY(u16,0xFF00,0x100)       \
    VAL_TEST_UNARY(name)                    \
    VAL_FAIL_WORD_UNARY(name)               \
    VAL_END_UNARY()

#define VAL_WORD_BYTE_UNARY(name)           \
    printk("Validating %s ... ", #name);    \
    VAL_START_UNARY(u16,0xFF,0x1)           \
    VAL_TEST_UNARY(name)                    \
    VAL_FAIL_WORD_UNARY(name)               \
    VAL_END_UNARY()

#define VAL_LONG_UNARY(name)                \
    printk("Validating %s ... ", #name);    \
    VAL_START_UNARY(u32,0xFF000000,0x1000000) \
    VAL_TEST_UNARY(name)                    \
    VAL_FAIL_LONG_UNARY(name)               \
    VAL_END_UNARY()

#define VAL_BYTE_MUL(name)                                              \
    printk("Validating %s ... ", #name);                                \
{                                                                       \
    u8          d,s;                                                    \
    u16         r,r_asm;                                                \
	u32         flags,inflags;                                          \
    int         f,failed = false;                                       \
    char        buf1[80],buf2[80];                                      \
    for (d = 0; d < 0xFF; d += 1) {                                     \
	for (s = 0; s < 0xFF; s += 1) {                                 \
	    M.x86.R_EFLG = inflags = flags = def_flags;                 \
	    for (f = 0; f < 2; f++) {                                   \
		name##_asm(&flags,&r_asm,d,s);                          \
		M.x86.R_AL = d;                                         \
		name(s);                                            \
		r = M.x86.R_AX;                                         \
		if (r != r_asm || M.x86.R_EFLG != flags)                \
		    failed = true;                                      \
		if (failed || trace) {                                  \
		    if (failed)                                         \
			printk("fail\n");                               \
		    printk("0x%04X = %-15s(0x%02X,0x%02X), flags = %s -> %s\n",                         \
			r, #name, d, s, print_flags(buf1,inflags), print_flags(buf2,M.x86.R_EFLG));     \
		    printk("0x%04X = %-15s(0x%02X,0x%02X), flags = %s -> %s\n",                         \
			r_asm, #name"_asm", d, s, print_flags(buf1,inflags), print_flags(buf2,flags));  \
		    }                                                       \
		M.x86.R_EFLG = inflags = flags = def_flags | (ALL_FLAGS & ~F_OF);   \
		if (failed)                                                 \
		    break;                                                  \
		}                                                           \
	    if (failed)                                                     \
		break;                                                      \
	    }                                                               \
	if (failed)                                                         \
	    break;                                                          \
	}                                                                   \
    if (!failed)                                                            \
	printk("passed\n");                                                 \
}

#define VAL_WORD_MUL(name)                                              \
    printk("Validating %s ... ", #name);                                \
{                                                                       \
    u16         d,s;                                                    \
    u16         r_lo,r_asm_lo;                                          \
    u16         r_hi,r_asm_hi;                                          \
	u32         flags,inflags;                                          \
    int         f,failed = false;                                       \
    char        buf1[80],buf2[80];                                      \
    for (d = 0; d < 0xFF00; d += 0x100) {                               \
	for (s = 0; s < 0xFF00; s += 0x100) {                           \
	    M.x86.R_EFLG = inflags = flags = def_flags;                 \
	    for (f = 0; f < 2; f++) {                                   \
		name##_asm(&flags,&r_asm_lo,&r_asm_hi,d,s);             \
		M.x86.R_AX = d;                                         \
		name(s);                                            \
		r_lo = M.x86.R_AX;                                      \
		r_hi = M.x86.R_DX;                                      \
		if (r_lo != r_asm_lo || r_hi != r_asm_hi || M.x86.R_EFLG != flags)\
		    failed = true;                                      \
		if (failed || trace) {                                  \
		    if (failed)                                         \
			printk("fail\n");                               \
		    printk("0x%04X:0x%04X = %-15s(0x%04X,0x%04X), flags = %s -> %s\n",                              \
			r_hi,r_lo, #name, d, s, print_flags(buf1,inflags), print_flags(buf2,M.x86.R_EFLG));       \
		    printk("0x%04X:0x%04X = %-15s(0x%04X,0x%04X), flags = %s -> %s\n",                              \
			r_asm_hi,r_asm_lo, #name"_asm", d, s, print_flags(buf1,inflags), print_flags(buf2,flags));  \
		    }                                                                                               \
		M.x86.R_EFLG = inflags = flags = def_flags | (ALL_FLAGS & ~F_OF);   \
		if (failed)                                                 \
		    break;                                                  \
		}                                                           \
	    if (failed)                                                     \
		break;                                                      \
	    }                                                               \
	if (failed)                                                         \
	    break;                                                          \
	}                                                                   \
    if (!failed)                                                            \
	printk("passed\n");                                                 \
}

#define VAL_LONG_MUL(name)                                              \
    printk("Validating %s ... ", #name);                                \
{                                                                       \
    u32         d,s;                                                    \
    u32         r_lo,r_asm_lo;                                          \
    u32         r_hi,r_asm_hi;                                          \
	u32         flags,inflags;                                          \
    int         f,failed = false;                                       \
    char        buf1[80],buf2[80];                                      \
    for (d = 0; d < 0xFF000000; d += 0x1000000) {                       \
	for (s = 0; s < 0xFF000000; s += 0x1000000) {                   \
	    M.x86.R_EFLG = inflags = flags = def_flags;                 \
	    for (f = 0; f < 2; f++) {                                   \
		name##_asm(&flags,&r_asm_lo,&r_asm_hi,d,s);             \
		M.x86.R_EAX = d;                                        \
		name(s);                                            \
		r_lo = M.x86.R_EAX;                                     \
		r_hi = M.x86.R_EDX;                                     \
		if (r_lo != r_asm_lo || r_hi != r_asm_hi || M.x86.R_EFLG != flags)\
		    failed = true;                                      \
		if (failed || trace) {                                  \
		    if (failed)                                         \
			printk("fail\n");                               \
		    printk("0x%08X:0x%08X = %-15s(0x%08X,0x%08X), flags = %s -> %s\n",                              \
			r_hi,r_lo, #name, d, s, print_flags(buf1,inflags), print_flags(buf2,M.x86.R_EFLG));       \
		    printk("0x%08X:0x%08X = %-15s(0x%08X,0x%08X), flags = %s -> %s\n",                              \
			r_asm_hi,r_asm_lo, #name"_asm", d, s, print_flags(buf1,inflags), print_flags(buf2,flags));  \
		    }                                                                                               \
		M.x86.R_EFLG = inflags = flags = def_flags | (ALL_FLAGS & ~F_OF);   \
		if (failed)                                                 \
		    break;                                                  \
		}                                                           \
	    if (failed)                                                     \
		break;                                                      \
	    }                                                               \
	if (failed)                                                         \
	    break;                                                          \
	}                                                                   \
    if (!failed)                                                            \
	printk("passed\n");                                                 \
}

#define VAL_BYTE_DIV(name)                                              \
    printk("Validating %s ... ", #name);                                \
{                                                                       \
    u16         d,s;                                                    \
    u8          r_quot,r_rem,r_asm_quot,r_asm_rem;                      \
	u32         flags,inflags;                                          \
    int         f,failed = false;                                       \
    char        buf1[80],buf2[80];                                      \
    for (d = 0; d < 0xFF00; d += 0x100) {                               \
	for (s = 1; s < 0xFF; s += 1) {                                 \
	    M.x86.R_EFLG = inflags = flags = def_flags;                 \
	    for (f = 0; f < 2; f++) {                                   \
		M.x86.intr = 0;                                         \
		M.x86.R_AX = d;                                         \
		name(s);                                            \
		r_quot = M.x86.R_AL;                                    \
		r_rem = M.x86.R_AH;                                     \
		if (M.x86.intr & INTR_SYNCH)                            \
		    continue;                                           \
		name##_asm(&flags,&r_asm_quot,&r_asm_rem,d,s);          \
		if (r_quot != r_asm_quot || r_rem != r_asm_rem || M.x86.R_EFLG != flags) \
		    failed = true;                                      \
		if (failed || trace) {                                  \
		    if (failed)                                         \
			printk("fail\n");                               \
		    printk("0x%02X:0x%02X = %-15s(0x%04X,0x%02X), flags = %s -> %s\n",                      \
			r_quot, r_rem, #name, d, s, print_flags(buf1,inflags), print_flags(buf2,M.x86.R_EFLG));     \
		    printk("0x%02X:0x%02X = %-15s(0x%04X,0x%02X), flags = %s -> %s\n",                      \
			r_asm_quot, r_asm_rem, #name"_asm", d, s, print_flags(buf1,inflags), print_flags(buf2,flags));  \
		    }                                                       \
		M.x86.R_EFLG = inflags = flags = def_flags | (ALL_FLAGS & ~F_OF);   \
		if (failed)                                                 \
		    break;                                                  \
		}                                                           \
	    if (failed)                                                     \
		break;                                                      \
	    }                                                               \
	if (failed)                                                         \
	    break;                                                          \
	}                                                                   \
    if (!failed)                                                            \
	printk("passed\n");                                                 \
}

#define VAL_WORD_DIV(name)                                              \
    printk("Validating %s ... ", #name);                                \
{                                                                       \
    u32         d,s;                                                    \
    u16         r_quot,r_rem,r_asm_quot,r_asm_rem;                      \
	u32         flags,inflags;                                          \
    int         f,failed = false;                                       \
    char        buf1[80],buf2[80];                                      \
    for (d = 0; d < 0xFF000000; d += 0x1000000) {                       \