arch/sparc/kernel/muldiv.c

   1 /* $Id: muldiv.c,v 1.5 1997/12/15 20:07:20 ecd Exp $
   2  * muldiv.c: Hardware multiply/division illegal instruction trap
   3  *              for sun4c/sun4 (which do not have those instructions)
   4  *
   5  * Copyright (C) 1996 Jakub Jelinek (jj@sunsite.mff.cuni.cz)
   6  * Copyright (C) 1996 David S. Miller (davem@caip.rutgers.edu)
   7  */
   8
   9 #include <linux/kernel.h>
  10 #include <linux/sched.h>
  11 #include <linux/mm.h>
  12 #include <asm/ptrace.h>
  13 #include <asm/processor.h>
  14 #include <asm/system.h>
  15 #include <asm/uaccess.h>
  16
  17 /* #define DEBUG_MULDIV */
  18
  19 static inline int has_imm13(int insn)
  20 {
  21         return (insn & 0x2000);
  22 }
  23
  24 static inline int is_foocc(int insn)
  25 {
  26         return (insn & 0x800000);
  27 }
  28
  29 static inline int sign_extend_imm13(int imm)
  30 {
  31         return imm << 19 >> 19;
  32 }
  33
  34 static inline void advance(struct pt_regs *regs)
  35 {
  36         regs->pc   = regs->npc;
  37         regs->npc += 4;
  38 }
  39
  40 static inline void maybe_flush_windows(unsigned int rs1, unsigned int rs2,
  41                                        unsigned int rd)
  42 {
  43         if(rs2 >= 16 || rs1 >= 16 || rd >= 16) {
  44                 /* Wheee... */
  45                 __asm__ __volatile__("save %sp, -0x40, %sp\n\t"
  46                                      "save %sp, -0x40, %sp\n\t"
  47                                      "save %sp, -0x40, %sp\n\t"
  48                                      "save %sp, -0x40, %sp\n\t"
  49                                      "save %sp, -0x40, %sp\n\t"
  50                                      "save %sp, -0x40, %sp\n\t"
  51                                      "save %sp, -0x40, %sp\n\t"
  52                                      "restore; restore; restore; restore;\n\t"
  53                                      "restore; restore; restore;\n\t");
  54         }
  55 }
  56
  57 #define fetch_reg(reg, regs) ({                                         \
  58         struct reg_window __user *win;                                  \
  59         register unsigned long ret;                                     \
  60                                                                         \
  61         if (!(reg)) ret = 0;                                            \
  62         else if ((reg) < 16) {                                          \
  63                 ret = regs->u_regs[(reg)];                              \
  64         } else {                                                        \
  65                 /* Ho hum, the slightly complicated case. */            \
  66                 win = (struct reg_window __user *)regs->u_regs[UREG_FP];\
  67                 if (get_user (ret, &win->locals[(reg) - 16])) return -1;\
  68         }                                                               \
  69         ret;                                                            \
  70 })
  71
  72 static inline int
  73 store_reg(unsigned int result, unsigned int reg, struct pt_regs *regs)
  74 {
  75         struct reg_window __user *win;
  76
  77         if (!reg)
  78                 return 0;
  79         if (reg < 16) {
  80                 regs->u_regs[reg] = result;
  81                 return 0;
  82         } else {
  83                 /* need to use put_user() in this case: */
  84                 win = (struct reg_window __user *) regs->u_regs[UREG_FP];
  85                 return (put_user(result, &win->locals[reg - 16]));
  86         }
  87 }
  88
  89 extern void handle_hw_divzero (struct pt_regs *regs, unsigned long pc,
  90                                unsigned long npc, unsigned long psr);
  91
  92 /* Should return 0 if mul/div emulation succeeded and SIGILL should
  93  * not be issued.
  94  */
  95 int do_user_muldiv(struct pt_regs *regs, unsigned long pc)
  96 {
  97         unsigned int insn;
  98         int inst;
  99         unsigned int rs1, rs2, rdv;
 100
 101         if (!pc)
 102                 return -1; /* This happens to often, I think */
 103         if (get_user (insn, (unsigned int __user *)pc))
 104                 return -1;
 105         if ((insn & 0xc1400000) != 0x80400000)
 106                 return -1;
 107         inst = ((insn >> 19) & 0xf);
 108         if ((inst & 0xe) != 10 && (inst & 0xe) != 14)
 109                 return -1;
 110
 111         /* Now we know we have to do something with umul, smul, udiv or sdiv */
 112         rs1 = (insn >> 14) & 0x1f;
 113         rs2 = insn & 0x1f;
 114         rdv = (insn >> 25) & 0x1f;
 115         if (has_imm13(insn)) {
 116                 maybe_flush_windows(rs1, 0, rdv);
 117                 rs2 = sign_extend_imm13(insn);
 118         } else {
 119                 maybe_flush_windows(rs1, rs2, rdv);
 120                 rs2 = fetch_reg(rs2, regs);
 121         }
 122         rs1 = fetch_reg(rs1, regs);
 123         switch (inst) {
 124         case 10: /* umul */
 125 #ifdef DEBUG_MULDIV
 126                 printk ("unsigned muldiv: 0x%x * 0x%x = ", rs1, rs2);
 127 #endif
 128                 __asm__ __volatile__ ("\n\t"
 129                         "mov    %0, %%o0\n\t"
 130                         "call   .umul\n\t"
 131                         " mov   %1, %%o1\n\t"
 132                         "mov    %%o0, %0\n\t"
 133                         "mov    %%o1, %1\n\t"
 134                         : "=r" (rs1), "=r" (rs2)
 135                         :
 136                         : "o0", "o1", "o2", "o3", "o4", "o5", "o7", "cc");
 137 #ifdef DEBUG_MULDIV
 138                 printk ("0x%x%08x\n", rs2, rs1);
 139 #endif
 140                 if (store_reg(rs1, rdv, regs))
 141                         return -1;
 142                 regs->y = rs2;
 143                 break;
 144         case 11: /* smul */
 145 #ifdef DEBUG_MULDIV
 146                 printk ("signed muldiv: 0x%x * 0x%x = ", rs1, rs2);
 147 #endif
 148                 __asm__ __volatile__ ("\n\t"
 149                         "mov    %0, %%o0\n\t"
 150                         "call   .mul\n\t"
 151                         " mov   %1, %%o1\n\t"
 152                         "mov    %%o0, %0\n\t"
 153                         "mov    %%o1, %1\n\t"
 154                         : "=r" (rs1), "=r" (rs2)
 155                         :
 156                         : "o0", "o1", "o2", "o3", "o4", "o5", "o7", "cc");
 157 #ifdef DEBUG_MULDIV
 158                 printk ("0x%x%08x\n", rs2, rs1);
 159 #endif
 160                 if (store_reg(rs1, rdv, regs))
 161                         return -1;
 162                 regs->y = rs2;
 163                 break;
 164         case 14: /* udiv */
 165 #ifdef DEBUG_MULDIV
 166                 printk ("unsigned muldiv: 0x%x%08x / 0x%x = ", regs->y, rs1, rs2);
 167 #endif
 168                 if (!rs2) {
 169 #ifdef DEBUG_MULDIV
 170                         printk ("DIVISION BY ZERO\n");
 171 #endif
 172                         handle_hw_divzero (regs, pc, regs->npc, regs->psr);
 173                         return 0;
 174                 }
 175                 __asm__ __volatile__ ("\n\t"
 176                         "mov    %2, %%o0\n\t"
 177                         "mov    %0, %%o1\n\t"
 178                         "mov    %%g0, %%o2\n\t"
 179                         "call   __udivdi3\n\t"
 180                         " mov   %1, %%o3\n\t"
 181                         "mov    %%o1, %0\n\t"
 182                         "mov    %%o0, %1\n\t"
 183                         : "=r" (rs1), "=r" (rs2)
 184                         : "r" (regs->y)
 185                         : "o0", "o1", "o2", "o3", "o4", "o5", "o7",
 186                           "g1", "g2", "g3", "cc");
 187 #ifdef DEBUG_MULDIV
 188                 printk ("0x%x\n", rs1);
 189 #endif
 190                 if (store_reg(rs1, rdv, regs))
 191                         return -1;
 192                 break;
 193         case 15: /* sdiv */
 194 #ifdef DEBUG_MULDIV
 195                 printk ("signed muldiv: 0x%x%08x / 0x%x = ", regs->y, rs1, rs2);
 196 #endif
 197                 if (!rs2) {
 198 #ifdef DEBUG_MULDIV
 199                         printk ("DIVISION BY ZERO\n");
 200 #endif
 201                         handle_hw_divzero (regs, pc, regs->npc, regs->psr);
 202                         return 0;
 203                 }
 204                 __asm__ __volatile__ ("\n\t"
 205                         "mov    %2, %%o0\n\t"
 206                         "mov    %0, %%o1\n\t"
 207                         "mov    %%g0, %%o2\n\t"
 208                         "call   __divdi3\n\t"
 209                         " mov   %1, %%o3\n\t"
 210                         "mov    %%o1, %0\n\t"
 211                         "mov    %%o0, %1\n\t"
 212                         : "=r" (rs1), "=r" (rs2)
 213                         : "r" (regs->y)
 214                         : "o0", "o1", "o2", "o3", "o4", "o5", "o7",
 215                           "g1", "g2", "g3", "cc");
 216 #ifdef DEBUG_MULDIV
 217                 printk ("0x%x\n", rs1);
 218 #endif
 219                 if (store_reg(rs1, rdv, regs))
 220                         return -1;
 221                 break;
 222         }
 223         if (is_foocc (insn)) {
 224                 regs->psr &= ~PSR_ICC;
 225                 if ((inst & 0xe) == 14) {
 226                         /* ?div */
 227                         if (rs2) regs->psr |= PSR_V;
 228                 }
 229                 if (!rs1) regs->psr |= PSR_Z;
 230                 if (((int)rs1) < 0) regs->psr |= PSR_N;
 231 #ifdef DEBUG_MULDIV
 232                 printk ("psr muldiv: %08x\n", regs->psr);
 233 #endif
 234         }
 235         advance(regs);
 236         return 0;
 237 }