/* create mesh from a vector of nodes, element list in format => * {nuber of nodes, node0, node1, ..., material}, {REPEAT}, ..., 0 (end of list); and surface colors in format => * global surface, {number of nodes, node0, node1, ..., surface}, {REPEAT}, ..., 0 (end of list); */ MESH_DATA* MESH_Create (REAL (*nodes) [3], int *elements, int *surfaces) { int maximal_node, minimal_node, elements_count, faces_count, temp, *eleptr, n; REAL (*node) [3]; MEM *elemem, facmem, mapmem; ELEMENT *ele, *enx, *elist; FACE *fac, *cac, *gac, *flist; MAP *faces, *smap; MESH_DATA *msh; maximal_node = 0; minimal_node = INT_MAX; elements_count = 0; faces_count = 0; /* create mesh storage */ ERRMEM (msh = static_cast<MESH_DATA*>(MEM_CALLOC (sizeof (MESH_DATA)))); elemem = &msh->elemem; /* calculate elements */ for (eleptr = elements; eleptr [0]; eleptr += (eleptr [0]+2)) elements_count ++; MEM_Init (elemem, sizeof (ELEMENT), elements_count); MEM_Init (&facmem, sizeof (FACE), MEMCHUNK); MEM_Init (&mapmem, sizeof (MAP), MEMCHUNK); MEM_Init (&msh->mapmem, sizeof (MAP), MIN (elements_count, MEMCHUNK)); elist = NULL; flist = NULL; faces = NULL; /* create elements list & face adjacency map */ for (eleptr = elements; eleptr [0]; eleptr += (eleptr [0]+2)) { ASSERT ( eleptr [0] == 4 || /* tetrahedron */ eleptr [0] == 5 || /* pyramid */ eleptr [0] == 6 || /* wedge */ eleptr [0] == 8, /* hexahedron */ "ERROR: unsupported element type"); ele = create_element (elemem, eleptr); flist = create_faces (&facmem, &mapmem, &faces, ele, flist); ele->next = elist; elist = ele; /* node number extrema */ temp = maximal (eleptr); if (temp > maximal_node) maximal_node = temp; temp = minimal (eleptr); if (temp < minimal_node) minimal_node = temp; } /* calculate faces */ for (fac = flist; fac; fac = fac->next) if (fac->ele) faces_count ++; /* alocate additional storage */ MEM_Init (&msh->facmem, sizeof (FACE), faces_count); msh->nodes_count = (maximal_node - minimal_node + 1); ERRMEM (msh->nodes = static_cast<REAL(*)[3]>(malloc (sizeof (REAL [3]) * (msh->nodes_count)))); msh->surfeles_count = msh->bulkeles_count = 0; msh->surfeles = msh->bulkeles = NULL; /* set up elements */ for (ele = elist; ele; ele = enx) { enx = ele->next; if (minimal_node > 0) /* impose 0-based indexing */ { for (temp = 0; temp < ele->type; temp ++) ele->nodes [temp] -= minimal_node; } ele->prev = NULL; if (ele->neighs < neighs (ele->type)) /* surface element */ { msh->surfeles_count ++; ele->next = msh->surfeles; if (msh->surfeles) msh->surfeles->prev = ele; msh->surfeles = ele; } else /* bulk element */ { msh->bulkeles_count ++; ele->next = msh->bulkeles; if (msh->bulkeles) msh->bulkeles->prev = ele; msh->bulkeles = ele; } } /* create surfaces map => skip first element of 'surfaces' == the global surface kind */ for (eleptr = (surfaces + 1), smap = NULL, temp = 0; eleptr [0]; eleptr += (eleptr [0]+2), temp ++) { fac = static_cast<FACE*>(MEM_Alloc (&facmem)); ASSERT ( eleptr [0] == 3 || /* triangle */ eleptr [0] == 4, /* quad */ "ERROR: unsupported face type"); fac->type = eleptr [0]; for (n = 0; n < eleptr [0]; n ++) fac->nodes [n] = eleptr [n+1]; sort (fac->nodes, fac->nodes+fac->type-1); fac->color = eleptr [eleptr [0] + 1]; MAP_Insert (&mapmem, &smap, fac, /* map by the type/nodes key */ fac, face_compare); } /* set up nodes */ for (temp = minimal_node, node = msh->nodes; temp <= maximal_node; temp ++, node ++) { COPY (nodes [temp], *node); } /* set up faces */ for (fac = flist; fac; fac = fac->next) { if (fac->ele) /* see (***) */ { ele = fac->ele; cac = static_cast<FACE*>(MEM_Alloc (&msh->facmem)); setup_face (ele, fac->index, cac, 0); /* setup face nodes without sorting them */ cac->index = fac->index; cac->ele = fac->ele; setup_normal (msh->nodes, cac); /* calculate outer spatial normal */ cac->next = ele->faces; /* append element face list */ ele->faces = cac; /* set the mapped surface kind if possible => otherwise the global one */ gac = static_cast<FACE*>(MAP_Find (smap, fac, face_compare)); cac->color = (gac ? gac->color : surfaces [0]); } } /* create mesh face list */ for (ele = msh->surfeles; ele; ele = ele->next) { for (fac = ele->faces; fac; fac = fac->next) { fac->n = msh->faces; msh->faces = fac; } } /* clean up */ MEM_Release (&facmem); MEM_Release (&mapmem); return msh; }
static int restore_sigcontext(struct pt_regs *regs, struct sigcontext __user *sc, int *rval_p) { unsigned int err = 0; #define COPY(x) {err |= __get_user(regs->x, &sc->regs.x); } COPY(r0); COPY(r1); COPY(r2); COPY(r3); COPY(r4); COPY(r5); COPY(r6); COPY(r7); COPY(r8); COPY(r9); COPY(r10); COPY(r11); COPY(r12); COPY(r13); COPY(r14); COPY(r15); COPY(r16); COPY(r17); COPY(r18); COPY(r19); COPY(r20); COPY(r21); COPY(r22); COPY(r23); COPY(r24); COPY(r25); COPY(r26); COPY(r27); COPY(r28); COPY(r29); COPY(r30); COPY(r31); COPY(pc); COPY(ear); COPY(esr); COPY(fsr); #undef COPY *rval_p = regs->r3; return err; }
static int setup_rt_frame(int signr, struct k_sigaction *ka, siginfo_t *info, sigset_t *set, struct pt_regs *regs) { struct rt_sigframe __user *frame; unsigned long __user *retcode; int err = 0; frame = get_sigframe(ka, regs, sizeof(*frame)); if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame))) goto segv_and_exit; err |= __put_user(&frame->info, &frame->pinfo); err |= __put_user(&frame->uc, &frame->puc); err |= copy_siginfo_to_user(&frame->info, info); /* Clear all the bits of the ucontext we don't use. */ err |= __clear_user(&frame->uc, offsetof(struct ucontext, uc_mcontext)); err |= setup_sigcontext(&frame->uc.uc_mcontext, regs, set->sig[0]); err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set)); /* Set up to return from userspace */ retcode = (unsigned long __user *) &frame->retcode; /* The access_ok check was done above, so use __put_user here */ #define COPY(x) (err |= __put_user(x, retcode++)) COPY(0x0000002AUL | (__NR_rt_sigreturn << 7)); /* MVK __NR_rt_sigreturn,B0 */ COPY(0x10000000UL); /* SWE */ COPY(0x00006000UL); /* NOP 4 */ COPY(0x00006000UL); /* NOP 4 */ COPY(0x00006000UL); /* NOP 4 */ COPY(0x00006000UL); /* NOP 4 */ COPY(0x00006000UL); /* NOP 4 */ COPY(0x00006000UL); /* NOP 4 */ COPY(0x00006000UL); /* NOP 4 */ #undef COPY if (err) goto segv_and_exit; flush_icache_range((unsigned long) &frame->retcode, (unsigned long) &frame->retcode + RETCODE_SIZE); retcode = (unsigned long __user *) &frame->retcode; /* Change user context to branch to signal handler */ regs->sp = (unsigned long) frame - 8; regs->b3 = (unsigned long) retcode; regs->pc = (unsigned long) ka->sa.sa_handler; /* Give the signal number to the handler */ regs->a4 = signr; /* * For realtime signals we must also set the second and third * arguments for the signal handler. * -- Peter Maydell <*****@*****.**> 2000-12-06 */ regs->b4 = (unsigned long)&frame->info; regs->a6 = (unsigned long)&frame->uc; return 0; segv_and_exit: force_sigsegv(signr, current); return -EFAULT; }
static int setup_sigcontext(struct sigcontext __user *sc, struct pt_regs *regs, unsigned long mask) { int err = 0; #define COPY(x) err |= __put_user(regs->x, &sc->sc_##x) COPY(r4); COPY(r5); COPY(r6); COPY(pt_regs); COPY(r0); COPY(r1); COPY(r2); COPY(r3); COPY(r7); COPY(r8); COPY(r9); COPY(r10); COPY(r11); COPY(r12); COPY(acc0h); COPY(acc0l); COPY(acc1h); /* ISA_DSP_LEVEL2 only */ COPY(acc1l); /* ISA_DSP_LEVEL2 only */ COPY(psw); COPY(bpc); COPY(bbpsw); COPY(bbpc); COPY(spu); COPY(fp); COPY(lr); COPY(spi); #undef COPY err |= __put_user(mask, &sc->oldmask); return err; }
static int restore_sigcontext(struct pt_regs *regs, struct sigcontext __user *sc, long long *r2_p) { unsigned int err = 0; unsigned long long current_sr, new_sr; #define SR_MASK 0xffff8cfd #define COPY(x) err |= __get_user(regs->x, &sc->sc_##x) COPY(regs[0]); COPY(regs[1]); COPY(regs[2]); COPY(regs[3]); COPY(regs[4]); COPY(regs[5]); COPY(regs[6]); COPY(regs[7]); COPY(regs[8]); COPY(regs[9]); COPY(regs[10]); COPY(regs[11]); COPY(regs[12]); COPY(regs[13]); COPY(regs[14]); COPY(regs[15]); COPY(regs[16]); COPY(regs[17]); COPY(regs[18]); COPY(regs[19]); COPY(regs[20]); COPY(regs[21]); COPY(regs[22]); COPY(regs[23]); COPY(regs[24]); COPY(regs[25]); COPY(regs[26]); COPY(regs[27]); COPY(regs[28]); COPY(regs[29]); COPY(regs[30]); COPY(regs[31]); COPY(regs[32]); COPY(regs[33]); COPY(regs[34]); COPY(regs[35]); COPY(regs[36]); COPY(regs[37]); COPY(regs[38]); COPY(regs[39]); COPY(regs[40]); COPY(regs[41]); COPY(regs[42]); COPY(regs[43]); COPY(regs[44]); COPY(regs[45]); COPY(regs[46]); COPY(regs[47]); COPY(regs[48]); COPY(regs[49]); COPY(regs[50]); COPY(regs[51]); COPY(regs[52]); COPY(regs[53]); COPY(regs[54]); COPY(regs[55]); COPY(regs[56]); COPY(regs[57]); COPY(regs[58]); COPY(regs[59]); COPY(regs[60]); COPY(regs[61]); COPY(regs[62]); COPY(tregs[0]); COPY(tregs[1]); COPY(tregs[2]); COPY(tregs[3]); COPY(tregs[4]); COPY(tregs[5]); COPY(tregs[6]); COPY(tregs[7]); /* Prevent the signal handler manipulating SR in a way that can crash the kernel. i.e. only allow S, Q, M, PR, SZ, FR to be modified */ current_sr = regs->sr; err |= __get_user(new_sr, &sc->sc_sr); regs->sr &= SR_MASK; regs->sr |= (new_sr & ~SR_MASK); COPY(pc); #undef COPY /* Must do this last in case it sets regs->sr.fd (i.e. after rest of sr * has been restored above.) */ err |= restore_sigcontext_fpu(regs, sc); regs->syscall_nr = -1; /* disable syscall checks */ err |= __get_user(*r2_p, &sc->sc_regs[REG_RET]); return err; }
void pathname_name1(CL_FORM *base) { COPY(ARG(0), ARG(2)); LOAD_SYMBOL(SYMBOL(Slisp, 234), ARG(3)); /* PATHNAME */ rt_struct_typep(ARG(2)); if(CL_TRUEP(ARG(2))) { COPY(ARG(0), ARG(2)); } else { COPY(ARG(0), ARG(2)); Fstringp(ARG(2)); if(CL_TRUEP(ARG(2))) { COPY(ARG(0), ARG(2)); LOAD_NIL(ARG(3)); COPY(SYMVAL(Slisp, 233), ARG(4)); /* *DEFAULT-PATHNAME-DEFAULTS* */ LOAD_FIXNUM(ARG(5), 0, ARG(5)); LOAD_NIL(ARG(6)); LOAD_NIL(ARG(7)); parse_namestring1(ARG(2)); mv_count = 1; } else { COPY(ARG(0), ARG(2)); LOAD_SYMBOL(SYMBOL(Slisp, 64), ARG(3)); /* STREAM */ rt_struct_typep(ARG(2)); if(CL_TRUEP(ARG(2))) { COPY(ARG(0), ARG(2)); LOAD_NIL(ARG(3)); file_name1(ARG(2)); COPY(SYMVAL(Slisp, 233), ARG(3)); /* *DEFAULT-PATHNAME-DEFAULTS* */ COPY(ARG(2), ARG(4)); LOAD_NIL(ARG(5)); COPY(ARG(3), ARG(6)); LOAD_FIXNUM(ARG(7), 0, ARG(7)); LOAD_NIL(ARG(8)); LOAD_NIL(ARG(9)); parse_namestring1(ARG(4)); mv_count = 1; COPY(ARG(4), ARG(2)); } else { LOAD_SMSTR((CL_FORM *)&Kpathname_name1[0], ARG(2)); /* etypecase: the value ~a is not a legal value */ COPY(ARG(0), ARG(3)); Ferror(ARG(2), 2); } } } COPY(ARG(2), ARG(3)); LOAD_SYMBOL(SYMBOL(Slisp, 234), ARG(4)); /* PATHNAME */ rt_struct_typep(ARG(3)); if(CL_TRUEP(ARG(3))) { COPY(OFFSET(AR_BASE(GET_FORM(ARG(2))), 3 + 1), ARG(3)); } else { COPY(SYMVAL(Slisp, 352), ARG(3)); /* NO_STRUCT */ COPY(ARG(2), ARG(4)); LOAD_SYMBOL(SYMBOL(Slisp, 234), ARG(5)); /* PATHNAME */ Ferror(ARG(3), 3); } if(CL_SYMBOLP(ARG(1)) && GET_SYMBOL(ARG(1)) == SYMBOL(Slisp, 278)) /* COMMON */ { COPY(ARG(2), ARG(4)); LOAD_SYMBOL(SYMBOL(Slisp, 234), ARG(5)); /* PATHNAME */ rt_struct_typep(ARG(4)); if(CL_TRUEP(ARG(4))) { COPY(OFFSET(AR_BASE(GET_FORM(ARG(2))), 0 + 1), ARG(4)); } else { COPY(SYMVAL(Slisp, 352), ARG(4)); /* NO_STRUCT */ COPY(ARG(2), ARG(5)); LOAD_SYMBOL(SYMBOL(Slisp, 234), ARG(6)); /* PATHNAME */ Ferror(ARG(4), 3); } COPY(ARG(4), ARG(5)); LOAD_SYMBOL(SYMBOL(Slisp, 263), ARG(6)); /* HOST */ rt_struct_typep(ARG(5)); if(CL_TRUEP(ARG(5))) { COPY(OFFSET(AR_BASE(GET_FORM(ARG(4))), 6 + 1), ARG(4)); } else { COPY(SYMVAL(Slisp, 352), ARG(5)); /* NO_STRUCT */ COPY(ARG(4), ARG(6)); LOAD_SYMBOL(SYMBOL(Slisp, 263), ARG(7)); /* HOST */ Ferror(ARG(5), 3); } LOAD_BOOL(CL_SYMBOLP(ARG(4)) && GET_SYMBOL(ARG(4)) == SYMBOL(Slisp, 279), ARG(4)); /* LOWER */ } else { LOAD_NIL(ARG(4)); } maybe_diddle_case(ARG(3)); COPY(ARG(3), ARG(0)); }
static void walk (struct state *st, int dir) { register int incr = 0; if (dir & (LEFT | RIGHT)) { /* left/right movement (mabye up/st->down too) */ st->walk_up = -st->walk_up; /* bouncing effect (even if hit a wall) */ if (dir & LEFT) { incr = X_INCR; st->walk_frame = (st->walk_up < 0) ? st->left1 : st->left2; } else { incr = -X_INCR; st->walk_frame = (st->walk_up < 0) ? st->right1 : st->right2; } if ((st->walk_lastdir == FRONT || st->walk_lastdir == DOWN) && dir & UP) { /* * workaround silly bug that leaves screen dust when guy is * facing forward or st->down and moves up-left/right. */ COPY(st->dpy, st->walk_frame, st->window, st->fg_gc, 0, 0, 64, 64, st->x, st->y); } /* note that maybe neither UP nor DOWN is set! */ if (dir & UP && st->y > Y_INCR) st->y -= Y_INCR; else if (dir & DOWN && st->y < st->Height - 64) st->y += Y_INCR; } /* Explicit up/st->down movement only (no left/right) */ else if (dir == UP) COPY(st->dpy, st->front, st->window, st->fg_gc, 0, 0, 64, 64, st->x, st->y -= Y_INCR); else if (dir == DOWN) COPY(st->dpy, st->down, st->window, st->fg_gc, 0, 0, 64, 64, st->x, st->y += Y_INCR); else if (dir == FRONT && st->walk_frame != st->front) { if (st->walk_up > 0) st->walk_up = -st->walk_up; if (st->walk_lastdir & LEFT) st->walk_frame = st->left_front; else if (st->walk_lastdir & RIGHT) st->walk_frame = st->right_front; else st->walk_frame = st->front; COPY(st->dpy, st->walk_frame, st->window, st->fg_gc, 0, 0, 64, 64, st->x, st->y); } if (dir & LEFT) while (--incr >= 0) { COPY(st->dpy, st->walk_frame, st->window, st->fg_gc, 0, 0, 64, 64, --st->x, st->y + st->walk_up); } else if (dir & RIGHT) while (++incr <= 0) { COPY(st->dpy, st->walk_frame, st->window, st->fg_gc, 0, 0, 64, 64, ++st->x, st->y + st->walk_up); } st->walk_lastdir = dir; }
void FcharGE(CL_FORM *base, int nargs) { CL_FORM *rest_0; CL_FORM *local; rest_0 = ARG(1); local = ARG(nargs); { CL_FORM *rest_1; LOAD_NIL(LOCAL(0)); rest_1 = rest_0; M1_1:; if(NOT(REST_NOT_EMPTY(rest_1))) { LOAD_NIL(LOCAL(0)); LOAD_SYMBOL(SYMBOL(Slisp, 48), ARG(0)); /* T */ goto RETURN1; } { CL_FORM *rest_2; rest_2 = rest_1; REST_CAR(rest_2, LOCAL(0)); } if(CL_CHARP(ARG(0))) { COPY(ARG(0), LOCAL(1)); } else { COPY(SYMVAL(Slisp, 58), LOCAL(1)); /* WRONG_TYPE */ COPY(ARG(0), LOCAL(2)); LOAD_SYMBOL(SYMBOL(Slisp, 18), LOCAL(3)); /* CHARACTER */ Ferror(LOCAL(1), 3); } rt_char_code(LOCAL(1)); if(CL_CHARP(LOCAL(0))) { COPY(LOCAL(0), LOCAL(2)); } else { COPY(SYMVAL(Slisp, 58), LOCAL(2)); /* WRONG_TYPE */ COPY(LOCAL(0), LOCAL(3)); LOAD_SYMBOL(SYMBOL(Slisp, 18), LOCAL(4)); /* CHARACTER */ Ferror(LOCAL(2), 3); } rt_char_code(LOCAL(2)); Flt(LOCAL(1), 2); if(CL_TRUEP(LOCAL(1))) { LOAD_NIL(ARG(0)); goto RETURN1; } COPY(LOCAL(0), ARG(0)); { CL_FORM *rest_3; rest_3 = rest_1; rest_1 = REST_CDR(rest_3); } goto M1_1; } RETURN1:; }
static int restore_sigcontext(struct pt_regs *regs, struct sigcontext __user *sc, int *r0_p) { unsigned int err = 0; /* Always make any pending restarted system calls return -EINTR */ current_thread_info()->restart_block.fn = do_no_restart_syscall; #define COPY(x) err |= __get_user(regs->x, &sc->sc_##x) COPY(r4); COPY(r5); COPY(r6); COPY(pt_regs); /* COPY(r0); Skip r0 */ COPY(r1); COPY(r2); COPY(r3); COPY(r7); COPY(r8); COPY(r9); COPY(r10); COPY(r11); COPY(r12); #if defined(CONFIG_ISA_M32R2) && defined(CONFIG_ISA_DSP_LEVEL2) COPY(acc0h); COPY(acc0l); COPY(acc1h); COPY(acc1l); #elif defined(CONFIG_ISA_M32R2) || defined(CONFIG_ISA_M32R) COPY(acch); COPY(accl); #else #error unknown isa configuration #endif COPY(psw); COPY(bpc); COPY(bbpsw); COPY(bbpc); COPY(spu); COPY(fp); COPY(lr); COPY(spi); #undef COPY regs->syscall_nr = -1; /* disable syscall checks */ err |= __get_user(*r0_p, &sc->sc_r0); return err; }
void vector_push_extend1(CL_FORM *base) { COPY(ARG(1), ARG(3)); Farray_has_fill_pointer_p(ARG(3)); if(CL_TRUEP(ARG(3))) { } else { COPY(SYMVAL(Slisp, 154), ARG(3)); /* NO_FILL_PTR */ COPY(ARG(1), ARG(4)); Ferror(ARG(3), 2); } COPY(ARG(1), ARG(3)); LOAD_SYMBOL(SYMBOL(Slisp, 150), ARG(4)); /* COMPLEX-VECTOR */ rt_struct_typep(ARG(3)); if(CL_TRUEP(ARG(3))) { COPY(OFFSET(AR_BASE(GET_FORM(ARG(1))), 3 + 1), ARG(3)); } else { COPY(SYMVAL(Slisp, 352), ARG(3)); /* NO_STRUCT */ COPY(ARG(1), ARG(4)); LOAD_SYMBOL(SYMBOL(Slisp, 150), ARG(5)); /* COMPLEX-VECTOR */ Ferror(ARG(3), 3); } COPY(ARG(3), ARG(4)); COPY(ARG(1), ARG(5)); Farray_total_size(ARG(5)); Fge(ARG(4), 2); if(CL_TRUEP(ARG(4))) { COPY(ARG(1), ARG(4)); if(CL_TRUEP(ARG(2))) { COPY(ARG(1), ARG(5)); Farray_total_size(ARG(5)); COPY(ARG(2), ARG(6)); Fplus(ARG(5), 2); } else { LOAD_FIXNUM(ARG(5), 2, ARG(5)); COPY(ARG(1), ARG(6)); Farray_total_size(ARG(6)); Fmult(ARG(5), 2); } LOAD_NIL(ARG(6)); LOAD_NIL(ARG(7)); LOAD_NIL(ARG(8)); COPY(ARG(3), ARG(9)); LOAD_NIL(ARG(10)); LOAD_NIL(ARG(11)); LOAD_SYMBOL(SYMBOL(Slisp, 101), ARG(12)); /* FILL-POINTER */ COPY(ARG(3), ARG(13)); Flist(ARG(12), 2); LOAD_NIL(ARG(13)); LOAD_SYMBOL(SYMBOL(Slisp, 48), ARG(14)); /* T */ adjust_array1(ARG(4)); } COPY(ARG(0), ARG(4)); COPY(ARG(1), ARG(5)); COPY(ARG(3), ARG(6)); rt_set_vref(ARG(4)); COPY(ARG(3), ARG(4)); F1plus(ARG(4)); COPY(ARG(1), ARG(5)); Fset_fill_pointer(ARG(4)); COPY(ARG(3), ARG(0)); }
void shadowing_import1(CL_FORM *base) { coerce_to_package(ARG(1)); if(CL_LISTP(ARG(0))) { } else { COPY(ARG(0), ARG(2)); Flist(ARG(2), 1); COPY(ARG(2), ARG(0)); } LOAD_NIL(ARG(2)); COPY(ARG(0), ARG(3)); M1_1:; if(CL_ATOMP(ARG(3))) { LOAD_NIL(ARG(2)); goto RETURN1; } COPY(ARG(3), ARG(4)); COPY(GET_CAR(ARG(4)), ARG(2)); if(CL_SYMBOLP(ARG(2))) { LOAD_SMSTR(SYM_NAME(ARG(2)), ARG(4)); } else { if(CL_TRUEP(ARG(2))) { COPY(SYMVAL(Slisp, 676), ARG(4)); /* SYM_EXPECTED */ COPY(ARG(2), ARG(5)); Ferror(ARG(4), 2); } else { LOAD_SMSTR((CL_FORM *)&KClisp[266], ARG(4)); /* NIL */ } } COPY(ARG(1), ARG(5)); find_symbol1(ARG(4)); COPY(&mv_buf[0], ARG(5)); { int nargs; nargs = 2; mv_count = 1; { switch(nargs) { case 0: LOAD_NIL(ARG(4)); case 1: LOAD_NIL(ARG(5)); nargs = 2; } if(CL_SYMBOLP(ARG(2))) { LOAD_SMSTR(SYM_NAME(ARG(2)), ARG(6)); } else { if(CL_TRUEP(ARG(2))) { COPY(SYMVAL(Slisp, 676), ARG(6)); /* SYM_EXPECTED */ COPY(ARG(2), ARG(7)); Ferror(ARG(6), 2); } else { LOAD_SMSTR((CL_FORM *)&KClisp[266], ARG(6)); /* NIL */ } } LOAD_FIXNUM(ARG(7), 101, ARG(7)); COPY(ARG(6), ARG(8)); string_to_simple_string(ARG(8)); rt_sxhash_string(ARG(8)); COPY(ARG(8), ARG(9)); LOAD_FIXNUM(ARG(10), 101, ARG(10)); rt_floor(ARG(9)); COPY(&mv_buf[0], ARG(10)); mv_count = 1; { COPY(ARG(10), ARG(6)); } if(CL_SYMBOLP(ARG(5)) && GET_SYMBOL(ARG(5)) == SYMBOL(Slisp, 384)) /* INTERNAL */ { COPY(ARG(4), ARG(7)); COPY(ARG(1), ARG(8)); LOAD_SYMBOL(SYMBOL(Slisp, 354), ARG(9)); /* PACKAGE */ rt_struct_typep(ARG(8)); if(CL_TRUEP(ARG(8))) { COPY(OFFSET(AR_BASE(GET_FORM(ARG(1))), 2 + 1), ARG(8)); } else { COPY(SYMVAL(Slisp, 352), ARG(8)); /* NO_STRUCT */ COPY(ARG(1), ARG(9)); LOAD_SYMBOL(SYMBOL(Slisp, 354), ARG(10)); /* PACKAGE */ Ferror(ARG(8), 3); } COPY(ARG(6), ARG(9)); del_pack_sym(ARG(7)); } else { if(CL_SYMBOLP(ARG(5)) && GET_SYMBOL(ARG(5)) == SYMBOL(Slisp, 385)) /* EXTERNAL */ { COPY(ARG(4), ARG(7)); COPY(ARG(1), ARG(8)); LOAD_SYMBOL(SYMBOL(Slisp, 354), ARG(9)); /* PACKAGE */ rt_struct_typep(ARG(8)); if(CL_TRUEP(ARG(8))) { COPY(OFFSET(AR_BASE(GET_FORM(ARG(1))), 3 + 1), ARG(8)); } else { COPY(SYMVAL(Slisp, 352), ARG(8)); /* NO_STRUCT */ COPY(ARG(1), ARG(9)); LOAD_SYMBOL(SYMBOL(Slisp, 354), ARG(10)); /* PACKAGE */ Ferror(ARG(8), 3); } COPY(ARG(6), ARG(9)); del_pack_sym(ARG(7)); } } } } COPY(ARG(2), ARG(4)); COPY(ARG(1), ARG(5)); internal_import(ARG(4)); COPY(ARG(1), ARG(5)); LOAD_SYMBOL(SYMBOL(Slisp, 354), ARG(6)); /* PACKAGE */ rt_struct_typep(ARG(5)); if(CL_TRUEP(ARG(5))) { COPY(OFFSET(AR_BASE(GET_FORM(ARG(1))), 4 + 1), ARG(5)); } else { COPY(SYMVAL(Slisp, 352), ARG(5)); /* NO_STRUCT */ COPY(ARG(1), ARG(6)); LOAD_SYMBOL(SYMBOL(Slisp, 354), ARG(7)); /* PACKAGE */ Ferror(ARG(5), 3); } ALLOC_CONS(ARG(6), ARG(2), ARG(5), ARG(4)); LOAD_FIXNUM(ARG(5), 4, ARG(5)); COPY(ARG(1), ARG(6)); LOAD_SYMBOL(SYMBOL(Slisp, 354), ARG(7)); /* PACKAGE */ rt_struct_typep(ARG(6)); if(CL_TRUEP(ARG(6))) { COPY(ARG(4), OFFSET(AR_BASE(GET_FORM(ARG(1))), 4 + 1)); } else { COPY(SYMVAL(Slisp, 352), ARG(6)); /* NO_STRUCT */ COPY(ARG(1), ARG(7)); LOAD_SYMBOL(SYMBOL(Slisp, 354), ARG(8)); /* PACKAGE */ Ferror(ARG(6), 3); } COPY(ARG(3), ARG(4)); COPY(GET_CDR(ARG(4)), ARG(3)); goto M1_1; RETURN1:; LOAD_SYMBOL(SYMBOL(Slisp, 48), ARG(0)); /* T */ }
/* * do a signal return; undo the signal stack. */ static int restore_sigcontext(struct pt_regs *regs, struct sigcontext __user *sc, long *_d0) { unsigned int err = 0; /* Always make any pending restarted system calls return -EINTR */ current_thread_info()->restart_block.fn = do_no_restart_syscall; if (is_using_fpu(current)) fpu_kill_state(current); #define COPY(x) err |= __get_user(regs->x, &sc->x) COPY(d1); COPY(d2); COPY(d3); COPY(a0); COPY(a1); COPY(a2); COPY(a3); COPY(e0); COPY(e1); COPY(e2); COPY(e3); COPY(e4); COPY(e5); COPY(e6); COPY(e7); COPY(lar); COPY(lir); COPY(mdr); COPY(mdrq); COPY(mcvf); COPY(mcrl); COPY(mcrh); COPY(sp); COPY(pc); #undef COPY { unsigned int tmpflags; #ifndef CONFIG_MN10300_USING_JTAG #define USER_EPSW (EPSW_FLAG_Z | EPSW_FLAG_N | EPSW_FLAG_C | EPSW_FLAG_V | \ EPSW_T | EPSW_nAR) #else #define USER_EPSW (EPSW_FLAG_Z | EPSW_FLAG_N | EPSW_FLAG_C | EPSW_FLAG_V | \ EPSW_nAR) #endif err |= __get_user(tmpflags, &sc->epsw); regs->epsw = (regs->epsw & ~USER_EPSW) | (tmpflags & USER_EPSW); regs->orig_d0 = -1; /* disable syscall checks */ } { struct fpucontext *buf; err |= __get_user(buf, &sc->fpucontext); if (buf) { if (verify_area(VERIFY_READ, buf, sizeof(*buf))) goto badframe; err |= fpu_restore_sigcontext(buf); } } err |= __get_user(*_d0, &sc->d0); return err; badframe: return 1; }
/* * store the userspace context into a signal frame */ static int setup_sigcontext(struct sigcontext __user *sc, struct fpucontext *fpuctx, struct pt_regs *regs, unsigned long mask) { int tmp, err = 0; #define COPY(x) err |= __put_user(regs->x, &sc->x) COPY(d0); COPY(d1); COPY(d2); COPY(d3); COPY(a0); COPY(a1); COPY(a2); COPY(a3); COPY(e0); COPY(e1); COPY(e2); COPY(e3); COPY(e4); COPY(e5); COPY(e6); COPY(e7); COPY(lar); COPY(lir); COPY(mdr); COPY(mdrq); COPY(mcvf); COPY(mcrl); COPY(mcrh); COPY(sp); COPY(epsw); COPY(pc); #undef COPY tmp = fpu_setup_sigcontext(fpuctx); if (tmp < 0) err = 1; else err |= __put_user(tmp ? fpuctx : NULL, &sc->fpucontext); /* non-iBCS2 extensions.. */ err |= __put_user(mask, &sc->oldmask); return err; }
static int restore_sigcontext(struct pt_regs *regs, struct sigcontext __user *sc, unsigned long *prax) { unsigned int err = 0; /* Always make any pending restarted system calls return -EINTR */ current_thread_info()->restart_block.fn = do_no_restart_syscall; #define COPY(x) err |= __get_user(regs->x, &sc->x) COPY(rdi); COPY(rsi); COPY(rbp); COPY(rsp); COPY(rbx); COPY(rdx); COPY(rcx); COPY(rip); COPY(r8); COPY(r9); COPY(r10); COPY(r11); COPY(r12); COPY(r13); COPY(r14); COPY(r15); /* Kernel saves and restores only the CS segment register on signals, * which is the bare minimum needed to allow mixed 32/64-bit code. * App's signal handler can save/restore other segments if needed. */ { unsigned cs; err |= __get_user(cs, &sc->cs); regs->cs = cs | 3; /* Force into user mode */ } { unsigned int tmpflags; err |= __get_user(tmpflags, &sc->eflags); regs->eflags = (regs->eflags & ~0x40DD5) | (tmpflags & 0x40DD5); regs->orig_rax = -1; /* disable syscall checks */ } { struct _fpstate __user * buf; err |= __get_user(buf, &sc->fpstate); if (buf) { if (!access_ok(VERIFY_READ, buf, sizeof(*buf))) goto badframe; err |= restore_i387(buf); } else { struct task_struct *me = current; if (used_math()) { clear_fpu(me); clear_used_math(); } } } err |= __get_user(*prax, &sc->rax); return err; badframe: return 1; }
int decode(void) { VAAPIContext * const vaapi = vaapi_get_context(); VAPictureParameterBufferMPEG4 *pic_param; VASliceParameterBufferMPEG4 *slice_param; VAIQMatrixBufferMPEG4 *iq_matrix; int i, slice_count; MPEG4PictureInfo mpeg4_pic_info; MPEG4SliceInfo mpeg4_slice_info; MPEG4IQMatrix mpeg4_iq_matrix; const uint8_t *mpeg4_slice_data; unsigned int mpeg4_slice_data_size; if (!vaapi) return -1; mpeg4_get_picture_info(&mpeg4_pic_info); if (vaapi_init_decoder(VAProfileMPEG4AdvancedSimple, VAEntrypointVLD, mpeg4_pic_info.width, mpeg4_pic_info.height) < 0) return -1; if ((pic_param = vaapi_alloc_picture(sizeof(*pic_param))) == NULL) return -1; #define COPY(field) \ pic_param->field = mpeg4_pic_info.field #define COPY_BFM(a,b,c) \ pic_param->BFM(a,b,c) = mpeg4_pic_info.a.b.c pic_param->vop_width = mpeg4_pic_info.width; pic_param->vop_height = mpeg4_pic_info.height; pic_param->forward_reference_picture = 0xffffffff; pic_param->backward_reference_picture = 0xffffffff; pic_param->BFV(vol_fields, value) = 0; /* reset all bits */ COPY_BFM(vol_fields, bits, short_video_header); COPY_BFM(vol_fields, bits, chroma_format); COPY_BFM(vol_fields, bits, interlaced); COPY_BFM(vol_fields, bits, obmc_disable); COPY_BFM(vol_fields, bits, sprite_enable); COPY_BFM(vol_fields, bits, sprite_warping_accuracy); COPY_BFM(vol_fields, bits, quant_type); COPY_BFM(vol_fields, bits, quarter_sample); COPY_BFM(vol_fields, bits, data_partitioned); COPY_BFM(vol_fields, bits, reversible_vlc); COPY(no_of_sprite_warping_points); for (i = 0; i < 3; i++) { COPY(sprite_trajectory_du[i]); COPY(sprite_trajectory_dv[i]); } COPY(quant_precision); pic_param->BFV(vop_fields, value) = 0; /* reset all bits */ COPY_BFM(vop_fields, bits, vop_coding_type); COPY_BFM(vop_fields, bits, backward_reference_vop_coding_type); COPY_BFM(vop_fields, bits, vop_rounding_type); COPY_BFM(vop_fields, bits, intra_dc_vlc_thr); COPY_BFM(vop_fields, bits, top_field_first); COPY_BFM(vop_fields, bits, alternate_vertical_scan_flag); COPY(vop_fcode_forward); COPY(vop_fcode_backward); COPY(num_gobs_in_vop); COPY(num_macroblocks_in_gob); COPY(TRB); COPY(TRD); #if (VA_CHECK_VERSION(0,31,1) /* XXX: update when changes are merged */ || \ (VA_CHECK_VERSION(0,31,0) && VA_SDS_VERSION >= 4)) COPY(vop_time_increment_resolution); COPY_BFM(vol_fields, bits, resync_marker_disable); #endif #undef COPY_BFM #undef COPY if (mpeg4_iq_matrix.load_intra_quant_mat || mpeg4_iq_matrix.load_non_intra_quant_mat) { if ((iq_matrix = vaapi_alloc_iq_matrix(sizeof(*iq_matrix))) == NULL) return -1; mpeg4_get_iq_matrix(&mpeg4_iq_matrix); #define COPY(field) iq_matrix->field = mpeg4_iq_matrix.field COPY(load_intra_quant_mat); COPY(load_non_intra_quant_mat); for (i = 0; i < 64; i++) { COPY(intra_quant_mat[i]); COPY(non_intra_quant_mat[i]); } #undef COPY } slice_count = mpeg4_get_slice_count(); for (i = 0; i < slice_count; i++) { if (mpeg4_get_slice_info(i, &mpeg4_slice_info) < 0) return -1; if (mpeg4_get_slice_data(i, &mpeg4_slice_data, &mpeg4_slice_data_size) < 0) return -1; if (mpeg4_slice_data_size != mpeg4_slice_info.slice_data_size) return -1; if ((slice_param = vaapi_alloc_slice(sizeof(*slice_param), mpeg4_slice_data, mpeg4_slice_data_size)) == NULL) return -1; #define COPY(field) slice_param->field = mpeg4_slice_info.field COPY(macroblock_offset); COPY(macroblock_number); COPY(quant_scale); #undef COPY } return vaapi_decode(); }
static int setup_sigcontext(struct sigcontext __user *sc, struct pt_regs *regs, unsigned long mask) { int err = 0; #define COPY(x) err |= __put_user(regs->x, &sc->sc_##x) COPY(r4); COPY(r5); COPY(r6); COPY(pt_regs); COPY(r0); COPY(r1); COPY(r2); COPY(r3); COPY(r7); COPY(r8); COPY(r9); COPY(r10); COPY(r11); COPY(r12); #if defined(CONFIG_ISA_M32R2) && defined(CONFIG_ISA_DSP_LEVEL2) COPY(acc0h); COPY(acc0l); COPY(acc1h); COPY(acc1l); #elif defined(CONFIG_ISA_M32R2) || defined(CONFIG_ISA_M32R) COPY(acch); COPY(accl); #else #error unknown isa configuration #endif COPY(psw); COPY(bpc); COPY(bbpsw); COPY(bbpc); COPY(spu); COPY(fp); COPY(lr); COPY(spi); #undef COPY err |= __put_user(mask, &sc->oldmask); return err; }
static void Z133_lambda(CL_FORM *base) { COPY(INDIRECT(GET_FORM(ARG(0)) + 4), ARG(2)); COPY(ARG(1), ARG(3)); find_symbol1(ARG(2)); COPY(&mv_buf[0], ARG(3)); { int nargs; nargs = 2; mv_count = 1; { switch(nargs) { case 0: LOAD_NIL(ARG(2)); case 1: LOAD_NIL(ARG(3)); nargs = 2; } LOAD_CONS((CL_FORM *)&KClisp[88], ARG(4)); COPY(ARG(3), ARG(5)); COPY(ARG(4), ARG(6)); LOAD_NIL(ARG(7)); LOAD_NIL(ARG(8)); LOAD_NIL(ARG(9)); member1(ARG(5)); if(CL_TRUEP(ARG(5))) { COPY(ARG(2), ARG(4)); COPY(INDIRECT(GET_FORM(ARG(0)) + 3), ARG(5)); COPY(ARG(4), ARG(6)); COPY(ARG(5), ARG(7)); LOAD_NIL(ARG(8)); LOAD_NIL(ARG(9)); LOAD_NIL(ARG(10)); adjoin1(ARG(6)); COPY(ARG(6), INDIRECT(GET_FORM(ARG(0)) + 3)); COPY(INDIRECT(GET_FORM(ARG(0)) + 3), ARG(0)); } else { LOAD_NIL(ARG(0)); } } } }
int restore_sigcontext(struct pt_regs *regs, struct sigcontext __user *sc, unsigned long *pax) { void __user *buf; unsigned int tmpflags; unsigned int err = 0; /* Always make any pending restarted system calls return -EINTR */ current->restart_block.fn = do_no_restart_syscall; get_user_try { #ifdef CONFIG_X86_32 set_user_gs(regs, GET_SEG(gs)); COPY_SEG(fs); COPY_SEG(es); COPY_SEG(ds); #endif /* CONFIG_X86_32 */ COPY(di); COPY(si); COPY(bp); COPY(sp); COPY(bx); COPY(dx); COPY(cx); COPY(ip); #ifdef CONFIG_X86_64 COPY(r8); COPY(r9); COPY(r10); COPY(r11); COPY(r12); COPY(r13); COPY(r14); COPY(r15); #endif /* CONFIG_X86_64 */ #ifdef CONFIG_X86_32 COPY_SEG_CPL3(cs); COPY_SEG_CPL3(ss); #else /* !CONFIG_X86_32 */ /* Kernel saves and restores only the CS segment register on signals, * which is the bare minimum needed to allow mixed 32/64-bit code. * App's signal handler can save/restore other segments if needed. */ COPY_SEG_CPL3(cs); #endif /* CONFIG_X86_32 */ get_user_ex(tmpflags, &sc->flags); regs->flags = (regs->flags & ~FIX_EFLAGS) | (tmpflags & FIX_EFLAGS); regs->orig_ax = -1; /* disable syscall checks */ get_user_ex(buf, &sc->fpstate); get_user_ex(*pax, &sc->ax); } get_user_catch(err); err |= restore_xstate_sig(buf, config_enabled(CONFIG_X86_32)); return err; }
/* * Hack -- display monster information using "roff()" * * Note that there is now a compiler option to only read the monster * descriptions from the raw file when they are actually needed, which * saves about 60K of memory at the cost of disk access during monster * recall, which is optional to the user. * * This function should only be called with the cursor placed at the * left edge of the screen, on a cleared line, in which the recall is * to take place. One extra blank line is left after the recall. */ void describe_monster_race(const monster_race *r_ptr, const monster_lore *l_ptr, bool spoilers) { monster_lore lore; /* Hack -- create a copy of the monster-memory */ COPY(&lore, l_ptr, monster_lore); /* Assume some "obvious" flags */ lore.flags1 |= (r_ptr->flags1 & RF1_OBVIOUS_MASK); /* Killing a monster reveals some properties */ if (lore.tkills) { /* Know "race" flags */ lore.flags3 |= (r_ptr->flags3 & RF3_RACE_MASK); /* Know "forced" flags */ lore.flags1 |= (r_ptr->flags1 & (RF1_FORCE_DEPTH | RF1_FORCE_MAXHP)); } /* Cheat -- know everything */ if (cheat_know || spoilers) cheat_monster_lore(r_ptr, &lore); /* Show kills of monster vs. player(s) */ if (!spoilers) describe_monster_kills(r_ptr, &lore); /* Monster description */ describe_monster_desc(r_ptr); /* Describe the movement and level of the monster */ describe_monster_movement(r_ptr, &lore); /* Describe experience */ describe_monster_exp(r_ptr, &lore); /* Describe power */ describe_monster_power(r_ptr, &lore); /* Describe the known ranged attacks */ describe_monster_attack(r_ptr, &lore, TRUE); /* Describe spells and innate attacks */ describe_monster_spells(r_ptr, &lore); /* Describe monster "toughness" */ if (!spoilers) describe_monster_toughness(r_ptr, &lore); /* Describe the abilities of the monster */ describe_monster_abilities(r_ptr, &lore); /* Describe the monster drop */ describe_monster_drop(r_ptr, &lore); /* Describe the known attacks */ describe_monster_attack(r_ptr, &lore, FALSE); /* Notice "Quest" monsters */ if (lore.flags1 & (RF1_QUESTOR)) { text_out("You feel an intense desire to kill this monster... "); } /* Notice "Guardian" monsters */ if (lore.flags1 & (RF1_GUARDIAN)) { text_out("It is a dungeon guardian, impeding your progress further. "); } /* All done */ text_out("\n"); }
static int restore_sigcontext(struct pt_regs *regs, struct sigcontext __user *sc, int *r0_p) { unsigned int err = 0; #define COPY(x) err |= __get_user(regs->x, &sc->sc_##x) COPY(regs[1]); COPY(regs[2]); COPY(regs[3]); COPY(regs[4]); COPY(regs[5]); COPY(regs[6]); COPY(regs[7]); COPY(regs[8]); COPY(regs[9]); COPY(regs[10]); COPY(regs[11]); COPY(regs[12]); COPY(regs[13]); COPY(regs[14]); COPY(regs[15]); COPY(gbr); COPY(mach); COPY(macl); COPY(pr); COPY(sr); COPY(pc); #undef COPY #ifdef CONFIG_SH_FPU if (current_cpu_data.flags & CPU_HAS_FPU) { int owned_fp; struct task_struct *tsk = current; regs->sr |= SR_FD; /* Release FPU */ clear_fpu(tsk, regs); clear_used_math(); __get_user (owned_fp, &sc->sc_ownedfp); if (owned_fp) err |= restore_sigcontext_fpu(sc); } #endif regs->tra = -1; /* disable syscall checks */ err |= __get_user(*r0_p, &sc->sc_regs[0]); return err; }
static void Z147_get_elem(CL_FORM *base) { if(CL_CONSP(ARG(1))) { COPY(GET_CAR(ARG(1)), ARG(2)); } else { if(CL_TRUEP(ARG(1))) { LOAD_SMSTR((CL_FORM *)&KClisp[264], ARG(2)); /* ~a is not a list */ COPY(ARG(1), ARG(3)); Ferror(ARG(2), 2); } else { COPY(ARG(1), ARG(2)); } } if(CL_LISTP(ARG(2))) { if(CL_CONSP(ARG(1))) { COPY(GET_CAR(ARG(1)), ARG(2)); } else { if(CL_TRUEP(ARG(1))) { LOAD_SMSTR((CL_FORM *)&KClisp[264], ARG(2)); /* ~a is not a list */ COPY(ARG(1), ARG(3)); Ferror(ARG(2), 2); } else { COPY(ARG(1), ARG(2)); } } if(CL_CONSP(ARG(2))) { COPY(GET_CAR(ARG(2)), ARG(3)); } else { if(CL_TRUEP(ARG(2))) { LOAD_SMSTR((CL_FORM *)&KClisp[264], ARG(3)); /* ~a is not a list */ COPY(ARG(2), ARG(4)); Ferror(ARG(3), 2); } else { COPY(ARG(2), ARG(3)); } } COPY(ARG(2), ARG(4)); COPY(ARG(4), ARG(5)); if(CL_CONSP(ARG(5))) { COPY(GET_CDR(ARG(5)), ARG(2)); } else { if(CL_TRUEP(ARG(5))) { LOAD_SMSTR((CL_FORM *)&KClisp[262], ARG(6)); /* ~a is not a list */ COPY(ARG(5), ARG(7)); Ferror(ARG(6), 2); } else { COPY(ARG(5), ARG(2)); } } if(CL_CONSP(ARG(1))) { COPY(ARG(2), GET_CAR(ARG(1))); } else { LOAD_SMSTR((CL_FORM *)&KClisp[252], ARG(4)); /* ~a is not a cons */ COPY(ARG(1), ARG(5)); Ferror(ARG(4), 2); } COPY(ARG(3), ARG(0)); } else { if(CL_CONSP(ARG(1))) { COPY(GET_CAR(ARG(1)), ARG(2)); } else { if(CL_TRUEP(ARG(1))) { LOAD_SMSTR((CL_FORM *)&KClisp[264], ARG(2)); /* ~a is not a list */ COPY(ARG(1), ARG(3)); Ferror(ARG(2), 2); } else { COPY(ARG(1), ARG(2)); } } COPY(INDIRECT(GET_FORM(ARG(0)) + 3), ARG(3)); Felt(ARG(2)); COPY(ARG(2), ARG(0)); } }
static int setup_sigcontext(struct sigcontext __user *sc, struct pt_regs *regs, unsigned long mask) { int err = 0; #define COPY(x) err |= __put_user(regs->x, &sc->sc_##x) COPY(regs[0]); COPY(regs[1]); COPY(regs[2]); COPY(regs[3]); COPY(regs[4]); COPY(regs[5]); COPY(regs[6]); COPY(regs[7]); COPY(regs[8]); COPY(regs[9]); COPY(regs[10]); COPY(regs[11]); COPY(regs[12]); COPY(regs[13]); COPY(regs[14]); COPY(regs[15]); COPY(gbr); COPY(mach); COPY(macl); COPY(pr); COPY(sr); COPY(pc); #undef COPY #ifdef CONFIG_SH_FPU err |= save_sigcontext_fpu(sc, regs); #endif /* non-iBCS2 extensions.. */ err |= __put_user(mask, &sc->oldmask); return err; }
static int restore_sigcontext(struct pt_regs *regs, struct sigcontext __user *sc, int *r0_p) { unsigned int err = 0; /* Always make any pending restarted system calls return -EINTR */ current->restart_block.fn = do_no_restart_syscall; #define COPY(x) err |= __get_user(regs->x, &sc->sc_##x) COPY(r4); COPY(r5); COPY(r6); COPY(pt_regs); /* COPY(r0); Skip r0 */ COPY(r1); COPY(r2); COPY(r3); COPY(r7); COPY(r8); COPY(r9); COPY(r10); COPY(r11); COPY(r12); COPY(acc0h); COPY(acc0l); COPY(acc1h); /* ISA_DSP_LEVEL2 only */ COPY(acc1l); /* ISA_DSP_LEVEL2 only */ COPY(psw); COPY(bpc); COPY(bbpsw); COPY(bbpc); COPY(spu); COPY(fp); COPY(lr); COPY(spi); #undef COPY regs->syscall_nr = -1; /* disable syscall checks */ err |= __get_user(*r0_p, &sc->sc_r0); return err; }
static int setup_sigcontext(struct sigcontext __user *sc, struct pt_regs *regs) { int err = 0; #define COPY(x) err |= __put_user(regs->x, &sc->x) COPY(sr); COPY(pc); COPY(lr); COPY(sp); COPY(r12); COPY(r11); COPY(r10); COPY(r9); COPY(r8); COPY(r7); COPY(r6); COPY(r5); COPY(r4); COPY(r3); COPY(r2); COPY(r1); COPY(r0); #undef COPY return err; }
/* * Set up a signal frame. */ static int setup_sigcontext(struct sigcontext __user *sc, struct pt_regs *regs, unsigned long mask) { int err = 0; /* Do this first, otherwise is this sets sr->fd, that value isn't preserved. */ err |= setup_sigcontext_fpu(regs, sc); #define COPY(x) err |= __put_user(regs->x, &sc->sc_##x) COPY(regs[0]); COPY(regs[1]); COPY(regs[2]); COPY(regs[3]); COPY(regs[4]); COPY(regs[5]); COPY(regs[6]); COPY(regs[7]); COPY(regs[8]); COPY(regs[9]); COPY(regs[10]); COPY(regs[11]); COPY(regs[12]); COPY(regs[13]); COPY(regs[14]); COPY(regs[15]); COPY(regs[16]); COPY(regs[17]); COPY(regs[18]); COPY(regs[19]); COPY(regs[20]); COPY(regs[21]); COPY(regs[22]); COPY(regs[23]); COPY(regs[24]); COPY(regs[25]); COPY(regs[26]); COPY(regs[27]); COPY(regs[28]); COPY(regs[29]); COPY(regs[30]); COPY(regs[31]); COPY(regs[32]); COPY(regs[33]); COPY(regs[34]); COPY(regs[35]); COPY(regs[36]); COPY(regs[37]); COPY(regs[38]); COPY(regs[39]); COPY(regs[40]); COPY(regs[41]); COPY(regs[42]); COPY(regs[43]); COPY(regs[44]); COPY(regs[45]); COPY(regs[46]); COPY(regs[47]); COPY(regs[48]); COPY(regs[49]); COPY(regs[50]); COPY(regs[51]); COPY(regs[52]); COPY(regs[53]); COPY(regs[54]); COPY(regs[55]); COPY(regs[56]); COPY(regs[57]); COPY(regs[58]); COPY(regs[59]); COPY(regs[60]); COPY(regs[61]); COPY(regs[62]); COPY(tregs[0]); COPY(tregs[1]); COPY(tregs[2]); COPY(tregs[3]); COPY(tregs[4]); COPY(tregs[5]); COPY(tregs[6]); COPY(tregs[7]); COPY(sr); COPY(pc); #undef COPY err |= __put_user(mask, &sc->oldmask); return err; }
static int restore_sigcontext(struct pt_regs *regs, struct sigcontext __user *sc) { int err = 0; #define COPY(x) err |= __get_user(regs->x, &sc->x) COPY(sr); COPY(pc); COPY(lr); COPY(sp); COPY(r12); COPY(r11); COPY(r10); COPY(r9); COPY(r8); COPY(r7); COPY(r6); COPY(r5); COPY(r4); COPY(r3); COPY(r2); COPY(r1); COPY(r0); #undef COPY /* * Don't allow anyone to pretend they're running in supervisor * mode or something... */ err |= !valid_user_regs(regs); return err; }
static int setup_sigcontext(struct sigcontext __user *sc, struct pt_regs *regs, unsigned long mask) { int err = 0; #define COPY(x) {err |= __put_user(regs->x, &sc->regs.x); } COPY(r0); COPY(r1); COPY(r2); COPY(r3); COPY(r4); COPY(r5); COPY(r6); COPY(r7); COPY(r8); COPY(r9); COPY(r10); COPY(r11); COPY(r12); COPY(r13); COPY(r14); COPY(r15); COPY(r16); COPY(r17); COPY(r18); COPY(r19); COPY(r20); COPY(r21); COPY(r22); COPY(r23); COPY(r24); COPY(r25); COPY(r26); COPY(r27); COPY(r28); COPY(r29); COPY(r30); COPY(r31); COPY(pc); COPY(ear); COPY(esr); COPY(fsr); #undef COPY err |= __put_user(mask, &sc->oldmask); return err; }
void pathname_host1(CL_FORM *base) { COPY(ARG(0), ARG(2)); LOAD_SYMBOL(SYMBOL(Slisp, 232), ARG(3)); /* PATHNAME */ rt_struct_typep(ARG(2)); if(CL_TRUEP(ARG(2))) { COPY(ARG(0), ARG(2)); } else { COPY(ARG(0), ARG(2)); Fstringp(ARG(2)); if(CL_TRUEP(ARG(2))) { COPY(ARG(0), ARG(2)); LOAD_NIL(ARG(3)); COPY(SYMVAL(Slisp, 231), ARG(4)); /* *DEFAULT-PATHNAME-DEFAULTS* */ LOAD_SMALLFIXNUM(0, ARG(5)); LOAD_NIL(ARG(6)); LOAD_NIL(ARG(7)); parse_namestring1(ARG(2)); mv_count = 1; } else { COPY(ARG(0), ARG(2)); LOAD_SYMBOL(SYMBOL(Slisp, 64), ARG(3)); /* STREAM */ rt_struct_typep(ARG(2)); if(CL_TRUEP(ARG(2))) { COPY(ARG(0), ARG(2)); LOAD_NIL(ARG(3)); file_name1(ARG(2)); COPY(SYMVAL(Slisp, 231), ARG(3)); /* *DEFAULT-PATHNAME-DEFAULTS* */ LOAD_SMALLFIXNUM(0, ARG(4)); COPY(ARG(2), ARG(5)); LOAD_NIL(ARG(6)); COPY(ARG(3), ARG(7)); COPY(ARG(4), ARG(8)); LOAD_NIL(ARG(9)); LOAD_NIL(ARG(10)); parse_namestring1(ARG(5)); mv_count = 1; COPY(ARG(5), ARG(2)); } else { LOAD_SMSTR((CL_FORM *)&Kpathname_host1[0], ARG(2)); /* etypecase: the value ~a is not a legal value */ COPY(ARG(0), ARG(3)); Ferror(ARG(2), 2); } } } COPY(ARG(2), ARG(3)); LOAD_SYMBOL(SYMBOL(Slisp, 232), ARG(4)); /* PATHNAME */ rt_struct_typep(ARG(3)); if(CL_TRUEP(ARG(3))) { COPY(OFFSET(AR_BASE(GET_FORM(ARG(2))), 0 + 1), ARG(0)); } else { COPY(SYMVAL(Slisp, 342), ARG(0)); /* NO_STRUCT */ COPY(ARG(2), ARG(1)); LOAD_SYMBOL(SYMBOL(Slisp, 232), ARG(2)); /* PATHNAME */ Ferror(ARG(0), 3); } }
static int restore_sigcontext(struct pt_regs *regs, struct sigcontext __user *sc) { int err = 0; /* The access_ok check was done by caller, so use __get_user here */ #define COPY(x) (err |= __get_user(regs->x, &sc->sc_##x)) COPY(sp); COPY(a4); COPY(b4); COPY(a6); COPY(b6); COPY(a8); COPY(b8); COPY(a0); COPY(a1); COPY(a2); COPY(a3); COPY(a5); COPY(a7); COPY(a9); COPY(b0); COPY(b1); COPY(b2); COPY(b3); COPY(b5); COPY(b7); COPY(b9); COPY(a16); COPY(a17); COPY(a18); COPY(a19); COPY(a20); COPY(a21); COPY(a22); COPY(a23); COPY(a24); COPY(a25); COPY(a26); COPY(a27); COPY(a28); COPY(a29); COPY(a30); COPY(a31); COPY(b16); COPY(b17); COPY(b18); COPY(b19); COPY(b20); COPY(b21); COPY(b22); COPY(b23); COPY(b24); COPY(b25); COPY(b26); COPY(b27); COPY(b28); COPY(b29); COPY(b30); COPY(b31); COPY(csr); COPY(pc); #undef COPY return err; }
static int restore_sigcontext(struct pt_regs *regs, struct sigcontext *sc) { unsigned int err = 0; #define COPY(x) err |= __get_user(regs->x, &sc->sc_##x) COPY(regs[0]); COPY(regs[1]); COPY(regs[2]); COPY(regs[3]); COPY(regs[4]); COPY(regs[5]); COPY(regs[6]); COPY(regs[7]); COPY(regs[8]); COPY(regs[9]); COPY(regs[10]); COPY(regs[11]); COPY(regs[12]); COPY(regs[13]); COPY(regs[14]); COPY(regs[15]); COPY(gbr); COPY(mach); COPY(macl); COPY(pr); COPY(sr); COPY(pc); #undef COPY #if defined(__SH4__) { int owned_fp; struct task_struct *tsk = current; regs->sr |= SR_FD; /* Release FPU */ clear_fpu(tsk); current->used_math = 0; __get_user (owned_fp, &sc->sc_ownedfp); if (owned_fp) err |= restore_sigcontext_fpu(sc); } #endif return err; }