int function::call(state *E) {
exo::instruction *pc = &i_store[0];
while (true) {
exo::instruction I = *pc;
exo::opcodes::opcode OP = GET_OP(I);
std::cout << I << " (" << OP << ")" << std::endl;
switch (OP) {
case opcodes::NOOP:
break;
case opcodes::RTN:
return GET_A(I);
case opcodes::JMP:
pc += GET_Bx(I);
break;
case opcodes::LOADK:
E->set(GET_A(I), k_store[GET_B(I)]);
break;
case opcodes::MOVE:
E->set(GET_B(I), E->get(GET_A(I)));
break;
}
pc++;
}
}
static void
nfs4_setup_create_special(struct nfs4_compound *cp, struct qstr *name,
dev_t dev, struct iattr *sattr,
struct nfs4_change_info *info)
{
int mode = sattr->ia_mode;
struct nfs4_create *create = GET_OP(cp, create);
BUG_ON(!(sattr->ia_valid & ATTR_MODE));
BUG_ON(!S_ISFIFO(mode) && !S_ISBLK(mode) && !S_ISCHR(mode) && !S_ISSOCK(mode));
if (S_ISFIFO(mode))
create->cr_ftype = NF4FIFO;
else if (S_ISBLK(mode)) {
create->cr_ftype = NF4BLK;
create->cr_specdata1 = MAJOR(dev);
create->cr_specdata2 = MINOR(dev);
}
else if (S_ISCHR(mode)) {
create->cr_ftype = NF4CHR;
create->cr_specdata1 = MAJOR(dev);
create->cr_specdata2 = MINOR(dev);
}
else
create->cr_ftype = NF4SOCK;
create->cr_namelen = name->len;
create->cr_name = name->name;
create->cr_attrs = sattr;
create->cr_cinfo = info;
OPNUM(cp) = OP_CREATE;
cp->req_nops++;
}
int Line::diff_width(void)
{
int sz = 0;
char* diff = str;
if(!diff)
return 0;
while(*diff)
{
int op = GET_OP(*diff);
int cnt = GET_CNT(*diff);
diff++;
switch(op)
{
case OP_ADD:
case OP_SUB:
diff += cnt;
case OP_EQ:
sz += cnt;
break;
}
}
return sz;
}
static void
nfs4_setup_readdir(struct nfs4_compound *cp, u64 cookie, u32 *verifier,
struct page **pages, unsigned int bufsize, struct dentry *dentry)
{
u32 *start, *p;
struct nfs4_readdir *readdir = GET_OP(cp, readdir);
BUG_ON(bufsize < 80);
readdir->rd_cookie = (cookie > 2) ? cookie : 0;
memcpy(&readdir->rd_req_verifier, verifier, sizeof(readdir->rd_req_verifier));
readdir->rd_count = bufsize;
readdir->rd_bmval[0] = FATTR4_WORD0_FILEID;
readdir->rd_bmval[1] = 0;
readdir->rd_pages = pages;
readdir->rd_pgbase = 0;
OPNUM(cp) = OP_READDIR;
cp->req_nops++;
if (cookie >= 2)
return;
/*
* NFSv4 servers do not return entries for '.' and '..'
* Therefore, we fake these entries here. We let '.'
* have cookie 0 and '..' have cookie 1. Note that
* when talking to the server, we always send cookie 0
* instead of 1 or 2.
*/
start = p = (u32 *)kmap_atomic(*pages, KM_USER0);
if (cookie == 0) {
*p++ = xdr_one; /* next */
*p++ = xdr_zero; /* cookie, first word */
*p++ = xdr_one; /* cookie, second word */
*p++ = xdr_one; /* entry len */
memcpy(p, ".\0\0\0", 4); /* entry */
p++;
*p++ = xdr_one; /* bitmap length */
*p++ = htonl(FATTR4_WORD0_FILEID); /* bitmap */
*p++ = htonl(8); /* attribute buffer length */
p = xdr_encode_hyper(p, NFS_FILEID(dentry->d_inode));
}
*p++ = xdr_one; /* next */
*p++ = xdr_zero; /* cookie, first word */
*p++ = xdr_two; /* cookie, second word */
*p++ = xdr_two; /* entry len */
memcpy(p, "..\0\0", 4); /* entry */
p++;
*p++ = xdr_one; /* bitmap length */
*p++ = htonl(FATTR4_WORD0_FILEID); /* bitmap */
*p++ = htonl(8); /* attribute buffer length */
p = xdr_encode_hyper(p, NFS_FILEID(dentry->d_parent->d_inode));
readdir->rd_pgbase = (char *)p - (char *)start;
readdir->rd_count -= readdir->rd_pgbase;
kunmap_atomic(start, KM_USER0);
}
static int callml_custom_initialize(SUNLinearSolver ls)
{
CAMLparam0();
CAMLlocal1(r);
r = caml_callback_exn(GET_OP(ls, INIT), Val_unit);
CAMLreturnT(int, CHECK_EXCEPTION_SUCCESS(r));
}
static int callml_custom_setup(SUNLinearSolver ls, SUNMatrix A)
{
CAMLparam0();
CAMLlocal1(r);
r = caml_callback_exn(GET_OP(ls, SETUP),
(A == NULL) ? Val_unit : MAT_BACKLINK(A));
CAMLreturnT(int, CHECK_EXCEPTION_SUCCESS(r));
}
static void
nfs4_setup_getfh(struct nfs4_compound *cp, struct nfs_fh *fhandle)
{
struct nfs4_getfh *getfh = GET_OP(cp, getfh);
getfh->gf_fhandle = fhandle;
OPNUM(cp) = OP_GETFH;
cp->req_nops++;
}
static void
nfs4_setup_lookup(struct nfs4_compound *cp, struct qstr *q)
{
struct nfs4_lookup *lookup = GET_OP(cp, lookup);
lookup->lo_name = q;
OPNUM(cp) = OP_LOOKUP;
cp->req_nops++;
}
static void
nfs4_setup_putfh(struct nfs4_compound *cp, struct nfs_fh *fhandle)
{
struct nfs4_putfh *putfh = GET_OP(cp, putfh);
putfh->pf_fhandle = fhandle;
OPNUM(cp) = OP_PUTFH;
cp->req_nops++;
}
static void
nfs4_setup_readlink(struct nfs4_compound *cp, int count, struct page **pages)
{
struct nfs4_readlink *readlink = GET_OP(cp, readlink);
readlink->rl_count = count;
readlink->rl_pages = pages;
OPNUM(cp) = OP_READLINK;
cp->req_nops++;
}
static void
nfs4_setup_access(struct nfs4_compound *cp, u32 req_access, u32 *resp_supported, u32 *resp_access)
{
struct nfs4_access *access = GET_OP(cp, access);
access->ac_req_access = req_access;
access->ac_resp_supported = resp_supported;
access->ac_resp_access = resp_access;
OPNUM(cp) = OP_ACCESS;
cp->req_nops++;
}
static void
nfs4_setup_remove(struct nfs4_compound *cp, struct qstr *name, struct nfs4_change_info *cinfo)
{
struct nfs4_remove *remove = GET_OP(cp, remove);
remove->rm_namelen = name->len;
remove->rm_name = name->name;
remove->rm_cinfo = cinfo;
OPNUM(cp) = OP_REMOVE;
cp->req_nops++;
}
static void
nfs4_setup_link(struct nfs4_compound *cp, struct qstr *name,
struct nfs4_change_info *info)
{
struct nfs4_link *link = GET_OP(cp, link);
link->ln_namelen = name->len;
link->ln_name = name->name;
link->ln_cinfo = info;
OPNUM(cp) = OP_LINK;
cp->req_nops++;
}
static N_Vector callml_custom_resid(SUNLinearSolver ls)
{
CAMLparam0();
CAMLlocal1(r);
r = caml_callback_exn(GET_OP(ls, GET_RES_ID), Val_unit);
if (Is_exception_result (r)) {
sunml_warn_discarded_exn (Extract_exception (r),
"user-defined res id handler");
CAMLreturnT(N_Vector, NULL);
}
CAMLreturnT(N_Vector, NVEC_VAL(r));
}
static int callml_custom_setscalingvectors(SUNLinearSolver ls,
N_Vector s1, N_Vector s2)
{
CAMLparam0();
CAMLlocal3(r, ss1, ss2);
ss1 = Val_none;
if (s1 != NULL) Store_some(ss1, NVEC_BACKLINK(s1));
ss2 = Val_none;
if (s2 != NULL) Store_some(ss2, NVEC_BACKLINK(s2));
r = caml_callback2_exn(GET_OP(ls, SET_SCALING_VECTORS), ss1, ss2);
CAMLreturnT(int, CHECK_EXCEPTION_SUCCESS(r));
}
static int callml_custom_numiters(SUNLinearSolver ls)
{
CAMLparam0();
CAMLlocal1(r);
r = caml_callback_exn(GET_OP(ls, GET_NUM_ITERS), Val_unit);
if (Is_exception_result (r)) {
sunml_warn_discarded_exn (Extract_exception (r),
"user-defined num iters handler");
CAMLreturnT(int, 0);
}
CAMLreturnT(int, Int_val(r));
}
static realtype callml_custom_resnorm(SUNLinearSolver ls)
{
CAMLparam0();
CAMLlocal1(r);
r = caml_callback_exn(GET_OP(ls, GET_RES_NORM), Val_unit);
if (Is_exception_result (r)) {
sunml_warn_discarded_exn (Extract_exception (r),
"user-defined res norm handler");
CAMLreturnT(realtype, 0.0);
}
CAMLreturnT(realtype, Double_val(r));
}
static void
nfs4_setup_create_dir(struct nfs4_compound *cp, struct qstr *name,
struct iattr *sattr, struct nfs4_change_info *info)
{
struct nfs4_create *create = GET_OP(cp, create);
create->cr_ftype = NF4DIR;
create->cr_namelen = name->len;
create->cr_name = name->name;
create->cr_attrs = sattr;
create->cr_cinfo = info;
OPNUM(cp) = OP_CREATE;
cp->req_nops++;
}
static int callml_custom_solve(SUNLinearSolver ls, SUNMatrix A, N_Vector x,
N_Vector b, realtype tol)
{
CAMLparam0();
CAMLlocal1(r);
CAMLlocalN(args, 4);
Store_field(args, 0, (A == NULL) ? Val_unit : MAT_BACKLINK(A));
Store_field(args, 1, NVEC_BACKLINK(x));
Store_field(args, 2, NVEC_BACKLINK(b));
Store_field(args, 3, caml_copy_double(tol));
r = caml_callbackN_exn(GET_OP(ls, SOLVE), 4, args);
CAMLreturnT(int, CHECK_EXCEPTION_SUCCESS(r));
}
static int callml_custom_setatimes(SUNLinearSolver ls, void* A_data,
ATimesFn ATimes)
{
CAMLparam0();
CAMLlocal2(vcptr, r);
vcptr = caml_alloc_final(
(sizeof(struct atimes_with_data) + sizeof(value) - 1)
/ sizeof(value),
NULL, 0, 1);
ATIMES_WITH_DATA(vcptr)->atimes_func = ATimes;
ATIMES_WITH_DATA(vcptr)->atimes_data = A_data;
r = caml_callback_exn(GET_OP(ls, SET_ATIMES), vcptr);
CAMLreturnT(int, CHECK_EXCEPTION_SUCCESS(r));
}
/*****************************************************
* Follow nodes inside the (NODE) tree *
******************************************************/
void CompField::VisitTree(Node *node)
{
nbASSERT(node != NULL, "node cannot be NULL");
if (GET_OP(node->Op) == OP_LABEL) //More quick!
{
return;
}
switch(node->Op)
{
case IR_DEFFLD: //Definition Field
{
VisitFieldDetails(node->Kids[0]);
}break;
case IR_DEFVARS:
case IR_DEFVARI:
case IR_LKADD:
case IR_LKDEL:
case IR_LKHIT:
case IR_LKSEL:
case IR_REGEXFND:
case IR_REGEXXTR:
case IR_LKUPDS:
case IR_LKUPDI:
case IR_ASGNS:
case IR_ASGNI:
default:
{
if (node->Kids[0])
{
VisitTree(node->Kids[0]);
}
if (node->Kids[1])
{
VisitTree(node->Kids[1]);
}
if (node->Kids[2]) //Really USEFUL??
{
VisitTree(node->Kids[2]);
}
}break;
}
}
static inline void
__nfs4_setup_getattr(struct nfs4_compound *cp, u32 *bitmap,
struct nfs_fattr *fattr,
struct nfs_fsstat *fsstat,
struct nfs_fsinfo *fsinfo,
struct nfs_pathconf *pathconf)
{
struct nfs4_getattr *getattr = GET_OP(cp, getattr);
getattr->gt_bmval = bitmap;
getattr->gt_attrs = fattr;
getattr->gt_fsstat = fsstat;
getattr->gt_fsinfo = fsinfo;
getattr->gt_pathconf = pathconf;
OPNUM(cp) = OP_GETATTR;
cp->req_nops++;
}
static int callml_custom_space(SUNLinearSolver ls,
long int *lenrwLS, long int *leniwLS)
{
CAMLparam0();
CAMLlocal1(r);
r = caml_callback_exn(GET_OP(ls, GET_WORK_SPACE), Val_unit);
if (Is_exception_result (r)) {
r = Extract_exception (r);
lenrwLS = 0;
leniwLS = 0;
CAMLreturnT(int, lsolver_translate_exception(r));
}
*lenrwLS = Long_val(Field(r, 0));
*leniwLS = Long_val(Field(r, 1));
CAMLreturnT(int, SUNLS_SUCCESS);
}
void POVFPU_RemoveFunction(FUNCTION fn)
{
if((POVFPU_Functions == NULL) || (fn >= POVFPU_FunctionCnt))
return;
if(POVFPU_Functions[fn].reference_count > 0) // necessary to prevent any recursion
{
POVFPU_Functions[fn].reference_count--;
if(POVFPU_Functions[fn].reference_count == 0)
{
// The copying is necessary because recursive POVFPU_RemoveFunction
// calls may shrink the POVFPU_Functions array and remove the data
// before we are done with it here! [trf]
FunctionEntry f = POVFPU_Functions[fn];
unsigned int i = 0;
SYS_DELETE_FUNCTION(&f);
for(i = 0; i < f.fn.program_size; i++)
{
if(GET_OP(f.fn.program[i]) == OPCODE_CALL)
POVFPU_RemoveFunction(GET_K(f.fn.program[i]));
}
FNCode_Delete(&(f.fn));
for(i = POVFPU_FunctionCnt - 1; i > 0; i--)
{
if(POVFPU_Functions[i].reference_count == 0)
POVFPU_FunctionCnt--;
else
break;
}
if(POVFPU_FunctionCnt == 0)
{
POV_FREE(POVFPU_Functions);
POVFPU_Functions = NULL;
}
else
POVFPU_Functions = (FunctionEntry *)POV_REALLOC(POVFPU_Functions, sizeof(FunctionEntry) * POVFPU_FunctionCnt, "fn: FunctionEntry");
}
}
}
static int callml_custom_setpreconditioner(SUNLinearSolver ls, void* P_data,
PSetupFn Pset, PSolveFn Psol)
{
CAMLparam0();
CAMLlocal2(vcptr, r);
vcptr = caml_alloc_final(
(sizeof(struct precond_with_data) + sizeof(value) - 1)
/ sizeof(value),
NULL, 0, 1);
PRECOND_WITH_DATA(vcptr)->psetup_func = Pset;
PRECOND_WITH_DATA(vcptr)->psolve_func = Psol;
PRECOND_WITH_DATA(vcptr)->precond_data = P_data;
r = caml_callback3_exn(GET_OP(ls, SET_PRECONDITIONER),
vcptr, Val_bool(Pset != NULL), Val_bool(Psol != NULL));
CAMLreturnT(int, CHECK_EXCEPTION_SUCCESS(r));
}
static int apply(char* diff, char* base, char* dst, int direction)
{
while(*diff)
{
int op = GET_OP(*diff);
int cnt = GET_CNT(*diff);
diff++;
if(direction) //reverse
{
if(op == OP_SUB)
op = OP_ADD;
else
if(op == OP_ADD)
op = OP_SUB;
}
switch(op)
{
case OP_EQ:
while(cnt--)
*dst++ = *base++;
break;
case OP_SUB:
while(cnt--)
{
diff++;
base++;
}
break;
case OP_ADD:
while(cnt--)
*dst++ = *diff++;
break;
}
}
*dst = 0;
return 0;
}
/**
* @brief Converts the target specific opcode into the generic
* opcode of the simulator.
* @return The internal opcode for the generic simulator
* instruction.
*/
static int getOpcode(uint32_t opcode) {
int op;
int op2;
int op3;
int return_opcode = UNKNOWN;
op = GET_OP(opcode);
/* fprintf(stderr, "0x%08x\n", opcode); */
switch (op) {
/* only call instruction has format 1*/
case 1:
return_opcode = CALL;
break;
/* check, whether we have branch or sethi instructions */
case 0:
op2 = GET_OP2(opcode);
switch (op2) {
case OP2_BICC:
return_opcode = BRANCH;
break;
case OP2_SETHI:
/* don't forget to check for NOP later!*/
return_opcode = SETHI;
break;
case OP2_SIMCYCLES:
if (GET_RD(opcode) == SIM_CYCLES_PRINT) {
return_opcode = CYCLE_PRINT;
} else if (GET_RD(opcode) == SIM_CYCLES_CLEAR) {
return_opcode = CYCLE_CLEAR;
}
break;
}
break;
/* check for logical and arithmetic instructions */
case 2:
op3 = GET_OP3(opcode);
/* fprintf(stderr, "logical/arithmetic instruction - op3 = 0x%02x\n", op3); */
switch (op3) {
case OP3_AND:
return_opcode = AND;
break;
case OP3_ANDCC:
return_opcode = ANDCC;
break;
case OP3_ANDN:
return_opcode = ANDN;
break;
case OP3_ANDNCC:
return_opcode = ANDNCC;
break;
case OP3_OR:
return_opcode = OR;
break;
case OP3_ORCC:
return_opcode = ORCC;
break;
case OP3_ORN:
return_opcode = ORN;
break;
case OP3_ORNCC:
return_opcode = ORNCC;
break;
case OP3_XOR:
return_opcode = XOR;
break;
case OP3_XORCC:
return_opcode = XORCC;
break;
case OP3_XNOR:
return_opcode = XNOR;
break;
case OP3_XNORCC:
return_opcode = XNORCC;
break;
case OP3_SLL:
return_opcode = SLL;
break;
case OP3_SRL:
return_opcode = SRL;
break;
case OP3_SRA:
return_opcode = SRA;
break;
case OP3_ADD:
return_opcode = ADD;
break;
case OP3_ADDCC:
return_opcode = ADDCC;
break;
case OP3_ADDX:
return_opcode = ADDX;
break;
case OP3_ADDXCC:
return_opcode = ADDXCC;
break;
case OP3_TADDCC:
return_opcode = TADDCC;
break;
case OP3_TADDCCTV:
return_opcode = TADDCCTV;
break;
case OP3_SUB:
return_opcode = SUB;
break;
case OP3_SUBCC:
return_opcode = SUBCC;
break;
case OP3_SUBX:
return_opcode = SUBX;
break;
case OP3_SUBXCC:
return_opcode = SUBXCC;
break;
case OP3_TSUBCC:
return_opcode = TSUBCC;
break;
case OP3_TSUBCCTV:
return_opcode = TSUBCCTV;
break;
case OP3_MULSCC:
return_opcode = MULSCC;
break;
case OP3_UMUL:
return_opcode = UMUL;
break;
case OP3_SMUL:
return_opcode = SMUL;
break;
case OP3_UMULCC:
return_opcode = UMULCC;
break;
case OP3_SMULCC:
return_opcode = SMULCC;
break;
case OP3_UDIV:
return_opcode = UDIV;
break;
case OP3_SDIV:
return_opcode = SDIV;
break;
case OP3_UDIVCC:
return_opcode = UDIVCC;
break;
case OP3_SDIVCC:
return_opcode = SDIVCC;
break;
case OP3_SAVE:
return_opcode = SAVE;
break;
case OP3_RESTORE:
return_opcode = RESTORE;
break;
case OP3_JUMPL:
return_opcode = JUMPL;
break;
case OP3_RDY:
return_opcode = RD;
break;
case OP3_WRY:
return_opcode = WR;
break;
}
break;
/* check for memory instructions */
case 3:
op3 = GET_OP3(opcode);
switch (op3) {
case OP3_LDSB:
return_opcode = LDSB;
break;
case OP3_LDSH:
return_opcode = LDSH;
break;
case OP3_LDUB:
return_opcode = LDUB;
break;
case OP3_LDUH:
return_opcode = LDUH;
break;
case OP3_LD:
return_opcode = LD;
break;
case OP3_LDD:
return_opcode = LDD;
break;
case OP3_LDSBA:
return_opcode = LDSBA;
break;
case OP3_LDSHA:
return_opcode = LDSHA;
break;
case OP3_LDUBA:
return_opcode = LDUBA;
break;
case OP3_LDUHA:
return_opcode = LDUHA;
break;
case OP3_LDA:
return_opcode = LDA;
break;
case OP3_LDDA:
return_opcode = LDDA;
break;
case OP3_STB:
return_opcode = STB;
break;
case OP3_STH:
return_opcode = STH;
break;
case OP3_ST:
return_opcode = ST;
break;
case OP3_STD:
return_opcode = STD;
break;
case OP3_STBA:
return_opcode = STBA;
break;
case OP3_STHA:
return_opcode = STHA;
break;
case OP3_STA:
return_opcode = STA;
break;
case OP3_STDA:
return_opcode = STDA;
break;
case OP3_LDSTUB:
return_opcode = LDSTUB;
break;
case OP3_LDSTUBA:
return_opcode = LDSTUBA;
break;
case OP3_SWAP:
return_opcode = SWAP;
break;
case OP3_SWAPA:
return_opcode = SWAPA;
break;
}
break;
}
return return_opcode;
}
DBL POVFPU_RunDefault(FUNCTION fn)
{
StackFrame *pstack = POVFPU_Current_Context->pstackbase;
DBL *dblstack = POVFPU_Current_Context->dblstackbase;
unsigned int maxdblstacksize = POVFPU_Current_Context->maxdblstacksize;
DBL r0, r1, r2, r3, r4, r5, r6, r7;
Instruction *program = NULL;
unsigned int k = 0;
unsigned int pc = 0;
unsigned int ccr = 0;
unsigned int sp = 0;
unsigned int psp = 0;
#if (SUPPORT_INTEGER_INSTRUCTIONS == 1)
POV_LONG iA, iB, itemp;
#endif
#if (DEBUG_DEFAULTCPU == 1)
COUNTER instr;
Long_To_Counter(POVFPU_Functions[fn].fn.program_size, instr);
Add_Counter(stats[Ray_Function_VM_Instruction_Est], stats[Ray_Function_VM_Instruction_Est], instr);
#endif
Increase_Counter(stats[Ray_Function_VM_Calls]);
program = POVFPU_Functions[fn].fn.program;
while(true)
{
k = GET_K(program[pc]);
switch(GET_OP(program[pc]))
{
OP_MATH_AOP(0,+); // add Rs, Rd
OP_MATH_AOP(1,-); // sub Rs, Rd
OP_MATH_AOP(2,*); // mul Rs, Rd
OP_MATH_AOP(3,/); // div Rs, Rd
OP_MOD_A(4); // mod Rs, Rd
OP_ASSIGN_ABOP(5,0,r0); // move R0, Rd
OP_ASSIGN_ABOP(5,1,r1); // move R1, Rd
OP_ASSIGN_ABOP(5,2,r2); // move R2, Rd
OP_ASSIGN_ABOP(5,3,r3); // move R3, Rd
OP_ASSIGN_ABOP(5,4,r4); // move R4, Rd
OP_ASSIGN_ABOP(5,5,r5); // move R5, Rd
OP_ASSIGN_ABOP(5,6,r6); // move R6, Rd
OP_ASSIGN_ABOP(5,7,r7); // move R7, Rd
OP_CMP_ABC(6,0,r0); // cmp R0, Rd
OP_CMP_ABC(6,1,r1); // cmp R1, Rd
OP_CMP_ABC(6,2,r2); // cmp R2, Rd
OP_CMP_ABC(6,3,r3); // cmp R3, Rd
OP_CMP_ABC(6,4,r4); // cmp R4, Rd
OP_CMP_ABC(6,5,r5); // cmp R5, Rd
OP_CMP_ABC(6,6,r6); // cmp R6, Rd
OP_CMP_ABC(6,7,r7); // cmp R7, Rd
OP_ASSIGN_ABOP(7,0,-r0); // neg R0, Rd
OP_ASSIGN_ABOP(7,1,-r1); // neg R1, Rd
OP_ASSIGN_ABOP(7,2,-r2); // neg R2, Rd
OP_ASSIGN_ABOP(7,3,-r3); // neg R3, Rd
OP_ASSIGN_ABOP(7,4,-r4); // neg R4, Rd
OP_ASSIGN_ABOP(7,5,-r5); // neg R5, Rd
OP_ASSIGN_ABOP(7,6,-r6); // neg R6, Rd
OP_ASSIGN_ABOP(7,7,-r7); // neg R7, Rd
OP_ABS_A(8); // abs Rs, Rd
OP_MATH_ABCOP(9,0,POVFPU_Consts[k],+); // addi k, Rd
OP_MATH_ABCOP(9,1,POVFPU_Consts[k],-); // subi k, Rd
OP_MATH_ABCOP(9,2,POVFPU_Consts[k],*); // muli k, Rd
OP_MATH_ABCOP(9,3,POVFPU_Consts[k],/); // divi k, Rd
OP_MOD_ABC(9,4,POVFPU_Consts[k]); // modi k, Rd
OP_ASSIGN_ABOP(9,5,POVFPU_Consts[k]); // loadi k, Rd
OP_CMP_ABC(9,6,POVFPU_Consts[k]); // cmpi k, Rs
OP_ASSIGN_ABOP(10,0,ccr == 1); // seq Rd
OP_ASSIGN_ABOP(10,1,ccr != 1); // sne Rd
OP_ASSIGN_ABOP(10,2,ccr == 2); // slt Rd
OP_ASSIGN_ABOP(10,3,ccr >= 1); // sle Rd
OP_ASSIGN_ABOP(10,4,ccr == 0); // sgt Rd
OP_ASSIGN_ABOP(10,5,ccr <= 1); // sge Rd
OP_MATH_ABCOP(10,6,0.0,==); // teq Rd
OP_MATH_ABCOP(10,7,0.0,!=); // tne Rd
OP_ASSIGN_ABOP(11,0,POVFPU_Globals[k]); // load 0(k), Rd
OP_ASSIGN_ABOP(11,1,dblstack[sp+k]); // load SP(k), Rd
OP_REVASSIGN_ABOP(12,0,POVFPU_Globals[k]); // store Rs, 0(k)
OP_REVASSIGN_ABOP(12,1,dblstack[sp+k]); // store Rs, SP(k)
OP_SPECIAL(13,0,0,if(ccr == 1) pc = k - 1); // beq k
OP_SPECIAL(13,1,0,if(ccr != 1) pc = k - 1); // bne k
OP_SPECIAL(13,2,0,if(ccr == 2) pc = k - 1); // blt k
OP_SPECIAL(13,3,0,if(ccr >= 1) pc = k - 1); // ble k
OP_SPECIAL(13,4,0,if(ccr == 0) pc = k - 1); // bgt k
OP_SPECIAL(13,5,0,if(ccr <= 1) pc = k - 1); // bge k
OP_XCC_ABOP(14,0,==); // xeq Rd
OP_XCC_ABOP(14,1,!=); // xne Rd
OP_XCC_ABOP(14,2,<); // xlt Rd
OP_XCC_ABOP(14,3,<=); // xle Rd
OP_XCC_ABOP(14,4,>); // xgt Rd
OP_XCC_ABOP(14,5,>=); // xge Rd
OP_SPECIAL(14,6,0,if((r0 == 0.0) && (r0 == 0.0)) POVFPU_Exception(fn)); // xdz R0, R0
OP_SPECIAL(14,6,1,if((r0 == 0.0) && (r1 == 0.0)) POVFPU_Exception(fn)); // xdz R0, R1
OP_SPECIAL(14,6,2,if((r0 == 0.0) && (r2 == 0.0)) POVFPU_Exception(fn)); // xdz R0, R2
OP_SPECIAL(14,6,3,if((r0 == 0.0) && (r3 == 0.0)) POVFPU_Exception(fn)); // xdz R0, R3
OP_SPECIAL(14,6,4,if((r0 == 0.0) && (r4 == 0.0)) POVFPU_Exception(fn)); // xdz R0, R4
OP_SPECIAL(14,6,5,if((r0 == 0.0) && (r5 == 0.0)) POVFPU_Exception(fn)); // xdz R0, R5
OP_SPECIAL(14,6,6,if((r0 == 0.0) && (r6 == 0.0)) POVFPU_Exception(fn)); // xdz R0, R6
OP_SPECIAL(14,6,7,if((r0 == 0.0) && (r7 == 0.0)) POVFPU_Exception(fn)); // xdz R0, R7
OP_SPECIAL_CASE(15,0,0) // jsr k
pstack[psp].pc = pc;
pstack[psp].fn = fn;
psp++;
if(psp >= MAX_CALL_STACK_SIZE)
POVFPU_Exception(fn, "Maximum function evaluation recursion level reached.");
pc = k;
continue; // prevent increment of pc
OP_SPECIAL_CASE(15,0,1) // jmp k
pc = k;
continue; // prevent increment of pc
OP_SPECIAL_CASE(15,0,2) // rts
if(psp == 0)
return r0;
psp--;
pc = pstack[psp].pc; // old position, will be incremented
fn = pstack[psp].fn;
program = POVFPU_Functions[fn].fn.program;
break;
OP_SPECIAL_CASE(15,0,3) // call k
pstack[psp].pc = pc;
pstack[psp].fn = fn;
psp++;
if(psp >= MAX_CALL_STACK_SIZE)
POVFPU_Exception(fn, "Maximum function evaluation recursion level reached.");
fn = k;
program = POVFPU_Functions[fn].fn.program;
pc = 0;
continue; // prevent increment of pc
OP_SPECIAL_CASE(15,0,4) // sys1 k
r0 = POVFPU_Sys1Table[k](r0);
break;
OP_SPECIAL_CASE(15,0,5) // sys2 k
r0 = POVFPU_Sys2Table[k](r0,r1);
break;
OP_SPECIAL_CASE(15,0,6) // trap k
r0 = POVFPU_TrapTable[k].fn(&dblstack[sp], fn);
maxdblstacksize = POVFPU_Current_Context->maxdblstacksize;
dblstack = POVFPU_Current_Context->dblstackbase;
break;
OP_SPECIAL_CASE(15,0,7) // traps k
POVFPU_TrapSTable[k].fn(&dblstack[sp], fn, sp);
maxdblstacksize = POVFPU_Current_Context->maxdblstacksize;
dblstack = POVFPU_Current_Context->dblstackbase;
break;
OP_SPECIAL_CASE(15,1,0) // grow k
if((unsigned int)((unsigned int)sp + (unsigned int)k) >= (unsigned int)MAX_K)
{
POVFPU_Exception(fn, "Stack full. Possible infinite recursive function call.");
}
else if(sp + k >= maxdblstacksize)
{
maxdblstacksize = POVFPU_Current_Context->maxdblstacksize = POVFPU_Current_Context->maxdblstacksize + max(k + 1, (unsigned int)256);
dblstack = POVFPU_Current_Context->dblstackbase = (DBL *)POV_REALLOC(dblstack, sizeof(DBL) * maxdblstacksize, "fn: stack");
}
break;
OP_SPECIAL_CASE(15,1,1) // push k
if(sp + k >= maxdblstacksize)
POVFPU_Exception(fn, "Function evaluation stack overflow.");
sp += k;
break;
OP_SPECIAL_CASE(15,1,2) // pop k
if(k > sp)
POVFPU_Exception(fn, "Function evaluation stack underflow.");
sp -= k;
break;
#if (SUPPORT_INTEGER_INSTRUCTIONS == 1)
OP_SPECIAL_CASE(15,1,3) // iconv
iA = POV_LONG(r0);
break;
OP_SPECIAL_CASE(15,1,4) // fconv
r0 = DBL(iA);
break;
OP_SPECIAL_CASE(15,1,5) // reserved
POVFPU_Exception(fn, "Internal error - reserved function VM opcode found!");
break;
OP_INT_MATH_ABOP(15,32,+); // add s, d
OP_INT_MATH_ABOP(15,33,-); // sub s, d
OP_INT_MATH_ABOP(15,34,*); // mul s, d
OP_INT_SPECIAL(15,35,0,iA = iA / iB); // div B, A
OP_INT_SPECIAL(15,35,1,iB = iB / iA); // div A, B
OP_INT_SPECIAL(15,35,2,iA = iA % iB); // mod B, A
OP_INT_SPECIAL(15,35,3,iB = iB % iA); // mod A, B
OP_INT_SPECIAL(15,36,0,ccr = (((iB > iA) & 1) << 1) | ((iB == iA) & 1)); // cmp B, A
OP_INT_SPECIAL(15,36,1,ccr = (((iA > iB) & 1) << 1) | ((iA == iB) & 1)); // cmp A, B
OP_INT_SPECIAL(15,36,2,itemp = iA; iA = iB; iB = itemp); // exg A, B
OP_INT_SPECIAL(15,36,3,iA = iB = 0); // clr A, B
OP_INT_SPECIAL(15,37,0,iA = 0); // clr A
OP_INT_SPECIAL(15,37,1,iB = 0); // clr B
OP_INT_SPECIAL(15,37,2,iA = iB); // move B, A
OP_INT_SPECIAL(15,37,3,iB = iA); // move A, B
OP_INT_SPECIAL(15,38,0,iA = -iA); // neg A
OP_INT_SPECIAL(15,38,1,iB = -iB); // neg B
OP_INT_SPECIAL(15,38,2,iA = abs(iA)); // abs A
OP_INT_SPECIAL(15,38,3,iB = abs(iB)); // abs B
OP_INT_SPECIAL(15,39,0,iA = iA + k); // addi k, A
OP_INT_SPECIAL(15,39,1,iB = iB + k); // addi k, B
OP_INT_SPECIAL(15,39,2,iA = iA - k); // subi k, A
OP_INT_SPECIAL(15,39,3,iB = iB - k); // subi k, B
OP_INT_MATH_SHIFT_ABOP(15,40,<<,POV_LONG); // asl s, d
OP_INT_MATH_SHIFT_ABOP(15,41,>>,POV_LONG); // asr s, d
OP_INT_MATH_SHIFT_ABOP(15,42,<<,POV_ULONG); // lsl s, d
OP_INT_MATH_SHIFT_ABOP(15,43,>>,POV_ULONG); // lsr s, d
OP_INT_MATH_ABOP(15,44,&); // and s, d
OP_INT_MATH_ABOP(15,45,|); // or s, d
OP_INT_MATH_ABOP(15,46,^); // xor s, d
OP_INT_SPECIAL(15,47,0,iA = !iA); // not A, A
OP_INT_SPECIAL(15,47,1,iA = !iB); // not B, A
OP_INT_SPECIAL(15,47,2,iB = !iA); // not A, B
OP_INT_SPECIAL(15,47,3,iB = !iB); // not B, B
OP_INT_SPECIAL(15,48,0,iA = k); // loadi A
OP_INT_SPECIAL(15,48,1,iB = k); // loadi B
OP_INT_SPECIAL(15,48,2,iA = (iA << 16) | k);// ldhi A
OP_INT_SPECIAL(15,48,3,iB = (iB << 16) | k);// ldhi B
OP_INT_SPECIAL(15,49,0,iA = max(POV_LONG(k), iA)); // max k, A
OP_INT_SPECIAL(15,49,1,iB = max(POV_LONG(k), iB)); // max k, B
OP_INT_SPECIAL(15,49,2,iA = min(POV_LONG(k), iA)); // min k, A
OP_INT_SPECIAL(15,49,3,iB = min(POV_LONG(k), iB)); // min k, B
OP_INT_SPECIAL(15,50,0,iA = (POV_LONG(iA) << k)); // asl k, A
OP_INT_SPECIAL(15,50,1,iB = (POV_LONG(iB) >> k)); // asr k, B
OP_INT_SPECIAL(15,50,2,iA = (POV_ULONG(iA) << k)); // lsl k, A
OP_INT_SPECIAL(15,50,3,iB = (POV_ULONG(iB) >> k)); // lsr k, B
#endif
default: // nop
break;
}
pc++;
}
#if (DEBUG_DEFAULTCPU == 1)
printf("Registers\n");
printf("=========\n");
printf("PC = %d\n", (int)pc);
printf("CCR = %x\n", (int)ccr);
printf("R0 = %8f R4 = %8f\n", (float)r0, (float)r4);
printf("R1 = %8f R5 = %8f\n", (float)r1, (float)r5);
printf("R2 = %8f R6 = %8f\n", (float)r2, (float)r6);
printf("R3 = %8f R7 = %8f\n", (float)r3, (float)r7);
#endif
}
static void diff_str(char* s1, char* s2, char* s3)
{
char* start = s2;
char* j;
char* last_op = s3;
*last_op = 0;
for(; *s1; s1++)
{
int res = 1;
for(j = start; *j; j++)
{
res = (*s1 - *j);
if(!res) //Match found
break;
}
if(!res) //Match found
{
//Fill the gap, if any
if(start < j)
{
last_op = s3;
*s3++ = OP_SUB;
while(start < j)
{
if(GET_CNT(*last_op) == MAX_CNT)
{
last_op = s3;
*s3++ = OP_SUB;
}
*s3++ = *start++;
*last_op = *last_op + 1;
}
}
if(GET_OP(*last_op) == OP_EQ)
{
if(GET_CNT(*last_op) == MAX_CNT)
{
last_op = s3;
*s3++ = OP_EQ;
}
*last_op = *last_op + 1;
}
else
{
last_op = s3;
*s3++ = OP_EQ | 0x01;
}
start++;
}
else //No match
{
if(GET_OP(*last_op) == OP_ADD)
{
if(GET_CNT(*last_op) == MAX_CNT)
{
last_op = s3;
*s3++ = OP_ADD;
}
*s3++ = *s1;
*last_op = *last_op + 1;
}
else
{
last_op = s3;
*s3++ = OP_ADD | 0x01;
*s3++ = *s1;
}
}
}
if(*start)
{
last_op = s3;
*s3++ = OP_SUB;
while(*start)
{
if(GET_CNT(*last_op) == MAX_CNT)
{
last_op = s3;
*s3++ = OP_SUB;
}
*s3++ = *start++;
*last_op = *last_op + 1;
}
}
*s3 = 0;
}
{
struct nfs4_remove *remove = GET_OP(cp, remove);
remove->rm_namelen = name->len;
remove->rm_name = name->name;
remove->rm_cinfo = cinfo;
OPNUM(cp) = OP_REMOVE;
cp->req_nops++;
}
static void
nfs4_setup_rename(struct nfs4_compound *cp, struct qstr *old, struct qstr *new,
struct nfs4_change_info *old_cinfo, struct nfs4_change_info *new_cinfo)
{
struct nfs4_rename *rename = GET_OP(cp, rename);
rename->rn_oldnamelen = old->len;
rename->rn_oldname = old->name;
rename->rn_newnamelen = new->len;
rename->rn_newname = new->name;
rename->rn_src_cinfo = old_cinfo;
rename->rn_dst_cinfo = new_cinfo;
OPNUM(cp) = OP_RENAME;
cp->req_nops++;
}
static void
nfs4_setup_renew(struct nfs4_compound *cp)
{
