root/arch/sh/kernel/signal_64.c

DEFINITIONS

1. handle_syscall_restart
2. do_signal
3. restore_sigcontext_fpu
4. setup_sigcontext_fpu
5. restore_sigcontext_fpu
6. setup_sigcontext_fpu
7. restore_sigcontext
8. sys_sigreturn
9. sys_rt_sigreturn
10. setup_sigcontext
11. get_sigframe
12. setup_frame
13. setup_rt_frame
14. handle_signal
15. do_notify_resume

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * arch/sh/kernel/signal_64.c
   4  *
   5  * Copyright (C) 2000, 2001  Paolo Alberelli
   6  * Copyright (C) 2003 - 2008  Paul Mundt
   7  * Copyright (C) 2004  Richard Curnow
   8  */
   9 #include <linux/rwsem.h>
  10 #include <linux/sched.h>
  11 #include <linux/mm.h>
  12 #include <linux/smp.h>
  13 #include <linux/kernel.h>
  14 #include <linux/signal.h>
  15 #include <linux/errno.h>
  16 #include <linux/wait.h>
  17 #include <linux/personality.h>
  18 #include <linux/ptrace.h>
  19 #include <linux/unistd.h>
  20 #include <linux/stddef.h>
  21 #include <linux/tracehook.h>
  22 #include <asm/ucontext.h>
  23 #include <linux/uaccess.h>
  24 #include <asm/pgtable.h>
  25 #include <asm/cacheflush.h>
  26 #include <asm/fpu.h>
  27 
  28 #define REG_RET 9
  29 #define REG_ARG1 2
  30 #define REG_ARG2 3
  31 #define REG_ARG3 4
  32 #define REG_SP 15
  33 #define REG_PR 18
  34 #define REF_REG_RET regs->regs[REG_RET]
  35 #define REF_REG_SP regs->regs[REG_SP]
  36 #define DEREF_REG_PR regs->regs[REG_PR]
  37 
  38 #define DEBUG_SIG 0
  39 
  40 static void
  41 handle_signal(struct ksignal *ksig, struct pt_regs *regs);
  42 
  43 static inline void
  44 handle_syscall_restart(struct pt_regs *regs, struct sigaction *sa)
  45 {
  46         /* If we're not from a syscall, bail out */
  47         if (regs->syscall_nr < 0)
  48                 return;
  49 
  50         /* check for system call restart.. */
  51         switch (regs->regs[REG_RET]) {
  52                 case -ERESTART_RESTARTBLOCK:
  53                 case -ERESTARTNOHAND:
  54                 no_system_call_restart:
  55                         regs->regs[REG_RET] = -EINTR;
  56                         break;
  57 
  58                 case -ERESTARTSYS:
  59                         if (!(sa->sa_flags & SA_RESTART))
  60                                 goto no_system_call_restart;
  61                 /* fallthrough */
  62                 case -ERESTARTNOINTR:
  63                         /* Decode syscall # */
  64                         regs->regs[REG_RET] = regs->syscall_nr;
  65                         regs->pc -= 4;
  66                         break;
  67         }
  68 }
  69 
  70 /*
  71  * Note that 'init' is a special process: it doesn't get signals it doesn't
  72  * want to handle. Thus you cannot kill init even with a SIGKILL even by
  73  * mistake.
  74  *
  75  * Note that we go through the signals twice: once to check the signals that
  76  * the kernel can handle, and then we build all the user-level signal handling
  77  * stack-frames in one go after that.
  78  */
  79 static void do_signal(struct pt_regs *regs)
  80 {
  81         struct ksignal ksig;
  82 
  83         /*
  84          * We want the common case to go fast, which
  85          * is why we may in certain cases get here from
  86          * kernel mode. Just return without doing anything
  87          * if so.
  88          */
  89         if (!user_mode(regs))
  90                 return;
  91 
  92         if (get_signal(&ksig)) {
  93                 handle_syscall_restart(regs, &ksig.ka.sa);
  94 
  95                 /* Whee!  Actually deliver the signal.  */
  96                 handle_signal(&ksig, regs);
  97                 return;
  98         }
  99 
 100         /* Did we come from a system call? */
 101         if (regs->syscall_nr >= 0) {
 102                 /* Restart the system call - no handlers present */
 103                 switch (regs->regs[REG_RET]) {
 104                 case -ERESTARTNOHAND:
 105                 case -ERESTARTSYS:
 106                 case -ERESTARTNOINTR:
 107                         /* Decode Syscall # */
 108                         regs->regs[REG_RET] = regs->syscall_nr;
 109                         regs->pc -= 4;
 110                         break;
 111 
 112                 case -ERESTART_RESTARTBLOCK:
 113                         regs->regs[REG_RET] = __NR_restart_syscall;
 114                         regs->pc -= 4;
 115                         break;
 116                 }
 117         }
 118 
 119         /* No signal to deliver -- put the saved sigmask back */
 120         restore_saved_sigmask();
 121 }
 122 
 123 /*
 124  * Do a signal return; undo the signal stack.
 125  */
 126 struct sigframe {
 127         struct sigcontext sc;
 128         unsigned long extramask[_NSIG_WORDS-1];
 129         long long retcode[2];
 130 };
 131 
 132 struct rt_sigframe {
 133         struct siginfo __user *pinfo;
 134         void *puc;
 135         struct siginfo info;
 136         struct ucontext uc;
 137         long long retcode[2];
 138 };
 139 
 140 #ifdef CONFIG_SH_FPU
 141 static inline int
 142 restore_sigcontext_fpu(struct pt_regs *regs, struct sigcontext __user *sc)
 143 {
 144         int err = 0;
 145         int fpvalid;
 146 
 147         err |= __get_user (fpvalid, &sc->sc_fpvalid);
 148         conditional_used_math(fpvalid);
 149         if (! fpvalid)
 150                 return err;
 151 
 152         if (current == last_task_used_math) {
 153                 last_task_used_math = NULL;
 154                 regs->sr |= SR_FD;
 155         }
 156 
 157         err |= __copy_from_user(&current->thread.xstate->hardfpu, &sc->sc_fpregs[0],
 158                                 (sizeof(long long) * 32) + (sizeof(int) * 1));
 159 
 160         return err;
 161 }
 162 
 163 static inline int
 164 setup_sigcontext_fpu(struct pt_regs *regs, struct sigcontext __user *sc)
 165 {
 166         int err = 0;
 167         int fpvalid;
 168 
 169         fpvalid = !!used_math();
 170         err |= __put_user(fpvalid, &sc->sc_fpvalid);
 171         if (! fpvalid)
 172                 return err;
 173 
 174         if (current == last_task_used_math) {
 175                 enable_fpu();
 176                 save_fpu(current);
 177                 disable_fpu();
 178                 last_task_used_math = NULL;
 179                 regs->sr |= SR_FD;
 180         }
 181 
 182         err |= __copy_to_user(&sc->sc_fpregs[0], &current->thread.xstate->hardfpu,
 183                               (sizeof(long long) * 32) + (sizeof(int) * 1));
 184         clear_used_math();
 185 
 186         return err;
 187 }
 188 #else
 189 static inline int
 190 restore_sigcontext_fpu(struct pt_regs *regs, struct sigcontext __user *sc)
 191 {
 192         return 0;
 193 }
 194 static inline int
 195 setup_sigcontext_fpu(struct pt_regs *regs, struct sigcontext __user *sc)
 196 {
 197         return 0;
 198 }
 199 #endif
 200 
 201 static int
 202 restore_sigcontext(struct pt_regs *regs, struct sigcontext __user *sc, long long *r2_p)
 203 {
 204         unsigned int err = 0;
 205         unsigned long long current_sr, new_sr;
 206 #define SR_MASK 0xffff8cfd
 207 
 208 #define COPY(x)         err |= __get_user(regs->x, &sc->sc_##x)
 209 
 210         COPY(regs[0]);  COPY(regs[1]);  COPY(regs[2]);  COPY(regs[3]);
 211         COPY(regs[4]);  COPY(regs[5]);  COPY(regs[6]);  COPY(regs[7]);
 212         COPY(regs[8]);  COPY(regs[9]);  COPY(regs[10]); COPY(regs[11]);
 213         COPY(regs[12]); COPY(regs[13]); COPY(regs[14]); COPY(regs[15]);
 214         COPY(regs[16]); COPY(regs[17]); COPY(regs[18]); COPY(regs[19]);
 215         COPY(regs[20]); COPY(regs[21]); COPY(regs[22]); COPY(regs[23]);
 216         COPY(regs[24]); COPY(regs[25]); COPY(regs[26]); COPY(regs[27]);
 217         COPY(regs[28]); COPY(regs[29]); COPY(regs[30]); COPY(regs[31]);
 218         COPY(regs[32]); COPY(regs[33]); COPY(regs[34]); COPY(regs[35]);
 219         COPY(regs[36]); COPY(regs[37]); COPY(regs[38]); COPY(regs[39]);
 220         COPY(regs[40]); COPY(regs[41]); COPY(regs[42]); COPY(regs[43]);
 221         COPY(regs[44]); COPY(regs[45]); COPY(regs[46]); COPY(regs[47]);
 222         COPY(regs[48]); COPY(regs[49]); COPY(regs[50]); COPY(regs[51]);
 223         COPY(regs[52]); COPY(regs[53]); COPY(regs[54]); COPY(regs[55]);
 224         COPY(regs[56]); COPY(regs[57]); COPY(regs[58]); COPY(regs[59]);
 225         COPY(regs[60]); COPY(regs[61]); COPY(regs[62]);
 226         COPY(tregs[0]); COPY(tregs[1]); COPY(tregs[2]); COPY(tregs[3]);
 227         COPY(tregs[4]); COPY(tregs[5]); COPY(tregs[6]); COPY(tregs[7]);
 228 
 229         /* Prevent the signal handler manipulating SR in a way that can
 230            crash the kernel. i.e. only allow S, Q, M, PR, SZ, FR to be
 231            modified */
 232         current_sr = regs->sr;
 233         err |= __get_user(new_sr, &sc->sc_sr);
 234         regs->sr &= SR_MASK;
 235         regs->sr |= (new_sr & ~SR_MASK);
 236 
 237         COPY(pc);
 238 
 239 #undef COPY
 240 
 241         /* Must do this last in case it sets regs->sr.fd (i.e. after rest of sr
 242          * has been restored above.) */
 243         err |= restore_sigcontext_fpu(regs, sc);
 244 
 245         regs->syscall_nr = -1;          /* disable syscall checks */
 246         err |= __get_user(*r2_p, &sc->sc_regs[REG_RET]);
 247         return err;
 248 }
 249 
 250 asmlinkage int sys_sigreturn(unsigned long r2, unsigned long r3,
 251                                    unsigned long r4, unsigned long r5,
 252                                    unsigned long r6, unsigned long r7,
 253                                    struct pt_regs * regs)
 254 {
 255         struct sigframe __user *frame = (struct sigframe __user *) (long) REF_REG_SP;
 256         sigset_t set;
 257         long long ret;
 258 
 259         /* Always make any pending restarted system calls return -EINTR */
 260         current->restart_block.fn = do_no_restart_syscall;
 261 
 262         if (!access_ok(frame, sizeof(*frame)))
 263                 goto badframe;
 264 
 265         if (__get_user(set.sig[0], &frame->sc.oldmask)
 266             || (_NSIG_WORDS > 1
 267                 && __copy_from_user(&set.sig[1], &frame->extramask,
 268                                     sizeof(frame->extramask))))
 269                 goto badframe;
 270 
 271         set_current_blocked(&set);
 272 
 273         if (restore_sigcontext(regs, &frame->sc, &ret))
 274                 goto badframe;
 275         regs->pc -= 4;
 276 
 277         return (int) ret;
 278 
 279 badframe:
 280         force_sig(SIGSEGV);
 281         return 0;
 282 }
 283 
 284 asmlinkage int sys_rt_sigreturn(unsigned long r2, unsigned long r3,
 285                                 unsigned long r4, unsigned long r5,
 286                                 unsigned long r6, unsigned long r7,
 287                                 struct pt_regs * regs)
 288 {
 289         struct rt_sigframe __user *frame = (struct rt_sigframe __user *) (long) REF_REG_SP;
 290         sigset_t set;
 291         long long ret;
 292 
 293         /* Always make any pending restarted system calls return -EINTR */
 294         current->restart_block.fn = do_no_restart_syscall;
 295 
 296         if (!access_ok(frame, sizeof(*frame)))
 297                 goto badframe;
 298 
 299         if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
 300                 goto badframe;
 301 
 302         set_current_blocked(&set);
 303 
 304         if (restore_sigcontext(regs, &frame->uc.uc_mcontext, &ret))
 305                 goto badframe;
 306         regs->pc -= 4;
 307 
 308         if (restore_altstack(&frame->uc.uc_stack))
 309                 goto badframe;
 310 
 311         return (int) ret;
 312 
 313 badframe:
 314         force_sig(SIGSEGV);
 315         return 0;
 316 }
 317 
 318 /*
 319  * Set up a signal frame.
 320  */
 321 static int
 322 setup_sigcontext(struct sigcontext __user *sc, struct pt_regs *regs,
 323                  unsigned long mask)
 324 {
 325         int err = 0;
 326 
 327         /* Do this first, otherwise is this sets sr->fd, that value isn't preserved. */
 328         err |= setup_sigcontext_fpu(regs, sc);
 329 
 330 #define COPY(x)         err |= __put_user(regs->x, &sc->sc_##x)
 331 
 332         COPY(regs[0]);  COPY(regs[1]);  COPY(regs[2]);  COPY(regs[3]);
 333         COPY(regs[4]);  COPY(regs[5]);  COPY(regs[6]);  COPY(regs[7]);
 334         COPY(regs[8]);  COPY(regs[9]);  COPY(regs[10]); COPY(regs[11]);
 335         COPY(regs[12]); COPY(regs[13]); COPY(regs[14]); COPY(regs[15]);
 336         COPY(regs[16]); COPY(regs[17]); COPY(regs[18]); COPY(regs[19]);
 337         COPY(regs[20]); COPY(regs[21]); COPY(regs[22]); COPY(regs[23]);
 338         COPY(regs[24]); COPY(regs[25]); COPY(regs[26]); COPY(regs[27]);
 339         COPY(regs[28]); COPY(regs[29]); COPY(regs[30]); COPY(regs[31]);
 340         COPY(regs[32]); COPY(regs[33]); COPY(regs[34]); COPY(regs[35]);
 341         COPY(regs[36]); COPY(regs[37]); COPY(regs[38]); COPY(regs[39]);
 342         COPY(regs[40]); COPY(regs[41]); COPY(regs[42]); COPY(regs[43]);
 343         COPY(regs[44]); COPY(regs[45]); COPY(regs[46]); COPY(regs[47]);
 344         COPY(regs[48]); COPY(regs[49]); COPY(regs[50]); COPY(regs[51]);
 345         COPY(regs[52]); COPY(regs[53]); COPY(regs[54]); COPY(regs[55]);
 346         COPY(regs[56]); COPY(regs[57]); COPY(regs[58]); COPY(regs[59]);
 347         COPY(regs[60]); COPY(regs[61]); COPY(regs[62]);
 348         COPY(tregs[0]); COPY(tregs[1]); COPY(tregs[2]); COPY(tregs[3]);
 349         COPY(tregs[4]); COPY(tregs[5]); COPY(tregs[6]); COPY(tregs[7]);
 350         COPY(sr);       COPY(pc);
 351 
 352 #undef COPY
 353 
 354         err |= __put_user(mask, &sc->oldmask);
 355 
 356         return err;
 357 }
 358 
 359 /*
 360  * Determine which stack to use..
 361  */
 362 static inline void __user *
 363 get_sigframe(struct k_sigaction *ka, unsigned long sp, size_t frame_size)
 364 {
 365         if ((ka->sa.sa_flags & SA_ONSTACK) != 0 && ! sas_ss_flags(sp))
 366                 sp = current->sas_ss_sp + current->sas_ss_size;
 367 
 368         return (void __user *)((sp - frame_size) & -8ul);
 369 }
 370 
 371 void sa_default_restorer(void);         /* See comments below */
 372 void sa_default_rt_restorer(void);      /* See comments below */
 373 
 374 static int setup_frame(struct ksignal *ksig, sigset_t *set, struct pt_regs *regs)
 375 {
 376         struct sigframe __user *frame;
 377         int err = 0, sig = ksig->sig;
 378         int signal;
 379 
 380         frame = get_sigframe(&ksig->ka, regs->regs[REG_SP], sizeof(*frame));
 381 
 382         if (!access_ok(frame, sizeof(*frame)))
 383                 return -EFAULT;
 384 
 385         err |= setup_sigcontext(&frame->sc, regs, set->sig[0]);
 386 
 387         /* Give up earlier as i386, in case */
 388         if (err)
 389                 return -EFAULT;
 390 
 391         if (_NSIG_WORDS > 1) {
 392                 err |= __copy_to_user(frame->extramask, &set->sig[1],
 393                                       sizeof(frame->extramask)); }
 394 
 395         /* Give up earlier as i386, in case */
 396         if (err)
 397                 return -EFAULT;
 398 
 399         /* Set up to return from userspace.  If provided, use a stub
 400            already in userspace.  */
 401         if (ksig->ka.sa.sa_flags & SA_RESTORER) {
 402                 /*
 403                  * On SH5 all edited pointers are subject to NEFF
 404                  */
 405                 DEREF_REG_PR = neff_sign_extend((unsigned long)
 406                         ksig->ka->sa.sa_restorer | 0x1);
 407         } else {
 408                 /*
 409                  * Different approach on SH5.
 410                  * . Endianness independent asm code gets placed in entry.S .
 411                  *   This is limited to four ASM instructions corresponding
 412                  *   to two long longs in size.
 413                  * . err checking is done on the else branch only
 414                  * . flush_icache_range() is called upon __put_user() only
 415                  * . all edited pointers are subject to NEFF
 416                  * . being code, linker turns ShMedia bit on, always
 417                  *   dereference index -1.
 418                  */
 419                 DEREF_REG_PR = neff_sign_extend((unsigned long)
 420                         frame->retcode | 0x01);
 421 
 422                 if (__copy_to_user(frame->retcode,
 423                         (void *)((unsigned long)sa_default_restorer & (~1)), 16) != 0)
 424                         return -EFAULT;
 425 
 426                 /* Cohere the trampoline with the I-cache. */
 427                 flush_cache_sigtramp(DEREF_REG_PR-1);
 428         }
 429 
 430         /*
 431          * Set up registers for signal handler.
 432          * All edited pointers are subject to NEFF.
 433          */
 434         regs->regs[REG_SP] = neff_sign_extend((unsigned long)frame);
 435         regs->regs[REG_ARG1] = sig; /* Arg for signal handler */
 436 
 437         /* FIXME:
 438            The glibc profiling support for SH-5 needs to be passed a sigcontext
 439            so it can retrieve the PC.  At some point during 2003 the glibc
 440            support was changed to receive the sigcontext through the 2nd
 441            argument, but there are still versions of libc.so in use that use
 442            the 3rd argument.  Until libc.so is stabilised, pass the sigcontext
 443            through both 2nd and 3rd arguments.
 444         */
 445 
 446         regs->regs[REG_ARG2] = (unsigned long long)(unsigned long)(signed long)&frame->sc;
 447         regs->regs[REG_ARG3] = (unsigned long long)(unsigned long)(signed long)&frame->sc;
 448 
 449         regs->pc = neff_sign_extend((unsigned long)ksig->ka.sa.sa_handler);
 450 
 451         /* Broken %016Lx */
 452         pr_debug("SIG deliver (#%d,%s:%d): sp=%p pc=%08Lx%08Lx link=%08Lx%08Lx\n",
 453                  sig, current->comm, current->pid, frame,
 454                  regs->pc >> 32, regs->pc & 0xffffffff,
 455                  DEREF_REG_PR >> 32, DEREF_REG_PR & 0xffffffff);
 456 
 457         return 0;
 458 }
 459 
 460 static int setup_rt_frame(struct ksignal *kig, sigset_t *set,
 461                           struct pt_regs *regs)
 462 {
 463         struct rt_sigframe __user *frame;
 464         int err = 0, sig = ksig->sig;
 465 
 466         frame = get_sigframe(&ksig->ka, regs->regs[REG_SP], sizeof(*frame));
 467 
 468         if (!access_ok(frame, sizeof(*frame)))
 469                 return -EFAULT;
 470 
 471         err |= __put_user(&frame->info, &frame->pinfo);
 472         err |= __put_user(&frame->uc, &frame->puc);
 473         err |= copy_siginfo_to_user(&frame->info, &ksig->info);
 474 
 475         /* Give up earlier as i386, in case */
 476         if (err)
 477                 return -EFAULT;
 478 
 479         /* Create the ucontext.  */
 480         err |= __put_user(0, &frame->uc.uc_flags);
 481         err |= __put_user(0, &frame->uc.uc_link);
 482         err |= __save_altstack(&frame->uc.uc_stack, regs->regs[REG_SP]);
 483         err |= setup_sigcontext(&frame->uc.uc_mcontext,
 484                                 regs, set->sig[0]);
 485         err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
 486 
 487         /* Give up earlier as i386, in case */
 488         if (err)
 489                 return -EFAULT;
 490 
 491         /* Set up to return from userspace.  If provided, use a stub
 492            already in userspace.  */
 493         if (ksig->ka.sa.sa_flags & SA_RESTORER) {
 494                 /*
 495                  * On SH5 all edited pointers are subject to NEFF
 496                  */
 497                 DEREF_REG_PR = neff_sign_extend((unsigned long)
 498                         ksig->ka.sa.sa_restorer | 0x1);
 499         } else {
 500                 /*
 501                  * Different approach on SH5.
 502                  * . Endianness independent asm code gets placed in entry.S .
 503                  *   This is limited to four ASM instructions corresponding
 504                  *   to two long longs in size.
 505                  * . err checking is done on the else branch only
 506                  * . flush_icache_range() is called upon __put_user() only
 507                  * . all edited pointers are subject to NEFF
 508                  * . being code, linker turns ShMedia bit on, always
 509                  *   dereference index -1.
 510                  */
 511                 DEREF_REG_PR = neff_sign_extend((unsigned long)
 512                         frame->retcode | 0x01);
 513 
 514                 if (__copy_to_user(frame->retcode,
 515                         (void *)((unsigned long)sa_default_rt_restorer & (~1)), 16) != 0)
 516                         return -EFAULT;
 517 
 518                 /* Cohere the trampoline with the I-cache. */
 519                 flush_icache_range(DEREF_REG_PR-1, DEREF_REG_PR-1+15);
 520         }
 521 
 522         /*
 523          * Set up registers for signal handler.
 524          * All edited pointers are subject to NEFF.
 525          */
 526         regs->regs[REG_SP] = neff_sign_extend((unsigned long)frame);
 527         regs->regs[REG_ARG1] = sig; /* Arg for signal handler */
 528         regs->regs[REG_ARG2] = (unsigned long long)(unsigned long)(signed long)&frame->info;
 529         regs->regs[REG_ARG3] = (unsigned long long)(unsigned long)(signed long)&frame->uc.uc_mcontext;
 530         regs->pc = neff_sign_extend((unsigned long)ksig->ka.sa.sa_handler);
 531 
 532         pr_debug("SIG deliver (#%d,%s:%d): sp=%p pc=%08Lx%08Lx link=%08Lx%08Lx\n",
 533                  sig, current->comm, current->pid, frame,
 534                  regs->pc >> 32, regs->pc & 0xffffffff,
 535                  DEREF_REG_PR >> 32, DEREF_REG_PR & 0xffffffff);
 536 
 537         return 0;
 538 }
 539 
 540 /*
 541  * OK, we're invoking a handler
 542  */
 543 static void
 544 handle_signal(struct ksignal *ksig, struct pt_regs *regs)
 545 {
 546         sigset_t *oldset = sigmask_to_save();
 547         int ret;
 548 
 549         /* Set up the stack frame */
 550         if (ksig->ka.sa.sa_flags & SA_SIGINFO)
 551                 ret = setup_rt_frame(ksig, oldset, regs);
 552         else
 553                 ret = setup_frame(ksig, oldset, regs);
 554 
 555         signal_setup_done(ret, ksig, test_thread_flag(TIF_SINGLESTEP));
 556 }
 557 
 558 asmlinkage void do_notify_resume(struct pt_regs *regs, unsigned long thread_info_flags)
 559 {
 560         if (thread_info_flags & _TIF_SIGPENDING)
 561                 do_signal(regs);
 562 
 563         if (thread_info_flags & _TIF_NOTIFY_RESUME) {
 564                 clear_thread_flag(TIF_NOTIFY_RESUME);
 565                 tracehook_notify_resume(regs);
 566         }
 567 }