Subversion Repositories ao68000

/*

 * Copyright 2010, Aleksander Osman, alfik@poczta.fm. All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without modification, are

 * permitted provided that the following conditions are met:

 *

 *  1. Redistributions of source code must retain the above copyright notice, this list of

 *     conditions and the following disclaimer.

 *

 *  2. Redistributions in binary form must reproduce the above copyright notice, this list

 *     of conditions and the following disclaimer in the documentation and/or other materials

 *     provided with the distribution.

 *

 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED

 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND

 * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR

 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR

 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR

 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON

 * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING

 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF

 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 */

#include <stdio.h>

/*

struct from_68knotes_t {

        unsigned char operand;

        unsigned int x;

        unsigned char unadjusted;

        unsigned char adjusted;

        unsigned int v;

};

struct from_68knotes_t from_68knotes[] = {

        { 0x00, 0, 0x00, 0x00, 0 },

        { 0x00, 1, 0xFF, 0x99, 0 },

        { 0xFF, 0, 0x01, 0x9B, 0 },

        { 0xFF, 1, 0x00, 0x9A, 0 },

        { 0x01, 0, 0xFF, 0x99, 0 },

        { 0x01, 1, 0xFE, 0x98, 0 },

        { 0x0F, 0, 0xF1, 0x8B, 0 },

        { 0x0F, 1, 0xF0, 0x8A, 0 },

        { 0xF0, 0, 0x10, 0xB0, 0 },

        { 0xF0, 1, 0x0F, 0xA9, 0 },

        { 0x9A, 0, 0x66, 0x00, 0 },

        { 0x9A, 1, 0x65, 0xFF, 0 },

        { 0x99, 0, 0x67, 0x01, 0 },

        { 0x99, 1, 0x66, 0x00, 0 },

        { 0x10, 0, 0xF0, 0x90, 0 },

        { 0x10, 1, 0xEF, 0x89, 0 },

        { 0x7F, 0, 0x81, 0x1B, 1 },

        { 0x7F, 1, 0x80, 0x1A, 1 },

        { 0x80, 0, 0x80, 0x20, 1 },

        { 0x80, 1, 0x7F, 0x19, 0 },

        { 0x81, 0, 0x7F, 0x19, 0 },

        { 0x81, 1, 0x7E, 0x18, 0 }

};

*/

struct input_t {

        unsigned char src;

        unsigned char dst;

        unsigned int x;

        unsigned int z;

        unsigned int v;

};

struct output_t {

        unsigned char result;

        unsigned int c;

        unsigned int v;

        unsigned int z;

        unsigned int n;

        unsigned int x;

};

struct output_t uae_nbcd(struct input_t in) {

        signed char src = in.dst;

        unsigned short newv_lo = - (src & 0xF) - in.x;

        unsigned short newv_hi = - (src & 0xF0);

        unsigned short newv;

        int cflg;

        if (newv_lo > 9) { newv_lo -= 6; }

        newv = newv_hi + newv_lo;       cflg = (newv & 0x1F0) > 0x90;

        if (cflg) newv -= 0x60;

        struct output_t out;

        out.c = cflg ? 1 : 0;

        out.x = out.c;

        out.z = in.z & ((((signed char)(newv)) == 0) ? 1 : 0);

        out.n = (((signed char)(newv)) < 0) ? 1 : 0;

        out.v = in.v;

        out.result = (newv) & 0xff;

        return out;

}

struct output_t verilog_nbcd(struct input_t in) {

        struct output_t out;

        unsigned char l = 25 - ((in.dst) & 0x0F);

        unsigned char h = 25 - (((in.dst) & 0xF0) >> 4);

        if( ((in.dst) & 0x0F) > 9 ) h -= 1;

        l &= 0x0F;

        h &= 0x0F;

        if(in.x == 0) {

                if(l == 9) {

                        l = 0;

                        h = (h==9) ? 0 : h+1;

                }

                else if(l == 0xF) {

                        l = 0;

                        h += 1;

                }

                else {

                        l += 1;

                }

        }

        l &= 0x0F;

        h &= 0x0F;

        out.result = (h << 4) + l;

        out.v = in.v;

        out.z = in.z & ((out.result == 0) ? 1 : 0);

        out.c = out.x = (in.dst == 0 && in.x == 0) ? 0 : 1;

        out.n = (((out.result) & 0x80) == 0) ? 0 : 1;

        return out;

}

struct output_t uae_abcd(struct input_t in) {

        signed char src = in.src;

        signed char dst = in.dst;

        unsigned short newv_lo = (src & 0xF) + (dst & 0xF) + (in.x ? 1 : 0);

        unsigned short newv_hi = (src & 0xF0) + (dst & 0xF0);

        unsigned short newv, tmp_newv;

        int cflg;

        newv = tmp_newv = newv_hi + newv_lo;    if (newv_lo > 9) { newv += 6; }

        cflg = (newv & 0x3F0) > 0x90;

        if (cflg) newv += 0x60;

        struct output_t out;

        out.c = cflg;

        out.x = out.c;

        out.z = in.z & (((signed char)(newv)) == 0);

        out.n = ((signed char)(newv)) < 0;

        out.v = (tmp_newv & 0x80) == 0 && (newv & 0x80) != 0;

        out.result = (newv) & 0xff;

        return out;

}

struct output_t verilog_abcd(struct input_t in) {

        unsigned char l = (in.src & 0x0F) + (in.dst & 0x0F) + in.x;

        unsigned char h = ((in.src & 0xF0) >> 4) + ((in.dst & 0xF0) >> 4);

        int tmp = (in.src + in.dst + in.x) & 0x80;

        l = (l > 0x09) ? (l+6) : l;

        h = (l > 0x1F) ? (h+2) :

                (l > 0x0F) ? (h+1) : h;

        h = (h > 0x09) ? (h+6) : h;

        struct output_t out;

        out.c = (h > 0x09) ? 1 : 0;

        out.x = out.c;

        l &= 0x0F;

        h &= 0x0F;

        out.result = (h << 4) + l;

        out.z = in.z & (out.result == 0);

        out.n = ((out.result & 0x80) == 0x80) ? 1 : 0;

        out.v = (tmp == 0) && ((out.result & 0x80) != 0);

        return out;

}

struct output_t uae_sbcd(struct input_t in) {

        signed char src = in.src;

        signed char dst = in.dst;

        unsigned short newv_lo = (dst & 0xF) - (src & 0xF) - (in.x ? 1 : 0);

        unsigned short newv_hi = (dst & 0xF0) - (src & 0xF0);

        unsigned short newv, tmp_newv;

        int bcd = 0;

        newv = tmp_newv = newv_hi + newv_lo;

        if (newv_lo & 0xF0) { newv -= 6; bcd = 6; };

        if ((((dst & 0xFF) - (src & 0xFF) - (in.x ? 1 : 0)) & 0x100) > 0xFF) { newv -= 0x60; }

        struct output_t out;

        out.c = (((dst & 0xFF) - (src & 0xFF) - bcd - (in.x ? 1 : 0)) & 0x300) > 0xFF;

        out.x = out.c;

        out.z = in.z & (((signed char)(newv)) == 0);

        out.n = ((signed char)(newv)) < 0;

        out.v = (tmp_newv & 0x80) != 0 && (newv & 0x80) == 0;

        out.result = (newv) & 0xff;

        return out;

}

struct output_t verilog_sbcd(struct input_t in) {

        unsigned char l = 32 + (in.dst & 0x0F) - (in.src & 0x0F) - in.x;

        unsigned char h = 32 + ((in.dst & 0xF0) >> 4) - ((in.src & 0xF0) >> 4);

        int tmp = in.dst - in.src - in.x;

        l = (l < 32) ? (l-6) : l;

        h = (l < 16) ? (h-2) :

                (l < 32) ? (h-1) : h;

        h = (h < 32 && (tmp & 0x100) > 0xFF) ? (h-6) : h;

        struct output_t out;

        out.c = (h < 32) ? 1 : 0;

        out.x = out.c;

        l &= 0x0F;

        h &= 0x0F;

        out.result = (h << 4) + l;

        out.z = in.z & (out.result == 0);

        out.n = ((out.result & 0x80) == 0x80) ? 1 : 0;

        out.v = ((tmp & 0x80) != 0) && ((out.result & 0x80) == 0);

        return out;

}

int test_failed = 0;

void compare(struct input_t in, struct output_t uae, struct output_t verilog) {

        if( uae.result == verilog.result &&

                uae.c == verilog.c &&

                uae.v == verilog.v &&

                uae.z == verilog.z &&

                uae.n == verilog.n &&

                uae.x == verilog.x

        ) return;

        //printf("%hhx + %hhx + %x: | ", in.dst, in.src, in.x);

        //printf("%hhx - %hhx - %x: | ", in.dst, in.src, in.x);

        printf("[Mismatch: in.dst: %hhx, in.src: %hhx, in.x: %x] ", in.dst, in.src, in.x);

        if( uae.result != verilog.result )              printf("result: %hhx != %hhx | ", uae.result, verilog.result);

        if( uae.c != verilog.c )                        printf("c: %x != %x | ", uae.c, verilog.c);

        if( uae.v != verilog.v )                        printf("v: %x != %x | ", uae.v, verilog.v);

        if( uae.z != verilog.z )                        printf("z: %x != %x | ", uae.z, verilog.z);

        if( uae.n != verilog.n )                        printf("n: %x != %x | ", uae.n, verilog.n);

        if( uae.x != verilog.x )                        printf("x: %x != %x | ", uae.x, verilog.x);

        printf("\n");

        test_failed = 1;

}

int main(int argc, char **argv) {

        struct input_t in;

        int i,j,k,l,m;

        for(i=0; i<256; i++) {

                for(j=0; j<256; j++) {

                        for(k=0; k<2; k++) {

                                for(l=0; l<2; l++) {

                                        for(m=0; m<2; m++) {

                                                in.src = i;

                                                in.dst = j;

                                                in.x = k;

                                                in.z = l;

                                                in.v = m;

                                                struct output_t uae0 = uae_nbcd(in);

                                                struct output_t verilog0 = verilog_nbcd(in);

                                                compare(in, uae0, verilog0);

                                                struct output_t uae1 = uae_abcd(in);

                                                struct output_t verilog1 = verilog_abcd(in);

                                                compare(in, uae1, verilog1);

                                                struct output_t uae2 = uae_sbcd(in);

                                                struct output_t verilog2 = verilog_sbcd(in);

                                                compare(in, uae2, verilog2);

                                        }

                                }

                        }

                }

        }

        if(test_failed) printf("Test FAILED.\n");

        else            printf("Test OK.\n");

        return 0;

}