mathemu.c

Linux内核源代码 为压缩文件 是<<Linux内核>>一书中的源代码

/*
 *  arch/s390/kernel/mathemu.c
 *
 *  S390 version
 *    Copyright (C) 1999 IBM Deutschland Entwicklung GmbH, IBM Corporation
 *    Author(s): Martin Schwidefsky ([e-mail]),
 *
 * 'mathemu.c' handles IEEE instructions on a S390 processor
 * that does not have the IEEE fpu
 */

#include <linux/kernel.h>
#include <linux/errno.h>
#include <linux/ptrace.h>

#include <asm/uaccess.h>
#include <asm/mathemu.h>

static void set_CC_df(__u64 val1,__u64 val2) {
        int rc;
        rc = __cmpdf2(val1,val2);
        current->thread.regs->psw.mask &= 0xFFFFCFFF;
        switch (rc) {
                case -1:
                        current->thread.regs->psw.mask |= 0x00001000;
                        break;
                case 1:
                        current->thread.regs->psw.mask |= 0x00002000;
                        break;
        }
}

static void set_CC_sf(__u32 val1,__u32 val2) {
        int rc;
        rc = __cmpsf2(val1,val2);
        current->thread.regs->psw.mask &= 0xFFFFCFFF;
        switch (rc) {
                case -1:
                        current->thread.regs->psw.mask |= 0x00001000;
                        break;
                case 1:
                        current->thread.regs->psw.mask |= 0x00002000;
                        break;
        }
}


static void emu_adb (int rx, __u64 val) {
        current->thread.fp_regs.fprs[rx].d = __adddf3(current->thread.fp_regs.fprs[rx].d,val);
        set_CC_df(current->thread.fp_regs.fprs[rx].d,0ULL);
}

static void emu_adbr (int rx, int ry) {
        current->thread.fp_regs.fprs[rx].d = __adddf3(current->thread.fp_regs.fprs[rx].d,
                                         current->thread.fp_regs.fprs[ry].d);
        set_CC_df(current->thread.fp_regs.fprs[rx].d,0ULL);
}

static void emu_aeb (int rx, __u32 val) {
        current->thread.fp_regs.fprs[rx].f = __addsf3(current->thread.fp_regs.fprs[rx].f,val);
        set_CC_sf(current->thread.fp_regs.fprs[rx].f,0);
}

static void emu_aebr (int rx, int ry) {
        current->thread.fp_regs.fprs[rx].f = __addsf3(current->thread.fp_regs.fprs[rx].f,
                                        current->thread.fp_regs.fprs[ry].f);
        set_CC_sf(current->thread.fp_regs.fprs[rx].f,0);
}

static void emu_axbr (int rx, int ry) {
        printk("axbr emulation not implemented!\n");
}

static void emu_cdb (int rx, __u64 val) {
        set_CC_df(current->thread.fp_regs.fprs[rx].d,val);
}

static void emu_cdbr (int rx, int ry) {
        set_CC_df(current->thread.fp_regs.fprs[rx].d,current->thread.fp_regs.fprs[ry].d);
}

static void emu_cdfbr (int rx, int ry) {
        current->thread.fp_regs.fprs[rx].d =
                     __floatsidf(current->thread.regs->gprs[ry]);
}

static void emu_ceb (int rx, __u32 val) {
        set_CC_sf(current->thread.fp_regs.fprs[rx].f,val);
}

static void emu_cebr (int rx, int ry) {
        set_CC_sf(current->thread.fp_regs.fprs[rx].f,current->thread.fp_regs.fprs[ry].f);
}

static void emu_cefbr (int rx, int ry) {
        current->thread.fp_regs.fprs[rx].f =
                     __floatsisf(current->thread.regs->gprs[ry]);
}

static void emu_cfdbr (int rx, int ry, int mask) {
        current->thread.regs->gprs[rx] =
                     __fixdfsi(current->thread.fp_regs.fprs[ry].d);
}

static void emu_cfebr (int rx, int ry, int mask) {
        current->thread.regs->gprs[rx] =
                     __fixsfsi(current->thread.fp_regs.fprs[ry].f);
}

static void emu_cfxbr (int rx, int ry, int mask) {
        printk("cfxbr emulation not implemented!\n");
}

static void emu_cxbr (int rx, int ry) {
        printk("cxbr emulation not implemented!\n");
}

static void emu_cxfbr (int rx, int ry) {
        printk("cxfbr emulation not implemented!\n");
}

static void emu_ddb (int rx, __u64 val) {
        current->thread.fp_regs.fprs[rx].d = __divdf3(current->thread.fp_regs.fprs[rx].d,val);
        set_CC_df(current->thread.fp_regs.fprs[rx].d,0ULL);
}

static void emu_ddbr (int rx, int ry) {
        current->thread.fp_regs.fprs[rx].d = __divdf3(current->thread.fp_regs.fprs[rx].d,
                                         current->thread.fp_regs.fprs[ry].d);
        set_CC_df(current->thread.fp_regs.fprs[rx].d,0ULL);
}

static void emu_deb (int rx, __u32 val) {
        current->thread.fp_regs.fprs[rx].f = __divsf3(current->thread.fp_regs.fprs[rx].f,val);
        set_CC_sf(current->thread.fp_regs.fprs[rx].f,0);
}

static void emu_debr (int rx, int ry) {
        current->thread.fp_regs.fprs[rx].f = __divsf3(current->thread.fp_regs.fprs[rx].f,
                                         current->thread.fp_regs.fprs[ry].f);
        set_CC_sf(current->thread.fp_regs.fprs[rx].f,0);
}

static void emu_didbr (int rx, int ry, int mask) {
        printk("didbr emulation not implemented!\n");
}

static void emu_diebr (int rx, int ry, int mask) {
        printk("diebr emulation not implemented!\n");
}

static void emu_dxbr (int rx, int ry) {
        printk("dxbr emulation not implemented!\n");
}

static void emu_efpc (int rx, int ry) {
        printk("efpc emulation not implemented!\n");
}

static void emu_fidbr (int rx, int ry, int mask) {
        printk("fidbr emulation not implemented!\n");
}

static void emu_fiebr (int rx, int ry, int mask) {
        printk("fiebr emulation not implemented!\n");
}

static void emu_fixbr (int rx, int ry, int mask) {
        printk("fixbr emulation not implemented!\n");
}

static void emu_kdb (int rx, __u64 val) {
        printk("kdb emulation not implemented!\n");
}

static void emu_kdbr (int rx, int ry) {
        printk("kdbr emulation not implemented!\n");
}

static void emu_keb (int rx, __u32 val) {
        printk("keb emulation not implemented!\n");
}

static void emu_kebr (int rx, int ry) {
        printk("kebr emulation not implemented!\n");
}

static void emu_kxbr (int rx, int ry) {
        printk("kxbr emulation not implemented!\n");
}

static void emu_lcdbr (int rx, int ry) {
        current->thread.fp_regs.fprs[rx].d =
        __negdf2(current->thread.fp_regs.fprs[ry].d);
        set_CC_df(current->thread.fp_regs.fprs[rx].d,0ULL);
}

static void emu_lcebr (int rx, int ry) {
        current->thread.fp_regs.fprs[rx].f =
        __negsf2(current->thread.fp_regs.fprs[ry].f);
        set_CC_sf(current->thread.fp_regs.fprs[rx].f,0);
}

static void emu_lcxbr (int rx, int ry) {
        printk("lcxbr emulation not implemented!\n");
}

static void emu_ldeb (int rx, __u32 val) {
        current->thread.fp_regs.fprs[rx].d = __extendsfdf2(val);
}

static void emu_ldebr (int rx, int ry) {
        current->thread.fp_regs.fprs[rx].d =
        __extendsfdf2(current->thread.fp_regs.fprs[ry].f);
}

static void emu_ldxbr (int rx, int ry) {
        printk("ldxbr emulation not implemented!\n");
}

static void emu_ledbr (int rx, int ry) {
        current->thread.fp_regs.fprs[rx].f = __truncdfsf2(current->thread.fp_regs.fprs[ry].d);
        set_CC_sf(current->thread.fp_regs.fprs[rx].f,0);
}

static void emu_lexbr (int rx, int ry) {
        printk("lexbr emulation not implemented!\n");
}

static void emu_lndbr (int rx, int ry) {
        printk("lndbr emulation not implemented!\n");
}

static void emu_lnebr (int rx, int ry) {
        printk("lnebr emulation not implemented!\n");
}

static void emu_lnxbr (int rx, int ry) {
        printk("lnxbr emulation not implemented!\n");
}

static void emu_lpdbr (int rx, int ry) {
        current->thread.fp_regs.fprs[rx].d = __absdf2(current->thread.fp_regs.fprs[ry].d);
        set_CC_df(current->thread.fp_regs.fprs[rx].d,0);
}

static void emu_lpebr (int rx, int ry) {
        current->thread.fp_regs.fprs[rx].f = __abssf2(current->thread.fp_regs.fprs[ry].f);
        set_CC_sf(current->thread.fp_regs.fprs[rx].f,0);
}

static void emu_lpxbr (int rx, int ry) {
        printk("lpxbr emulation not implemented!\n");
}

static void emu_ltdbr (int rx, int ry) {
        current->thread.fp_regs.fprs[rx].d = current->thread.fp_regs.fprs[ry].d;
        set_CC_df(current->thread.fp_regs.fprs[rx].d,0ULL);
}

static void emu_ltebr (int rx, int ry) {
        current->thread.fp_regs.fprs[rx].f = current->thread.fp_regs.fprs[ry].f;
        set_CC_sf(current->thread.fp_regs.fprs[rx].f,0);
}

static void emu_ltxbr (int rx, int ry) {
        printk("ltxbr emulation not implemented!\n");
}

static void emu_lxdb (int rx, __u64 val) {
        printk("lxdb emulation not implemented!\n");
}

static void emu_lxdbr (int rx, int ry) {
        printk("lxdbr emulation not implemented!\n");
}

static void emu_lxeb (int rx, __u32 val) {
        printk("lxeb emulation not implemented!\n");
}

static void emu_lxebr (int rx, int ry) {
        printk("lxebr emulation not implemented!\n");
}

static void emu_madb (int rx, __u64 val, int mask) {
        printk("madb emulation not implemented!\n");
}

static void emu_madbr (int rx, int ry, int mask) {
        printk(" emulation not implemented!\n");
}

static void emu_maeb (int rx, __u32 val, int mask) {
        printk("maeb emulation not implemented!\n");
}

static void emu_maebr (int rx, int ry, int mask) {
        printk("maebr emulation not implemented!\n");