static int checkArgMode (const Proto *pt, int r, enum OpArgMask mode) { switch (mode) { case OpArgN: check(r == 0); break; case OpArgU: break; case OpArgR: checkreg(pt, r); break; case OpArgK: check(ISK(r) ? INDEXK(r) < pt->sizek : r < pt->maxstacksize); break; } return 1; }
const struct puc_device_description * puc_find_description(pcireg_t vend, pcireg_t prod, pcireg_t svend, pcireg_t sprod) { int i; #define checkreg(val, index) \ (((val) & puc_devices[i].rmask[(index)]) == puc_devices[i].rval[(index)]) for (i = 0; puc_devices[i].name != NULL; i++) { if (checkreg(vend, PUC_REG_VEND) && checkreg(prod, PUC_REG_PROD) && checkreg(svend, PUC_REG_SVEND) && checkreg(sprod, PUC_REG_SPROD)) return (&puc_devices[i]); } #undef checkreg return (NULL); }
CharismaApp::CharismaApp(): BApplication(kapptype) { int r; int32 code; checkreg(); // on lance afl_server r=afl_init(); if(r) fatal(__FILE__,__LINE__, "The file locking mechanism could not be started: %s", strerror(r)); startproxy(); cw=new CharismaWindow(BPoint(100,100)); cw->setdefaults(); cw->getprefs(); cw->Show(); cw->setnetpos(); }
static Instruction symbexec(const Proto* pt, int lastpc, int reg) { int pc; int last; /* stores position of last instruction that changed `reg' */ last = pt->sizecode - 1; /* points to final return (a `neutral' instruction) */ check(precheck(pt)); for (pc = 0; pc < lastpc; pc++) { Instruction i = pt->code[pc]; OpCode op = GET_OPCODE(i); int a = GETARG_A(i); int b = 0; int c = 0; check(op < NUM_OPCODES); checkreg(pt, a); switch (getOpMode(op)) { case iABC: { b = GETARG_B(i); c = GETARG_C(i); check(checkArgMode(pt, b, getBMode(op))); check(checkArgMode(pt, c, getCMode(op))); break; } case iABx: { b = GETARG_Bx(i); if (getBMode(op) == OpArgK) check(b < pt->sizek); break; } case iAsBx: { b = GETARG_sBx(i); if (getBMode(op) == OpArgR) { int dest = pc + 1 + b; check(0 <= dest && dest < pt->sizecode); if (dest > 0) { int j; /* check that it does not jump to a setlist count; this is tricky, because the count from a previous setlist may have the same value of an invalid setlist; so, we must go all the way back to the first of them (if any) */ for (j = 0; j < dest; j++) { Instruction d = pt->code[dest - 1 - j]; if (!(GET_OPCODE(d) == OP_SETLIST && GETARG_C(d) == 0)) break; } /* if 'j' is even, previous value is not a setlist (even if it looks like one) */ check((j & 1) == 0); } } break; } } if (testAMode(op)) { if (a == reg) last = pc; /* change register `a' */ } if (testTMode(op)) { check(pc + 2 < pt->sizecode); /* check skip */ check(GET_OPCODE(pt->code[pc + 1]) == OP_JMP); } switch (op) { case OP_LOADBOOL: { if (c == 1) /* does it jump? */ { check(pc + 2 < pt->sizecode); /* check its jump */ check(GET_OPCODE(pt->code[pc + 1]) != OP_SETLIST || GETARG_C(pt->code[pc + 1]) != 0); } break; } case OP_LOADNIL: { if (a <= reg && reg <= b) last = pc; /* set registers from `a' to `b' */ break; } case OP_GETUPVAL: case OP_SETUPVAL: { check(b < pt->nups); break; } case OP_GETGLOBAL: case OP_SETGLOBAL: { check(ttisstring(&pt->k[b])); break; } case OP_SELF: { checkreg(pt, a + 1); if (reg == a + 1) last = pc; break; } case OP_CONCAT: { check(b < c); /* at least two operands */ break; } case OP_TFORLOOP: { check(c >= 1); /* at least one result (control variable) */ checkreg(pt, a + 2 + c); /* space for results */ if (reg >= a + 2) last = pc; /* affect all regs above its base */ break; } case OP_FORLOOP: case OP_FORPREP: checkreg(pt, a + 3); /* go through */ case OP_JMP: { int dest = pc + 1 + b; /* not full check and jump is forward and do not skip `lastpc'? */ if (reg != NO_REG && pc < dest && dest <= lastpc) pc += b; /* do the jump */ break; } case OP_CALL: case OP_TAILCALL: { if (b != 0) { checkreg(pt, a + b - 1); } c--; /* c = num. returns */ if (c == LUA_MULTRET) { check(checkopenop(pt, pc)); } else if (c != 0) checkreg(pt, a + c - 1); if (reg >= a) last = pc; /* affect all registers above base */ break; } case OP_RETURN: { b--; /* b = num. returns */ if (b > 0) checkreg(pt, a + b - 1); break; } case OP_SETLIST: { if (b > 0) checkreg(pt, a + b); if (c == 0) { pc++; check(pc < pt->sizecode - 1); } break; } case OP_CLOSURE: { int nup, j; check(b < pt->sizep); nup = pt->p[b]->nups; check(pc + nup < pt->sizecode); for (j = 1; j <= nup; j++) { OpCode op1 = GET_OPCODE(pt->code[pc + j]); check(op1 == OP_GETUPVAL || op1 == OP_MOVE); } if (reg != NO_REG) /* tracing? */ pc += nup; /* do not 'execute' these pseudo-instructions */ break; } case OP_VARARG: { check((pt->is_vararg & VARARG_ISVARARG) && !(pt->is_vararg & VARARG_NEEDSARG)); b--; if (b == LUA_MULTRET) check(checkopenop(pt, pc)); checkreg(pt, a + b - 1); break; } default: break; } } return pt->code[last]; }
static Instruction symbexec (const Proto *pt, int lastpc, int reg) { int pc; int last; /* stores position of last instruction that changed `reg' */ last = pt->sizecode-1; /* points to final return (a `neutral' instruction) */ check(precheck(pt)); for (pc = 0; pc < lastpc; pc++) { Instruction i = pt->code[pc]; OpCode op = GET_OPCODE(i); int a = GETARG_A(i); int b = 0; int c = 0; check(op < NUM_OPCODES); checkreg(pt, a); switch (getOpMode(op)) { case iABC: { b = GETARG_B(i); c = GETARG_C(i); check(checkArgMode(pt, b, getBMode(op))); check(checkArgMode(pt, c, getCMode(op))); break; } case iABx: { b = GETARG_Bx(i); if (getBMode(op) == OpArgK) check(b < pt->sizek); break; } case iAsBx: { b = GETARG_sBx(i); if (getBMode(op) == OpArgR) { int dest = pc+1+b; check(0 <= dest && dest < pt->sizecode); if (dest > 0) { /* cannot jump to a setlist count */ Instruction d = pt->code[dest-1]; check(!(GET_OPCODE(d) == OP_SETLIST && GETARG_C(d) == 0)); } } break; } } if (testAMode(op)) { if (a == reg) last = pc; /* change register `a' */ } if (testTMode(op)) { check(pc+2 < pt->sizecode); /* check skip */ check(GET_OPCODE(pt->code[pc+1]) == OP_JMP); } switch (op) { case OP_LOADBOOL: { check(c == 0 || pc+2 < pt->sizecode); /* check its jump */ break; } case OP_LOADNIL: { if (a <= reg && reg <= b) last = pc; /* set registers from `a' to `b' */ break; } case OP_GETUPVAL: case OP_SETUPVAL: { check(b < pt->nups); break; } case OP_GETGLOBAL: case OP_SETGLOBAL: { check(ttisstring(&pt->k[b])); break; } case OP_SELF: { checkreg(pt, a+1); if (reg == a+1) last = pc; break; } case OP_CONCAT: { check(b < c); /* at least two operands */ break; } case OP_TFORLOOP: { check(c >= 1); /* at least one result (control variable) */ checkreg(pt, a+2+c); /* space for results */ if (reg >= a+2) last = pc; /* affect all regs above its base */ break; } case OP_FORLOOP: case OP_FORPREP: checkreg(pt, a+3); /* go through */ case OP_JMP: { int dest = pc+1+b; /* not full check and jump is forward and do not skip `lastpc'? */ if (reg != NO_REG && pc < dest && dest <= lastpc) pc += b; /* do the jump */ break; } case OP_CALL: case OP_TAILCALL: { if (b != 0) { checkreg(pt, a+b-1); } c--; /* c = num. returns */ if (c == LUA_MULTRET) { check(checkopenop(pt, pc)); } else if (c != 0) checkreg(pt, a+c-1); if (reg >= a) last = pc; /* affect all registers above base */ break; } case OP_RETURN: { b--; /* b = num. returns */ if (b > 0) checkreg(pt, a+b-1); break; } case OP_SETLIST: { if (b > 0) checkreg(pt, a + b); if (c == 0) pc++; break; } case OP_CLOSURE: { int nup; check(b < pt->sizep); nup = pt->p[b]->nups; check(pc + nup < pt->sizecode); for (; nup>0; nup--) { OpCode op1 = GET_OPCODE(pt->code[pc+nup]); check(op1 == OP_GETUPVAL || op1 == OP_MOVE); } break; } case OP_VARARG: { check((pt->is_vararg & VARARG_ISVARARG) && !(pt->is_vararg & VARARG_NEEDSARG)); b--; if (b == LUA_MULTRET) check(checkopenop(pt, pc)); checkreg(pt, a+b-1); break; } default: break; } } return pt->code[last]; }
static Instruction luaG_symbexec (const Proto *pt, int lastpc, int reg) { int pc; int last; /* stores position of last instruction that changed `reg' */ last = pt->sizecode-1; /* points to final return (a `neutral' instruction) */ check(precheck(pt)); for (pc = 0; pc < lastpc; pc++) { const Instruction i = pt->code[pc]; OpCode op = GET_OPCODE(i); int a = GETARG_A(i); int b = 0; int c = 0; checkreg(pt, a); switch (getOpMode(op)) { case iABC: { b = GETARG_B(i); c = GETARG_C(i); if (testOpMode(op, OpModeBreg)) { checkreg(pt, b); } else if (testOpMode(op, OpModeBrk)) check(checkRK(pt, b)); if (testOpMode(op, OpModeCrk)) check(checkRK(pt, c)); break; } case iABx: { b = GETARG_Bx(i); if (testOpMode(op, OpModeK)) check(b < pt->sizek); break; } case iAsBx: { b = GETARG_sBx(i); break; } } if (testOpMode(op, OpModesetA)) { if (a == reg) last = pc; /* change register `a' */ } if (testOpMode(op, OpModeT)) { check(pc+2 < pt->sizecode); /* check skip */ check(GET_OPCODE(pt->code[pc+1]) == OP_JMP); } switch (op) { case OP_LOADBOOL: { check(c == 0 || pc+2 < pt->sizecode); /* check its jump */ break; } case OP_LOADNIL: { if (a <= reg && reg <= b) last = pc; /* set registers from `a' to `b' */ break; } case OP_GETUPVAL: case OP_SETUPVAL: { check(b < pt->nups); break; } case OP_GETGLOBAL: case OP_SETGLOBAL: { check(ttisstring(&pt->k[b])); break; } case OP_SELF: { checkreg(pt, a+1); if (reg == a+1) last = pc; break; } case OP_CONCAT: { /* `c' is a register, and at least two operands */ check(c < MAXSTACK && b < c); break; } case OP_TFORLOOP: checkreg(pt, a+c+5); if (reg >= a) last = pc; /* affect all registers above base */ /* go through */ case OP_FORLOOP: checkreg(pt, a+2); /* go through */ case OP_JMP: { int dest = pc+1+b; check(0 <= dest && dest < pt->sizecode); /* not full check and jump is forward and do not skip `lastpc'? */ if (reg != NO_REG && pc < dest && dest <= lastpc) pc += b; /* do the jump */ break; } case OP_CALL: case OP_TAILCALL: { if (b != 0) { checkreg(pt, a+b-1); } c--; /* c = num. returns */ if (c == LUA_MULTRET) { check(checkopenop(pt, pc)); } else if (c != 0) checkreg(pt, a+c-1); if (reg >= a) last = pc; /* affect all registers above base */ break; } case OP_RETURN: { b--; /* b = num. returns */ if (b > 0) checkreg(pt, a+b-1); break; } case OP_SETLIST: { checkreg(pt, a + (b&(LFIELDS_PER_FLUSH-1)) + 1); break; } case OP_CLOSURE: { int nup; check(b < pt->sizep); nup = pt->p[b]->nups; check(pc + nup < pt->sizecode); for (; nup>0; nup--) { OpCode op1 = GET_OPCODE(pt->code[pc+nup]); check(op1 == OP_GETUPVAL || op1 == OP_MOVE); } break; } default: break; } } return pt->code[last]; }
/* * setreg -- store the given word in the register with the given number * * reg -- the register number * word -- the word to store * * Dies if the register number is invalid. */ void setreg(size_t reg, size_t word) { checkreg(reg); regs[reg] = word; }
/* * getreg -- fetch the word in the register with the given number * * reg -- the register number * * Dies if the register number is invalid. */ size_t getreg(size_t reg) { checkreg(reg); return(regs[reg]); }
static int dexec(DwarfBuf *b, State *s, int locstop) { int c; long arg1, arg2; DwarfExpr *e; for(;;){ if(b->p == b->ep){ if(s->initr) s->loc = s->endloc; return 0; } c = dwarfget1(b); if(b->p == nil){ werrstr("ran out of instructions during cfa program"); if(trace) werrstr("%r\n"); return -1; } if(trace) werrstr("+ loc=0x%lux op 0x%ux ", s->loc, c); switch(c>>6){ case 1: /* advance location */ arg1 = c&0x3F; advance: if(trace) werrstr("loc += %ld\n", arg1*s->iquantum); s->loc += arg1 * s->iquantum; if(locstop) return 0; continue; case 2: /* offset rule */ arg1 = c&0x3F; arg2 = dwarfget128(b); offset: if(trace) werrstr("r%ld += %ld\n", arg1, arg2*s->dquantum); if(checkreg(s, arg1) < 0) return -1; s->r[arg1].type = RuleCfaOffset; s->r[arg1].offset = arg2 * s->dquantum; continue; case 3: /* restore initial setting */ arg1 = c&0x3F; restore: if(trace) werrstr("r%ld = init\n", arg1); if(checkreg(s, arg1) < 0) return -1; s->r[arg1] = s->initr[arg1]; continue; } switch(c){ case 0: /* nop */ if(trace) werrstr("nop\n"); continue; case 0x01: /* set location */ s->loc = dwarfgetaddr(b); if(trace) werrstr("loc = 0x%lux\n", s->loc); if(locstop) return 0; continue; case 0x02: /* advance loc1 */ arg1 = dwarfget1(b); goto advance; case 0x03: /* advance loc2 */ arg1 = dwarfget2(b); goto advance; case 0x04: /* advance loc4 */ arg1 = dwarfget4(b); goto advance; case 0x05: /* offset extended */ arg1 = dwarfget128(b); arg2 = dwarfget128(b); goto offset; case 0x06: /* restore extended */ arg1 = dwarfget128(b); goto restore; case 0x07: /* undefined */ arg1 = dwarfget128(b); if(trace) werrstr("r%ld = undef\n", arg1); if(checkreg(s, arg1) < 0) return -1; s->r[arg1].type = RuleUndef; continue; case 0x08: /* same value */ arg1 = dwarfget128(b); if(trace) werrstr("r%ld = same\n", arg1); if(checkreg(s, arg1) < 0) return -1; s->r[arg1].type = RuleSame; continue; case 0x09: /* register */ arg1 = dwarfget128(b); arg2 = dwarfget128(b); if(trace) werrstr("r%ld = r%ld\n", arg1, arg2); if(checkreg(s, arg1) < 0 || checkreg(s, arg2) < 0) return -1; s->r[arg1].type = RuleRegister; s->r[arg1].reg = arg2; continue; case 0x0A: /* remember state */ e = malloc(s->nr*sizeof(e[0])); if(trace) werrstr("push\n"); if(e == nil) return -1; void *newstack = malloc(s->nstack*sizeof(s->stack[0])); RtlMoveMemory(newstack, s->stack, s->nstack*sizeof(s->stack[0])); if (newstack) { free(s->stack); s->stack = newstack; } else { free(e); return -1; } if(b->p == nil){ free(e); return -1; } s->stack[s->nstack++] = e; memmove(e, s->r, s->nr*sizeof(e[0])); continue; case 0x0B: /* restore state */ if(trace) werrstr("pop\n"); if(s->nstack == 0){ werrstr("restore state underflow"); return -1; } e = s->stack[s->nstack-1]; memmove(s->r, e, s->nr*sizeof(e[0])); free(e); s->nstack--; continue; case 0x0C: /* def cfa */ arg1 = dwarfget128(b); arg2 = dwarfget128(b); defcfa: if(trace) werrstr("cfa %ld(r%ld)\n", arg2, arg1); if(checkreg(s, arg1) < 0) return -1; s->cfa->type = RuleRegOff; s->cfa->reg = arg1; s->cfa->offset = arg2; continue; case 0x0D: /* def cfa register */ arg1 = dwarfget128(b); if(trace) werrstr("cfa reg r%ld\n", arg1); if(s->cfa->type != RuleRegOff){ werrstr("change CFA register but CFA not in register+offset form"); return -1; } if(checkreg(s, arg1) < 0) return -1; s->cfa->reg = arg1; continue; case 0x0E: /* def cfa offset */ arg1 = dwarfget128(b); cfaoffset: if(trace) werrstr("cfa off %ld\n", arg1); if(s->cfa->type != RuleRegOff){ werrstr("change CFA offset but CFA not in register+offset form"); return -1; } s->cfa->offset = arg1; continue; case 0x0F: /* def cfa expression */ if(trace) werrstr("cfa expr\n"); s->cfa->type = RuleLocation; s->cfa->loc.len = dwarfget128(b); s->cfa->loc.data = dwarfgetnref(b, s->cfa->loc.len); continue; case 0x10: /* def reg expression */ arg1 = dwarfget128(b); if(trace) werrstr("reg expr r%ld\n", arg1); if(checkreg(s, arg1) < 0) return -1; s->r[arg1].type = RuleLocation; s->r[arg1].loc.len = dwarfget128(b); s->r[arg1].loc.data = dwarfgetnref(b, s->r[arg1].loc.len); continue; case 0x11: /* offset extended */ arg1 = dwarfget128(b); arg2 = dwarfget128s(b); goto offset; case 0x12: /* cfa sf */ arg1 = dwarfget128(b); arg2 = dwarfget128s(b); goto defcfa; case 0x13: /* cfa offset sf */ arg1 = dwarfget128s(b); goto cfaoffset; default: /* unknown */ werrstr("unknown opcode 0x%ux in cfa program", c); return -1; } } /* not reached */ }