diogo/yap-6.3
Archived
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

use same format for all call instructions; try to be more robust in doing g

Browse Source
This commit is contained in:
Vitor Santos Costa 2017-08-27 22:03:19 +01:00
parent 8bf607aa65
commit 51b99388e7
13 changed files with 1199 additions and 1274 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
C/absmi.c
View File

@ -526,8 +526,8 @@ static int interrupt_execute(USES_REGS1) {
} }
if (PP) if (PP)
UNLOCKPE(1, PP); UNLOCKPE(1, PP);
PP = P->y_u.pp.p0; PP = P->y_u.Osbpp.p0;
if ((P->y_u.pp.p->PredFlags & (NoTracePredFlag | HiddenPredFlag)) && if ((P->y_u.Osbpp.p->PredFlags & (NoTracePredFlag | HiddenPredFlag)) &&
Yap_only_has_signal(YAP_CREEP_SIGNAL)) { Yap_only_has_signal(YAP_CREEP_SIGNAL)) {
return 2; return 2;
} }
@ -535,11 +535,11 @@ static int interrupt_execute(USES_REGS1) {
if ((v = code_overflow(YENV PASS_REGS)) >= 0) { if ((v = code_overflow(YENV PASS_REGS)) >= 0) {
return v; return v;
} }
if ((v = stack_overflow(P->y_u.pp.p, ENV, CP, if ((v = stack_overflow(P->y_u.Osbpp.p, ENV, CP,
P->y_u.pp.p->ArityOfPE PASS_REGS)) >= 0) { P->y_u.Osbpp.p->ArityOfPE PASS_REGS)) >= 0) {
return v; return v;
} }
return interrupt_handler(P->y_u.pp.p PASS_REGS); return interrupt_handler(P->y_u.Osbpp.p PASS_REGS);
} }
static int interrupt_call(USES_REGS1) { static int interrupt_call(USES_REGS1) {
@ -864,8 +864,8 @@ static int interrupt_dexecute(USES_REGS1) {
#endif #endif
if (PP) if (PP)
UNLOCKPE(1, PP); UNLOCKPE(1, PP);
PP = P->y_u.pp.p0; PP = P->y_u.Osbpp.p0;
pe = P->y_u.pp.p; pe = P->y_u.Osbpp.p;
if ((pe->PredFlags & (NoTracePredFlag | HiddenPredFlag)) && if ((pe->PredFlags & (NoTracePredFlag | HiddenPredFlag)) &&
Yap_only_has_signal(YAP_CREEP_SIGNAL)) { Yap_only_has_signal(YAP_CREEP_SIGNAL)) {
return 2; return 2;
@ -877,8 +877,8 @@ static int interrupt_dexecute(USES_REGS1) {
if ((v = code_overflow(YENV PASS_REGS)) >= 0) { if ((v = code_overflow(YENV PASS_REGS)) >= 0) {
return v; return v;
} }
if ((v = stack_overflow(P->y_u.pp.p, (CELL *)YENV[E_E], (yamop *)YENV[E_CP], if ((v = stack_overflow(P->y_u.Osbpp.p, (CELL *)YENV[E_E], (yamop *)YENV[E_CP],
P->y_u.pp.p->ArityOfPE PASS_REGS)) >= 0) { P->y_u.Osbpp.p->ArityOfPE PASS_REGS)) >= 0) {
return v; return v;
} }
/* first, deallocate */ /* first, deallocate */

16
C/amasm.c
View File

@ -1434,10 +1434,12 @@ a_p(op_numbers opcode, clause_info *clinfo, yamop *code_p, int pass_no,
if (Flags & CPredFlag) { if (Flags & CPredFlag) {
code_p->opc = emit_op(_execute_cpred); code_p->opc = emit_op(_execute_cpred);
} }
code_p->y_u.pp.p = RepPredProp(fe); code_p->y_u.Osbpp.p = RepPredProp(fe);
code_p->y_u.pp.p0 = clinfo->CurrentPred; code_p->y_u.Osbpp.p0 = clinfo->CurrentPred;
code_p->y_u.Osbpp.s = 0;
code_p->y_u.Osbpp.bmap = NULL;
} }
GONEXT(pp); GONEXT(Osbpp);
} else { } else {
if (pass_no) if (pass_no)
code_p->y_u.p.p = RepPredProp(fe); code_p->y_u.p.p = RepPredProp(fe);
@ -3901,7 +3903,7 @@ yamop *Yap_InitCommaContinuation(PredEntry *pe) {
GONEXT(Osbmp); GONEXT(Osbmp);
for (i = 0; i < arity; i++) for (i = 0; i < arity; i++)
GONEXT(yx); GONEXT(yx);
GONEXT(pp); GONEXT(Osbmp);
pe->MetaEntryOfPred = code_p = pe->MetaEntryOfPred = code_p =
Yap_AllocCodeSpace((size_t)code_p); Yap_AllocCodeSpace((size_t)code_p);
code_p->opc = opcode(_call); code_p->opc = opcode(_call);
@ -3917,8 +3919,8 @@ Yap_AllocCodeSpace((size_t)code_p);
GONEXT(yx); GONEXT(yx);
} }
code_p->opc = opcode(_dexecute); code_p->opc = opcode(_dexecute);
code_p->y_u.pp.p0 = PredMetaCall; code_p->y_u.Osbpp.p0 = PredMetaCall;
code_p->y_u.pp.p = pe; code_p->y_u.Osbpp.p = pe;
GONEXT(pp); GONEXT(Osbpp);
return pe->MetaEntryOfPred; return pe->MetaEntryOfPred;
} }

14
C/control_absmi_insts.h
View File

@ -194,18 +194,18 @@
/* Macros for stack trimming */ /* Macros for stack trimming */
/* execute Label */ /* execute Label */
BOp(execute, pp); BOp(execute, Osbpp);
{ {
PredEntry *pt0; PredEntry *pt0;
CACHE_Y_AS_ENV(YREG); CACHE_Y_AS_ENV(YREG);
pt0 = PREG->y_u.pp.p; pt0 = PREG->y_u.Osbpp.p;
#ifndef NO_CHECKING #ifndef NO_CHECKING
check_stack(NoStackExecute, HR); check_stack(NoStackExecute, HR);
goto skip_do_execute; goto skip_do_execute;
#endif #endif
do_execute: do_execute:
FETCH_Y_FROM_ENV(YREG); FETCH_Y_FROM_ENV(YREG);
pt0 = PREG->y_u.pp.p; pt0 = PREG->y_u.Osbpp.p;
skip_do_execute: skip_do_execute:
#ifdef LOW_LEVEL_TRACER #ifdef LOW_LEVEL_TRACER
if (Yap_do_low_level_trace) { if (Yap_do_low_level_trace) {
@ -244,17 +244,17 @@
/* dexecute Label */ /* dexecute Label */
/* joint deallocate and execute */ /* joint deallocate and execute */
BOp(dexecute, pp); BOp(dexecute, Osbpp);
#ifdef LOW_LEVEL_TRACER #ifdef LOW_LEVEL_TRACER
if (Yap_do_low_level_trace) if (Yap_do_low_level_trace)
low_level_trace(enter_pred,PREG->y_u.pp.p,XREGS+1); low_level_trace(enter_pred,PREG->y_u.Osbpp.p,XREGS+1);
#endif /* LOW_LEVEL_TRACER */ #endif /* LOW_LEVEL_TRACER */
CACHE_Y_AS_ENV(YREG); CACHE_Y_AS_ENV(YREG);
{ {
PredEntry *pt0; PredEntry *pt0;
CACHE_A1(); CACHE_A1();
pt0 = PREG->y_u.pp.p; pt0 = PREG->y_u.Osbpp.p;
#ifndef NO_CHECKING #ifndef NO_CHECKING
/* check stacks */ /* check stacks */
check_stack(NoStackDExecute, HR); check_stack(NoStackDExecute, HR);
@ -262,7 +262,7 @@
#endif #endif
continue_dexecute: continue_dexecute:
FETCH_Y_FROM_ENV(YREG); FETCH_Y_FROM_ENV(YREG);
pt0 = PREG->y_u.pp.p; pt0 = PREG->y_u.Osbpp.p;
skip_dexecute: skip_dexecute:
#ifdef DEPTH_LIMIT #ifdef DEPTH_LIMIT
if (DEPTH <= MkIntTerm(1)) {/* I assume Module==0 is primitives */ if (DEPTH <= MkIntTerm(1)) {/* I assume Module==0 is primitives */

15
C/errors.c
View File

@ -130,14 +130,27 @@ bool Yap_HandleError__(const char *file, const char *function, int lineno,
yap_error_number err = LOCAL_Error_TYPE; yap_error_number err = LOCAL_Error_TYPE;
const char *serr; const char *serr;
arity_t arity = 2;
if (LOCAL_ErrorMessage) { if (LOCAL_ErrorMessage) {
serr = LOCAL_ErrorMessage; serr = LOCAL_ErrorMessage;
} else { } else {
serr = s; serr = s;
} }
if (P->opc == Yap_opcode(_try_c) ||
P->opc == Yap_opcode(_try_userc) ||
P->opc == Yap_opcode(_retry_c) ||
P->opc == Yap_opcode(_retry_userc)) {
arity = P->y_u.OtapFs.p->ArityOfPE;
} else {
arity = PREVOP(P,Osbpp)->y_u.Osbpp.p->ArityOfPE;
}
switch (err) { switch (err) {
case RESOURCE_ERROR_STACK: case RESOURCE_ERROR_STACK:
if (!Yap_gc(2, ENV, gc_P(P, CP))) { if (!Yap_gc(arity, ENV, gc_P(P, CP))) {
Yap_Error__(file, function, lineno, RESOURCE_ERROR_STACK, ARG1, serr); Yap_Error__(file, function, lineno, RESOURCE_ERROR_STACK, ARG1, serr);
return false; return false;
} }

6
C/fli_absmi_insts.h
View File

@ -74,7 +74,7 @@
ENDBOp(); ENDBOp();
/* execute Label */ /* execute Label */
BOp(execute_cpred, pp); BOp(execute_cpred, Osbpp);
check_trail(TR); check_trail(TR);
{ {
PredEntry *pt0; PredEntry *pt0;
@ -103,7 +103,7 @@
SET_ASP(YREG, E_CB * sizeof(CELL)); SET_ASP(YREG, E_CB * sizeof(CELL));
/* for slots to work */ /* for slots to work */
#endif /* FROZEN_STACKS */ #endif /* FROZEN_STACKS */
pt0 = PREG->y_u.pp.p; pt0 = PREG->y_u.Osbpp.p;
#ifdef LOW_LEVEL_TRACER #ifdef LOW_LEVEL_TRACER
if (Yap_do_low_level_trace) { if (Yap_do_low_level_trace) {
low_level_trace(enter_pred, pt0, XREGS + 1); low_level_trace(enter_pred, pt0, XREGS + 1);
@ -131,7 +131,7 @@
#endif /* DEPTH_LIMIT */ #endif /* DEPTH_LIMIT */
/* now call C-Code */ /* now call C-Code */
{ {
CPredicate f = PREG->y_u.pp.p->cs.f_code; CPredicate f = PREG->y_u.Osbpp.p->cs.f_code;
yamop *oldPREG = PREG; yamop *oldPREG = PREG;
saveregs(); saveregs();
d0 = f(PASS_REGS1); d0 = f(PASS_REGS1);

2
C/gprof.c
View File

@ -973,7 +973,7 @@ prof_alrm(int signo, siginfo_t *si, void *scv)
current_p = PREVOP(P,Osbpp)->y_u.Osbpp.p->CodeOfPred; current_p = PREVOP(P,Osbpp)->y_u.Osbpp.p->CodeOfPred;
} else if ((oop = Yap_op_from_opcode(P->opc)) == _execute_cpred) { } else if ((oop = Yap_op_from_opcode(P->opc)) == _execute_cpred) {
/* doing C-code */ /* doing C-code */
current_p = P->y_u.pp.p->CodeOfPred; current_p = P->y_u.Osbpp.p->CodeOfPred;
} else { } else {
current_p = P; current_p = P;
} }

4
C/stack.c
View File

@ -789,9 +789,9 @@ static PredEntry *found_ystop(yamop *pc, int clause_code, void **startp, void **
return pp; return pp;
} }
if (!pp) { if (!pp) {
yamop *o = PREVOP(pc,pp); yamop *o = PREVOP(pc,Osbpp);
if (o->opc ==Yap_opcode(_execute_cpred)) { if (o->opc ==Yap_opcode(_execute_cpred)) {
pp = o->y_u.pp.p0; pp = o->y_u.Osbpp.p0;
} else { } else {
/* must be an index */ /* must be an index */
PredEntry **pep = (PredEntry **)pc->y_u.l.l; PredEntry **pep = (PredEntry **)pc->y_u.l.l;

499
H/YapCompile.h
View File

@ -2,291 +2,231 @@
* * * *
* YAP Prolog %W% %G% * * YAP Prolog %W% %G% *
* * * *
* Yap Prolog was developed at NCCUP - Universidade do Porto * *Yap Prolog was developed at NCCUP - Universidade do Porto *
* * * *
* Copyright L.Damas, V.S.Costa and Universidade do Porto 1985-1997 * * Copyright L.Damas, V.S.Costa and Universidade do Porto 1985-1997 *
* * * *
************************************************************************** **************************************************************************
* * * *
* File: YapCompile.h * * File:YapCompile.h *
* Last rev: * * Last rev: *
* mods: * * mods: *
* comments: compiler data structures and routines * * comments:compiler data structures and routines *
* * * *
*************************************************************************/ *************************************************************************/
/* consult stack management */ /* consult stack management */
/* virtual machine instruction op-codes */ #undef COMPILER_OPS
#define mklist0(f) \ #undef COMPILER_OPS_END
f(nop_op, "nop") f(get_var_op, "get_var\t\t%v,%r") f(put_var_op, "put_" \ #undef f
"var\t\t%" \
"v,%r") f( \ #ifdef COMPILER_NAMES
get_val_op, "get_val\t\t%v,%r") f(put_val_op, \
"put_val\t\t%v,%r") f(get_atom_op, \ #define COMPILER_OPS() char *opDesc[] =
"get_atom\t%a,%" \ #define COMPILER_OPS_END()
"r") f(put_atom_op, \ #define f(x,y) y
"put_" \
"atom\t%" \
"a,%r") \
f(get_num_op, "get_num\t\t%n,%r") f(put_num_op, "put_num\t\t%n,%r") f( \
get_float_op, \
"get_float\t\t%w,%r") f(put_float_op, \
"put_float\t\t%w,%r") f(get_dbterm_op, \
"get_dbterm\t%w,%r") \
f(put_dbterm_op, "put_dbterm\t%w,%r") f(get_longint_op, "get_" \
"longint\t" \
"\t%w,%r") f( \
put_longint_op, \
"put_longint\t\t%w,%r") f(get_string_op, \
"get_string\t\t%w,%S") f(put_string_op, \
"put_" \
"string\t\t%" \
"w,%S") \
f(get_bigint_op, "get_bigint\t\t%l,%r") f(put_bigint_op, "put_" \
"bigin" \
"t\t\t" \
"%l,%" \
"r") f( \
get_list_op, \
"get_list\t%r") f(put_list_op, \
"put_list\t%r") f(get_struct_op, \
"get_struct\t%f,%r") \
f(put_struct_op, "put_struct\t%f,%r") f(put_unsafe_op, "put" \
"_un" \
"saf" \
"e\t" \
"%v," \
"%r") f( \
unify_var_op, \
"unify_var\t%v") f(write_var_op, \
"write_var\t%v") f(unify_val_op, \
"unify_val\t%v") \
f(write_val_op, "write_val\t%v") f(unify_atom_op, "unif" \
"y_" \
"atom" \
"\t%" \
"a") f( \
write_atom_op, \
"write_atom\t%a") f(unify_num_op, \
"unify_num\t%n") f(write_num_op, \
"write_" \
"num\t%n") \
f(unify_float_op, "unify_float\t%w") f( \
write_float_op, \
"write_float\t%w") f(unify_dbterm_op, \
"unify_dbterm\t%w") \
f(write_dbterm_op, "write_dbterm\t%w") f( \
unify_longint_op, \
"unify_longint\t%w") f(write_longint_op, \
"write_longint\t%w") \
f(unify_string_op, "unify_string\t%S") f( \
write_string_op, \
"write_string\t%S") f(unify_bigint_op, \
"unify_bigint\t%" \
"l") f(write_bigint_op, \
"write_" \
"bigint\t%" \
"l") \
f(unify_list_op, "unify_list") f( \
write_list_op, \
"write_list") f(unify_struct_op, \
"unify_struct\t%f") \
f(write_struct_op, "write_struct\t%" \
"f") f( \
write_unsafe_op, \
"write_unsafe\t%v") f(unify_local_op, \
"unify_" \
"local\t%" \
"v") \
f(write_local_op, "write " \
"local\t%v") f( \
unify_last_list_op, \
"unify_last_list") \
f(write_last_list_op, "writ" \
"e_" \
"last" \
"_lis" \
"t") f( \
unify_last_struct_op, \
"unify_last_struct\t%f") \
f(write_last_struct_op, \
"write_last_struct\t%" \
"f") f(unify_last_var_op, \
"unify_last_" \
"var\t%v") \
f( \
unify_last_val_op, \
"unify_last_" \
"val\t%v") f(unify_last_local_op, \
"u" \
"n" \
"i" \
"f" \
"y" \
"_" \
"l" \
"a" \
"s" \
"t" \
"_" \
"l" \
"o" \
"c" \
"a" \
"l" \
"\t%v") f(unify_last_atom_op, \
"unify_last_atom\t%a") f(unify_last_num_op, "unify_last_num\t%n") f(unify_last_float_op, "unify_last_float\t%w") f(unify_last_dbterm_op, "unify_last_dbterm\t%w") f(unify_last_longint_op, "unify_last_longint\t%w") f(unify_last_string_op, "unify_last_string\t%S") f(unify_last_bigint_op, "unify_last_bigint\t%l") f(ensure_space_op, \
"ensure_space") f(native_op, \
"native_code") f(f_var_op, "function_to_var\t%v,%B") f(f_val_op, "function_to_val\t%v,%B") f(f_0_op, "function_to_0\t%B") f(align_float_op, \
"align_float") f(fail_op, "fail") f(cut_op, "cut") f(cutexit_op, \
"cutexit") f(allocate_op, \
"allocate") f(deallocate_op, \
"deallocate") f(tryme_op, \
"try_me_else\t\t%l\t%x") f(jump_op, \
"jump\t\t%l") f(jumpi_op, \
"jump_in_indexing\t\t%i") f(procceed_op, "proceed") f(call_op, "call\t\t%p,%d,%z") f(execute_op, "execute\t\t%p") f(safe_call_op, "sys\t\t%p") f(label_op, \
"%l:") f(name_op, "name\t\t%m,%d") f(pop_op, \
"pop\t\t%l") f(retryme_op, \
"retry_me_else\t\t%l\t%x") f(trustme_op, \
"trust_me_else_fail\t%x") f(either_op, "either_me\t\t%l,%d,%z") f(orelse_op, "or_else\t\t%l,%z") f(orlast_op, \
"or_last") f(push_or_op, "push_or") f(pushpop_or_op, "pushpop_or") f(pop_or_op, "pop_or") f(save_b_op, "save_by\t\t%v") f(commit_b_op, \
"commit_by\t\t%v") f(patch_b_op, "patch_by\t\t%v") f(try_op, \
"try\t\t%g\t%x") f(retry_op, "retry\t\t%g\t%x") f(trust_op, \
"trust\t\t%g\t%x") f(try_in_op, \
"try_in\t\t%g\t%x") f(jump_v_op, \
"jump_if_var\t\t%g") f(jump_nv_op, "jump_if_nonvar\t\t%g") f(cache_arg_op, "cache_arg\t%r") f(cache_sub_arg_op, "cache_sub_arg\t%d") f(user_switch_op, \
"user_switch") f(switch_on_type_op, "switch_on_type\t%h\t%h\t%h\t%h") f(switch_c_op, \
"switch_on_constant\t%i\n%c") f(if_c_op, \
"if_constant\t%i\n%c") f(switch_f_op, \
"switch_on_functor\t%i\n%e") f(if_f_op, "if_functor\t%i\n%e") f(if_not_op, "if_not_then\t%i\t%h\t%h\t%h") \
f(index_dbref_op, \
"index_on_" \
"dbref") f(index_blob_op, \
"i" \
"n" \
"d" \
"e" \
"x" \
"_" \
"o" \
"n" \
"_" \
"b" \
"l" \
"o" \
"b") f(index_string_op, "index_on_string") \
f(index_long_op, "index_on_blob") f( \
if_nonvar_op, \
"check_" \
"var\t " \
"%r") f(save_pair_op, "save_pair\t%v") \
f(save_appl_op, "save_appl\t%v") f( \
mark_initialized_pvars_op, \
"pv" \
"ar" \
"_b" \
"it" \
"ma" \
"p" \
"\t" \
"%l" \
",%" \
"b") f(mark_live_regs_op, \
"pvar_live_regs\t%l,%b") \
f(fetch_args_vv_op, "fetch_reg1_reg2\t%N,%N") f( \
fetch_args_cv_op, \
"fetch_constant_reg\t%l,%N") f(fetch_args_vc_op, \
"fetch_reg_constant\t%l,%N") \
f(fetch_args_iv_op, "fetch_integer_reg\t%d,%N") f( \
fetch_args_vi_op, \
"fetch_reg_integer\t%d,%N") f(enter_profiling_op, \
"enter_profiling\t\t%g") \
f(retry_profiled_op, "retry_profiled\t\t%g") f( \
count_call_op, \
"count_call_op\t\t%g") f(count_retry_op, \
"count_retry_op\t\t%g") \
f(restore_tmps_op, "restore_temps\t\t%l") f( \
restore_tmps_and_skip_op, \
"restore_temps_and_skip\t\t%l") \
f(enter_lu_op, "enter_lu") f( \
empty_call_op, \
"empty_call\t\t%l,%d") \
f(bccall_op, \
"binary_cfunc\t\t%v,%r,%2") \
f(blob_op, \
"blob\t%O") \
f(string_op, \
"string\t%O") \
f(label_ctl_op, \
"label_control\t")
#ifdef YAPOR
#define mklist1(f) mklist0(f) f(sync_op, "sync")
#else #else
#define mklist1(f) mklist0(f)
#define COMPILER_OPS() typedef enum compiler_op
#define COMPILER_OPS_END() compiler_vm_op
#define f(x,y) x
#endif
/* virtual machine instruction op-codes*/
COMPILER_OPS() {
f(nop_op, "nop"),
f(get_var_op, "get_var\t\t %v,%r"),
f(put_var_op, "put_var\t\t %v,%r"),
f( get_val_op, "get_val\t\t %v,%r"),
f(put_val_op, "put_val\t\t %v,%r"),
f(get_atom_op, "get_atom\t %a,%r"),
f(put_atom_op, "put_atom\t %a,%r"),
f(get_num_op, "get_num\t\t %n,%r"),
f(put_num_op, "put_num\t\t %n,%r"),
f( get_float_op, "get_float\t\t %w,%r"),
f(put_float_op, "put_float\t\t %w,%r"),
f(get_dbterm_op, "get_dbterm\t %w,%r"),
f(put_dbterm_op, "put_dbterm\t %w,%r"),
f(get_longint_op, "get_longint\t\t %w,%r"),
f( put_longint_op, "put_longint\t\t %w,%r"),
f(get_string_op, "get_string\t\t %w,%S"),
f(put_string_op, "put_string\t\t %w,%S"),
f(get_bigint_op, "get_bigint\t\t %l,%r"),
f(put_bigint_op, "put_bigint\t\t %l,%r"),
f( get_list_op, "get_list\t %r"),
f(put_list_op, "put_list\t %r"),
f(get_struct_op, "get_struct\t %f,%r"),
f(put_struct_op, "put_struct\t %f,%r"),
f(put_unsafe_op, "put_unsafe\t %v,%r"),
f( unify_var_op, "unify_var\t %v"),
f(write_var_op, "write_var\t %v"),
f(unify_val_op, "unify_val\t %v"),
f(write_val_op, "write_val\t %v"),
f(unify_atom_op, "unify_atom\t %a"),
f( write_atom_op, "write_atom\t %a"),
f(unify_num_op, "unify_num\t %n"),
f(write_num_op, "write_num\t %n"),
f(unify_float_op, "unify_float\t %w"),
f( write_float_op, "write_float\t %w"),
f(unify_dbterm_op, "unify_dbterm\t %w"),
f(write_dbterm_op, "write_dbterm\t %w"),
f( unify_longint_op, "unify_longint\t %w"),
f(write_longint_op, "write_longint\t %w"),
f(unify_string_op, "unify_string\t %S"),
f( write_string_op, "write_string\t %S"),
f(unify_bigint_op, "unify_bigint\t %l"),
f(write_bigint_op, "write_bigint\t %l"),
f(unify_list_op, "unify_list"),
f( write_list_op, "write_list"),
f(unify_struct_op, "unify_struct\t %f"),
f(write_struct_op, "write_struct\t %f"),
f( write_unsafe_op, "write_unsafe\t %v"),
f(unify_local_op, "unify_local\t %v"),
f(write_local_op, "write local\t %v"),
f( unify_last_list_op, "unify_last_list"),
f(write_last_list_op, "write_last_list"),
f( unify_last_struct_op, "unify_last_struct\t %f"),
f(write_last_struct_op, "write_last_struct\t %f"),
f(unify_last_var_op, "unify_last_var\t %v"),
f( unify_last_val_op, "unify_last_val\t %v"),
f(unify_last_local_op, "unify_last_local\t %v"),
f(unify_last_atom_op, "unify_last_atom\t %a"),
f(unify_last_num_op, "unify_last_num\t %n"),
f(unify_last_float_op, "unify_last_float\t %w"),
f(unify_last_dbterm_op, "unify_last_dbterm\t %w"),
f(unify_last_longint_op, "unify_last_longint\t %w"),
f(unify_last_string_op, "unify_last_string\t %S"),
f(unify_last_bigint_op, "unify_last_bigint\t %l"),
f(ensure_space_op, "ensure_space"),
f(native_op, "native_code"),
f(f_var_op, "function_to_var\t %v,%B"),
f(f_val_op, "function_to_val\t %v,%B"),
f(f_0_op, "function_to_0\t %B"),
f(align_float_op, "align_float"),
f(fail_op, "fail"),
f(cut_op, "cut"),
f(cutexit_op, "cutexit"),
f(allocate_op, "allocate"),
f(deallocate_op, "deallocate"),
f(tryme_op, "try_me_else\t\t %l\t %x"),
f(jump_op, "jump\t\t %l"),
f(jumpi_op, "jump_in_indexing\t\t %i"),
f(procceed_op, "proceed"),
f(call_op, "call\t\t %p,%d,%z"),
f(execute_op, "execute\t\t %p"),
f(safe_call_op, "sys\t\t %p"),
f(label_op, "%l:"),
f(name_op, "name\t\t %m,%d"),
f(pop_op, "pop\t\t %l"),
f(retryme_op, "retry_me_else\t\t %l\t %x"),
f(trustme_op, "trust_me_else_fail\t %x"),
f(either_op, "either_me\t\t %l,%d,%z"),
f(orelse_op, "or_else\t\t %l,%z"),
f(orlast_op, "or_last"),
f(push_or_op, "push_or"),
f(pushpop_or_op, "pushpop_or"),
f(pop_or_op, "pop_or"),
f(save_b_op, "save_by\t\t %v"),
f(commit_b_op, "commit_by\t\t %v"),
f(patch_b_op, "patch_by\t\t %v"),
f(try_op, "try\t\t %g\t %x"),
f(retry_op, "retry\t\t %g\t %x"),
f(trust_op, "trust\t\t %g\t %x"),
f(try_in_op, "try_in\t\t %g\t %x"),
f(jump_v_op, "jump_if_var\t\t %g"),
f(jump_nv_op, "jump_if_nonvar\t\t %g"),
f(cache_arg_op, "cache_arg\t %r"),
f(cache_sub_arg_op, "cache_sub_arg\t %d"),
f(user_switch_op, "user_switch"),
f(switch_on_type_op, "switch_on_type\t %h\t %h\t %h\t %h"),
f(switch_c_op, "switch_on_constant\t %i,n%c"),
f(if_c_op, "if_constant\t %i,n%c"),
f(switch_f_op, "switch_on_functor\t %i,n%e"),
f(if_f_op, "if_functor\t %i,n%e"),
f(if_not_op, "if_not_then\t %i\t %h\t %h\t %h"),
f(index_dbref_op, "index_on_dbref"),
f(index_blob_op, "index_on_blob"),
f(index_string_op, "index_on_string"),
f(index_long_op, "index_on_blob"),
f( if_nonvar_op, "check_var\t %r"),
f(save_pair_op, "save_pair\t %v"),
f(save_appl_op, "save_appl\t %v"),
f( mark_initialized_pvars_op, "pvar_bitmap\t %l,%b"),
f(mark_live_regs_op, "pvar_live_regs\t %l,%b"),
f(fetch_args_vv_op, "fetch_reg1_reg2\t %N,%N"),
f( fetch_args_cv_op, "fetch_constant_reg\t %l,%N"),
f(fetch_args_vc_op, "fetch_reg_constant\t %l,%N"),
f(fetch_args_iv_op, "fetch_integer_reg\t %d,%N"),
f( fetch_args_vi_op, "fetch_reg_integer\t %d,%N"),
f(enter_profiling_op, "enter_profiling\t\t %g"),
f(retry_profiled_op, "retry_profiled\t\t %g"),
f( count_call_op, "count_call_op\t\t %g"),
f(count_retry_op, "count_retry_op\t\t %g"),
f(restore_tmps_op, "restore_temps\t\t %l"),
f( restore_tmps_and_skip_op, "restore_temps_and_skip\t\t %l"),
f(enter_lu_op, "enter_lu"),
f( empty_call_op, "empty_call\t\t %l,%d"),
f(bccall_op, "binary_cfunc\t\t %v,%r,%2"),
f(blob_op, "blob\t %O"),
f(string_op, "string\t %O"),
f(label_ctl_op, "label_control\t"),
#ifdef YAPOR
f(sync_op, "sync"),
#endif /* YAPOR */ #endif /* YAPOR */
#ifdef TABLING #ifdef TABLING
#define mklist2(f) \ f(table_new_answer_op, "table_new_answer"),
mklist1(f) f(table_new_answer_op, "table_new_answer") \ f(table_try_single_op, "table_try_single\t %g\t %x"),
f(table_try_single_op, "table_try_single\t%g\t%x")
#else
#define mklist2(f) mklist1(f)
#endif /* TABLING */
#ifdef TABLING_INNER_CUTS #ifdef TABLING_INNER_CUTS
#define mklist3(f) mklist2(f) f(clause_with_cut_op, "clause_with_cut") f(clause_with_cut_op, "clause_with_cut"),
#else
#define mklist3(f) mklist2(f)
#endif /* TABLING_INNER_CUTS */ #endif /* TABLING_INNER_CUTS */
#endif
#ifdef BEAM #ifdef BEAM
#define mklist4(f) \ f(run_op, "run_op %1,%4"),
mklist3(f) f(run_op, "run_op %1,%4") f(body_op, "body_op %1") f( \ f(body_op, "body_op %1"),
endgoal_op, "endgoal_op") f(try_me_op, "try_me_op %1,%4") \ f( endgoal_op, "endgoal_op"),
f(retry_me_op, "retry_me_op %1,%4") f(trust_me_op, "trust_me_op %1,%4") \ f(try_me_op, "try_me_op %1,%4"),
f(only_1_clause_op, "only_1_clause_op %1,%4") f( \ f(retry_me_op, "retry_me_op %1,%4"),
create_first_box_op, "create_first_box_op %1,%4") \ f(trust_me_op, "trust_me_op %1,%4"),
f(create_box_op, "create_box_op %1,%4") f( \ f(only_1_clause_op, "only_1_clause_op %1,%4"),
create_last_box_op, "create_last_box_op %1,%4") \ f( create_first_box_op, "create_first_box_op %1,%4"),
f(remove_box_op, "remove_box_op %1,%4") f( \ f(create_box_op, "create_box_op %1,%4"),
remove_last_box_op, "remove_last_box_op %1,%4") \ f( create_last_box_op, "create_last_box_op %1,%4"),
f(prepare_tries, "prepare_tries") f(std_base_op, \ f(remove_box_op, "remove_box_op %1,%4"),
"std_base_op %1,%4") \ f( remove_last_box_op, "remove_last_box_op %1,%4"),
f(direct_safe_call_op, "direct_safe_call") \ f(prepare_tries, "prepare_tries"),
f(commit_op, ) f(skip_while_var_op, \ f(std_base_op, "std_base_op %1,%4"),
"skip_while_var_op") \ f(direct_safe_call_op, "direct_safe_call"),
f(wait_while_var_op, "wait_while_var_op") \ f(commit_op, ),
f(force_wait_op, "force_wait_op") \ f(skip_while_var_op, "skip_while_var_op"),
f(is_op, "is_op") \ f(wait_while_var_op, "wait_while_var_op"),
f(write_op, "write_op") \ f(force_wait_op, "force_wait_op"),
f(equal_op, "equal_op") \ f(is_op, "is_op"),
f(exit_op, "exit") f(write_op, "write_op"),
#else f(equal_op, "equal_op"),
#define mklist4(f) mklist3(f) f(exit_op, "exit"),
#endif #endif
#ifdef SFUNC #ifdef SFUNC
#define mklist(f) \ f(get_s_f_op, "get_s_f_op\t %f,%r"),
mklist4(f) f(get_s_f_op, "get_s_f_op\t%f,%r") \ f(put_s_f_op, "put_s_f_op\t %f,%r"),
f(put_s_f_op, "put_s_f_op\t%f,%r") f(unify_s_f_op, "unify_s_f_op\t%f") \ f(unify_s_f_op, "unify_s_f_op\t %f"),
f(write_s_f_op, "write_s_f_op\t%f") \ f(write_s_f_op, "write_s_f_op\t %f"),
f(unify_s_var_op, "unify_s_var\t%v,%r") f(write_s_var_op, \ f(unify_s_var_op, "unify_s_var\t %v,%r"),
"write_s_var\t%v,%r") \ f(write_s_var_op, "write_s_var\t %v,%r"),
f(unify_s_val_op, "unify_s_val\t%v,%r") \ f(unify_s_val_op, "unify_s_val\t %v,%r"),
f(write_s_val_op, "write_s_val\t%v,%r") \ f(write_s_val_op, "write_s_val\t %v,%r"),
f(unify_s_a_op, "unify_s_a\t%a,%r") \ f(unify_s_a_op, "unify_s_a\t %a,%r"),
f(write_s_a_op, "write_s_a\t%a,%r") \ f(write_s_a_op, "write_s_a\t %a,%r"),
f(get_s_end_op, "get_s_end") \ f(get_s_end_op, "get_s_end"),
f(put_s_end_op, "put_s_end") \ f(put_s_end_op, "put_s_end"),
f(unify_s_end_op, "unify_s_end") \ f(unify_s_end_op, "unify_s_end"),
f(write_s_end_op, "write_s_end") f(write_s_end_op, "write_s_end"),
#else
#define mklist(f) mklist4(f)
#endif #endif
} COMPILER_OPS_END();
#define f_enum(x, y) x, #ifndef COMPILER_NAMES
#define f_arr(x, y) y,
enum compiler_op { mklist(f_enum) };
typedef enum compiler_op compiler_vm_op;
typedef struct PSEUDO { typedef struct PSEUDO {
struct PSEUDO *nextInst; struct PSEUDO *nextInst;
@ -415,23 +355,20 @@ typedef enum special_label_op_enum {
#define One 1 #define One 1
#define Two 2 #define Two 2
extern yamop *Yap_assemble(int, Term, struct pred_entry *, int, extern yamop *Yap_assemble(int, Term, struct pred_entry *, int, struct intermediates *, UInt);
struct intermediates *, UInt); extern void Yap_emit(compiler_vm_op, Int, CELL, struct intermediates *);
void Yap_emit(compiler_vm_op, Int, CELL, struct intermediates *); extern void Yap_emit_3ops(compiler_vm_op, CELL, CELL, CELL, struct intermediates *);
void Yap_emit_3ops(compiler_vm_op, CELL, CELL, CELL, struct intermediates *); extern void Yap_emit_4ops(compiler_vm_op, CELL, CELL, CELL, CELL, struct intermediates *);
void Yap_emit_4ops(compiler_vm_op, CELL, CELL, CELL, CELL, extern void Yap_emit_5ops(compiler_vm_op, CELL, CELL, CELL, CELL, CELL,struct intermediates *);
struct intermediates *); extern void Yap_emit_6ops(compiler_vm_op, CELL, CELL, CELL, CELL, CELL, CELL,struct intermediates *);
void Yap_emit_5ops(compiler_vm_op, CELL, CELL, CELL, CELL, CELL, extern void Yap_emit_7ops(compiler_vm_op, CELL, CELL, CELL, CELL, CELL, CELL, CELL, struct intermediates *);
struct intermediates *); extern CELL *Yap_emit_extra_size(compiler_vm_op, CELL, int, struct intermediates *);
void Yap_emit_6ops(compiler_vm_op, CELL, CELL, CELL, CELL, CELL, CELL, extern char *Yap_AllocCMem(UInt, struct intermediates *);
struct intermediates *); extern void Yap_ReleaseCMem(struct intermediates *);
void Yap_emit_7ops(compiler_vm_op, CELL, CELL, CELL, CELL, CELL, CELL, CELL, extern int Yap_is_a_test_pred(Term, Term);
struct intermediates *); extern void Yap_bip_name(Int, char *);
CELL *Yap_emit_extra_size(compiler_vm_op, CELL, int, struct intermediates *);
char *Yap_AllocCMem(UInt, struct intermediates *);
void Yap_ReleaseCMem(struct intermediates *);
int Yap_is_a_test_pred(Term, Term);
void Yap_bip_name(Int, char *);
#ifdef DEBUG #ifdef DEBUG
void Yap_ShowCode(struct intermediates *); extern void Yap_ShowCode(struct intermediates *);
#endif /* DEBUG */ #endif /* DEBUG */
#endif

296
H/YapOpcodes.h
View File

@ -6,6 +6,26 @@
OPCODE(Nstop ,e), OPCODE(Nstop ,e),
#ifdef YAP_JIT #ifdef YAP_JIT
OPCODE(jit_handler ,J), OPCODE(jit_handler ,J),
#endif
OPCODE(cut ,s),
OPCODE(cut_t ,s),
OPCODE(cut_e ,s),
OPCODE(save_b_x ,x),
OPCODE(save_b_y ,y),
OPCODE(commit_b_x ,xps),
OPCODE(commit_b_y ,yps),
OPCODE(execute ,Osbpp),
OPCODE(dexecute ,Osbpp),
OPCODE(fcall ,Osbpp),
OPCODE(call ,Osbpp),
OPCODE(procceed ,p),
OPCODE(allocate ,e),
OPCODE(deallocate ,p),
#ifdef BEAM
OPCODE(retry_eam ,e),
#endif
#ifdef BEAM
OPCODE(run_eam ,os),
#endif #endif
OPCODE(try_me ,Otapl), OPCODE(try_me ,Otapl),
OPCODE(retry_me ,Otapl), OPCODE(retry_me ,Otapl),
@ -43,6 +63,44 @@
OPCODE(retry4 ,l), OPCODE(retry4 ,l),
OPCODE(trust ,Otapl), OPCODE(trust ,Otapl),
OPCODE(try_in ,l), OPCODE(try_in ,l),
OPCODE(trust_fail ,e),
OPCODE(op_fail ,e),
OPCODE(call_cpred ,Osbpp),
OPCODE(execute_cpred ,Osbpp),
OPCODE(call_usercpred ,Osbpp),
OPCODE(call_c_wfail ,slpp),
OPCODE(try_c ,OtapFs),
OPCODE(retry_c ,OtapFs),
OPCODE(cut_c ,OtapFs),
OPCODE(try_userc ,OtapFs),
OPCODE(retry_userc ,OtapFs),
OPCODE(cut_userc ,OtapFs),
OPCODE(lock_pred ,e),
OPCODE(index_pred ,e),
#ifdef THREADS
OPCODE(thread_local ,e),
#endif
OPCODE(expand_index ,e),
OPCODE(expand_clauses ,sssllp),
OPCODE(undef_p ,e),
OPCODE(spy_pred ,e),
OPCODE(user_switch ,lp),
OPCODE(switch_on_type ,llll),
OPCODE(switch_list_nl ,ollll),
OPCODE(switch_on_arg_type ,xllll),
OPCODE(switch_on_sub_arg_type ,sllll),
OPCODE(jump_if_var ,l),
OPCODE(jump_if_nonvar ,xll),
OPCODE(if_not_then ,clll),
OPCODE(switch_on_func ,sssl),
OPCODE(switch_on_cons ,sssl),
OPCODE(go_on_func ,sssl),
OPCODE(go_on_cons ,sssl),
OPCODE(if_func ,sssl),
OPCODE(if_cons ,sssl),
OPCODE(index_dbref ,e),
OPCODE(index_blob ,e),
OPCODE(index_long ,e),
OPCODE(enter_lu_pred ,Illss), OPCODE(enter_lu_pred ,Illss),
OPCODE(profiled_retry_logical ,OtaLl), OPCODE(profiled_retry_logical ,OtaLl),
OPCODE(profiled_trust_logical ,OtILl), OPCODE(profiled_trust_logical ,OtILl),
@ -56,28 +114,94 @@
OPCODE(alloc_for_logical_pred ,L), OPCODE(alloc_for_logical_pred ,L),
OPCODE(copy_idb_term ,e), OPCODE(copy_idb_term ,e),
OPCODE(unify_idb_term ,e), OPCODE(unify_idb_term ,e),
OPCODE(trust_fail ,e), OPCODE(p_execute_tail ,Osbmp),
OPCODE(op_fail ,e), OPCODE(p_execute2 ,Osbpp),
OPCODE(cut ,s), OPCODE(p_execute ,Osbmp),
OPCODE(cut_t ,s), OPCODE(jump ,l),
OPCODE(cut_e ,s), OPCODE(move_back ,l),
OPCODE(save_b_x ,x), OPCODE(skip ,l),
OPCODE(save_b_y ,y), OPCODE(either ,Osblp),
OPCODE(commit_b_x ,xps), OPCODE(or_else ,Osblp),
OPCODE(commit_b_y ,yps), OPCODE(pop_n ,s),
OPCODE(execute ,pp), OPCODE(pop ,e),
OPCODE(dexecute ,pp), OPCODE(p_plus_vv ,xxx),
OPCODE(fcall ,Osbpp), OPCODE(p_plus_vc ,xxn),
OPCODE(call ,Osbpp), OPCODE(p_plus_y_vv ,yxx),
OPCODE(procceed ,p), OPCODE(p_plus_y_vc ,yxn),
OPCODE(allocate ,e), OPCODE(p_minus_vv ,xxx),
OPCODE(deallocate ,p), OPCODE(p_minus_cv ,xxn),
#ifdef BEAM OPCODE(p_minus_y_vv ,yxx),
OPCODE(retry_eam ,e), OPCODE(p_minus_y_cv ,yxn),
#endif OPCODE(p_times_vv ,xxx),
#ifdef BEAM OPCODE(p_times_vc ,xxn),
OPCODE(run_eam ,os), OPCODE(p_times_y_vv ,yxx),
#endif OPCODE(p_times_y_vc ,yxn),
OPCODE(p_div_vv ,xxx),
OPCODE(p_div_vc ,xxn),
OPCODE(p_div_cv ,xxn),
OPCODE(p_div_y_vv ,yxx),
OPCODE(p_div_y_vc ,yxn),
OPCODE(p_div_y_cv ,yxn),
OPCODE(p_and_vv ,xxx),
OPCODE(p_and_vc ,xxn),
OPCODE(p_and_y_vv ,yxx),
OPCODE(p_and_y_vc ,yxn),
OPCODE(p_or_vv ,xxx),
OPCODE(p_or_vc ,xxn),
OPCODE(p_or_y_vv ,yxx),
OPCODE(p_or_y_vc ,yxn),
OPCODE(p_sll_vv ,xxx),
OPCODE(p_sll_vc ,xxn),
OPCODE(p_sll_cv ,xxn),
OPCODE(p_sll_y_vv ,yxx),
OPCODE(p_sll_y_vc ,yxn),
OPCODE(p_sll_y_cv ,yxn),
OPCODE(p_slr_vv ,xxx),
OPCODE(p_slr_vc ,xxn),
OPCODE(p_slr_cv ,xxn),
OPCODE(p_slr_y_vv ,yxx),
OPCODE(p_slr_y_vc ,yxn),
OPCODE(p_slr_y_cv ,yxn),
OPCODE(call_bfunc_xx ,plxxs),
OPCODE(call_bfunc_yx ,plxys),
OPCODE(call_bfunc_xy ,plxys),
OPCODE(call_bfunc_yy ,plyys),
OPCODE(p_equal ,e),
OPCODE(p_arg_vv ,xxx),
OPCODE(p_arg_cv ,xxn),
OPCODE(p_arg_y_vv ,yxx),
OPCODE(p_arg_y_cv ,yxn),
OPCODE(p_func2s_vv ,xxx),
OPCODE(p_func2s_cv ,xxc),
OPCODE(p_func2s_vc ,xxn),
OPCODE(p_func2s_y_vv ,yxx),
OPCODE(p_func2s_y_cv ,yxc),
OPCODE(p_func2s_y_vc ,yxn),
OPCODE(p_func2f_xx ,xxx),
OPCODE(p_func2f_xy ,xxy),
OPCODE(p_func2f_yx ,yxx),
OPCODE(p_func2f_yy ,yyx),
OPCODE(p_functor ,e),
OPCODE(p_atom_x ,xl),
OPCODE(p_atom_y ,yl),
OPCODE(p_atomic_x ,xl),
OPCODE(p_atomic_y ,yl),
OPCODE(p_integer_x ,xl),
OPCODE(p_integer_y ,yl),
OPCODE(p_nonvar_x ,xl),
OPCODE(p_nonvar_y ,yl),
OPCODE(p_number_x ,xl),
OPCODE(p_number_y ,yl),
OPCODE(p_var_x ,xl),
OPCODE(p_var_y ,yl),
OPCODE(p_db_ref_x ,xl),
OPCODE(p_db_ref_y ,yl),
OPCODE(p_primitive_x ,xl),
OPCODE(p_primitive_y ,yl),
OPCODE(p_compound_x ,xl),
OPCODE(p_compound_y ,yl),
OPCODE(p_float_x ,xl),
OPCODE(p_float_y ,yl),
OPCODE(get_x_var ,xx), OPCODE(get_x_var ,xx),
OPCODE(get_y_var ,yx), OPCODE(get_y_var ,yx),
OPCODE(get_yy_var ,yyxx), OPCODE(get_yy_var ,yyxx),
@ -207,134 +331,6 @@
OPCODE(save_appl_x_write ,ox), OPCODE(save_appl_x_write ,ox),
OPCODE(save_appl_y ,oy), OPCODE(save_appl_y ,oy),
OPCODE(save_appl_y_write ,oy), OPCODE(save_appl_y_write ,oy),
OPCODE(call_cpred ,Osbpp),
OPCODE(execute_cpred ,pp),
OPCODE(call_usercpred ,Osbpp),
OPCODE(call_c_wfail ,slpp),
OPCODE(try_c ,OtapFs),
OPCODE(retry_c ,OtapFs),
OPCODE(cut_c ,OtapFs),
OPCODE(try_userc ,OtapFs),
OPCODE(retry_userc ,OtapFs),
OPCODE(cut_userc ,OtapFs),
OPCODE(lock_pred ,e),
OPCODE(index_pred ,e),
#ifdef THREADS
OPCODE(thread_local ,e),
#endif
OPCODE(expand_index ,e),
OPCODE(expand_clauses ,sssllp),
OPCODE(undef_p ,e),
OPCODE(spy_pred ,e),
OPCODE(jump ,l),
OPCODE(move_back ,l),
OPCODE(skip ,l),
OPCODE(either ,Osblp),
OPCODE(or_else ,Osblp),
OPCODE(pop_n ,s),
OPCODE(pop ,e),
OPCODE(user_switch ,lp),
OPCODE(switch_on_type ,llll),
OPCODE(switch_list_nl ,ollll),
OPCODE(switch_on_arg_type ,xllll),
OPCODE(switch_on_sub_arg_type ,sllll),
OPCODE(jump_if_var ,l),
OPCODE(jump_if_nonvar ,xll),
OPCODE(if_not_then ,clll),
OPCODE(switch_on_func ,sssl),
OPCODE(switch_on_cons ,sssl),
OPCODE(go_on_func ,sssl),
OPCODE(go_on_cons ,sssl),
OPCODE(if_func ,sssl),
OPCODE(if_cons ,sssl),
OPCODE(index_dbref ,e),
OPCODE(index_blob ,e),
OPCODE(index_long ,e),
OPCODE(p_atom_x ,xl),
OPCODE(p_atom_y ,yl),
OPCODE(p_atomic_x ,xl),
OPCODE(p_atomic_y ,yl),
OPCODE(p_integer_x ,xl),
OPCODE(p_integer_y ,yl),
OPCODE(p_nonvar_x ,xl),
OPCODE(p_nonvar_y ,yl),
OPCODE(p_number_x ,xl),
OPCODE(p_number_y ,yl),
OPCODE(p_var_x ,xl),
OPCODE(p_var_y ,yl),
OPCODE(p_db_ref_x ,xl),
OPCODE(p_db_ref_y ,yl),
OPCODE(p_primitive_x ,xl),
OPCODE(p_primitive_y ,yl),
OPCODE(p_compound_x ,xl),
OPCODE(p_compound_y ,yl),
OPCODE(p_float_x ,xl),
OPCODE(p_float_y ,yl),
OPCODE(p_plus_vv ,xxx),
OPCODE(p_plus_vc ,xxn),
OPCODE(p_plus_y_vv ,yxx),
OPCODE(p_plus_y_vc ,yxn),
OPCODE(p_minus_vv ,xxx),
OPCODE(p_minus_cv ,xxn),
OPCODE(p_minus_y_vv ,yxx),
OPCODE(p_minus_y_cv ,yxn),
OPCODE(p_times_vv ,xxx),
OPCODE(p_times_vc ,xxn),
OPCODE(p_times_y_vv ,yxx),
OPCODE(p_times_y_vc ,yxn),
OPCODE(p_div_vv ,xxx),
OPCODE(p_div_vc ,xxn),
OPCODE(p_div_cv ,xxn),
OPCODE(p_div_y_vv ,yxx),
OPCODE(p_div_y_vc ,yxn),
OPCODE(p_div_y_cv ,yxn),
OPCODE(p_and_vv ,xxx),
OPCODE(p_and_vc ,xxn),
OPCODE(p_and_y_vv ,yxx),
OPCODE(p_and_y_vc ,yxn),
OPCODE(p_or_vv ,xxx),
OPCODE(p_or_vc ,xxn),
OPCODE(p_or_y_vv ,yxx),
OPCODE(p_or_y_vc ,yxn),
OPCODE(p_sll_vv ,xxx),
OPCODE(p_sll_vc ,xxn),
OPCODE(p_sll_cv ,xxn),
OPCODE(p_sll_y_vv ,yxx),
OPCODE(p_sll_y_vc ,yxn),
OPCODE(p_sll_y_cv ,yxn),
OPCODE(p_slr_vv ,xxx),
OPCODE(p_slr_vc ,xxn),
OPCODE(p_slr_cv ,xxn),
OPCODE(p_slr_y_vv ,yxx),
OPCODE(p_slr_y_vc ,yxn),
OPCODE(p_slr_y_cv ,yxn),
OPCODE(call_bfunc_xx ,plxxs),
OPCODE(call_bfunc_yx ,plxys),
OPCODE(call_bfunc_xy ,plxys),
OPCODE(call_bfunc_yy ,plyys),
OPCODE(p_equal ,e),
#if INLINE_BIG_COMPARISONS
OPCODE(p_dif ,l),
OPCODE(p_eq ,l),
#endif
OPCODE(p_arg_vv ,xxx),
OPCODE(p_arg_cv ,xxn),
OPCODE(p_arg_y_vv ,yxx),
OPCODE(p_arg_y_cv ,yxn),
OPCODE(p_func2s_vv ,xxx),
OPCODE(p_func2s_cv ,xxc),
OPCODE(p_func2s_vc ,xxn),
OPCODE(p_func2s_y_vv ,yxx),
OPCODE(p_func2s_y_cv ,yxc),
OPCODE(p_func2s_y_vc ,yxn),
OPCODE(p_func2f_xx ,xxx),
OPCODE(p_func2f_xy ,xxy),
OPCODE(p_func2f_yx ,yxx),
OPCODE(p_func2f_yy ,yyx),
OPCODE(p_functor ,e),
OPCODE(p_execute_tail ,Osbmp),
OPCODE(p_execute2 ,Osbpp),
OPCODE(p_execute ,Osbmp),
#ifdef YAPOR #ifdef YAPOR
OPCODE(getwork_first_time ,e), OPCODE(getwork_first_time ,e),
OPCODE(getwork ,Otapl), OPCODE(getwork ,Otapl),

5
H/amidefs.h
View File

@ -557,11 +557,6 @@ typedef struct yami {
struct pred_entry *p; struct pred_entry *p;
CELL next; CELL next;
} p; } p;
struct {
struct pred_entry *p;
struct pred_entry *p0;
CELL next;
} pp;
struct { struct {
COUNT s; COUNT s;
CELL next; CELL next;

4
H/rclause.h
View File

@ -255,10 +255,6 @@ restore_opcodes(yamop *pc, yamop *max USES_REGS)
case _jump: case _jump:
case _jump_if_var: case _jump_if_var:
case _move_back: case _move_back:
#if INLINE_BIG_COMPARISONS
case _p_dif:
case _p_eq:
#endif
case _retry2: case _retry2:
case _retry3: case _retry3:
case _retry4: case _retry4:

13
H/saveclause.h
View File

@ -78,6 +78,9 @@
case _call: case _call:
case _call_cpred: case _call_cpred:
case _call_usercpred: case _call_usercpred:
case _dexecute:
case _execute:
case _execute_cpred:
case _fcall: case _fcall:
case _p_execute2: case _p_execute2:
#ifdef YAPOR #ifdef YAPOR
@ -273,8 +276,6 @@
case _jump: case _jump:
case _jump_if_var: case _jump_if_var:
case _move_back: case _move_back:
case _p_dif:
case _p_eq:
case _retry2: case _retry2:
case _retry3: case _retry3:
case _retry4: case _retry4:
@ -498,14 +499,6 @@
CHECK(save_Constant(stream, pc->y_u.plyys.flags)); CHECK(save_Constant(stream, pc->y_u.plyys.flags));
pc = NEXTOP(pc,plyys); pc = NEXTOP(pc,plyys);
break; break;
/* instructions type pp */
case _dexecute:
case _execute:
case _execute_cpred:
CHECK(save_PtoPred(stream, pc->y_u.pp.p));
CHECK(save_PtoPred(stream, pc->y_u.pp.p0));
pc = NEXTOP(pc,pp);
break;
/* instructions type s */ /* instructions type s */
case _cut: case _cut:
case _cut_e: case _cut_e:

201
H/walkclause.h
View File

@ -1,7 +1,9 @@
/* This file was generated automatically by "yap -L misc/buildops"
/* This file was generated automatically by "yap -L misc/buildops"
please do not update */ please do not update */
while (TRUE) {
while (TRUE) {
op_numbers op; op_numbers op;
op = Yap_op_from_opcode(pc->opc); op = Yap_op_from_opcode(pc->opc);
@ -9,39 +11,39 @@ while (TRUE) {
switch (op) { switch (op) {
/* instructions type D */ /* instructions type D */
case _write_dbterm: case _write_dbterm:
pc = NEXTOP(pc, D); pc = NEXTOP(pc,D);
break; break;
/* instructions type Illss */ /* instructions type Illss */
case _enter_lu_pred: case _enter_lu_pred:
return walk_got_lu_block(pc->y_u.Illss.I, startp, endp); return walk_got_lu_block(pc->y_u.Illss.I, startp, endp);
/* instructions type J */ /* instructions type J */
#ifdef YAP_JIT #ifdef YAP_JIT
case _jit_handler: case _jit_handler:
#endif #endif
pc = NEXTOP(pc, J); pc = NEXTOP(pc,J);
break; break;
/* instructions type L */ /* instructions type L */
case _alloc_for_logical_pred: case _alloc_for_logical_pred:
return walk_got_lu_clause(pc->y_u.L.ClBase, startp, endp); return walk_got_lu_clause(pc->y_u.L.ClBase, startp, endp);
/* instructions type N */ /* instructions type N */
case _write_bigint: case _write_bigint:
pc = NEXTOP(pc, N); pc = NEXTOP(pc,N);
break; break;
/* instructions type Osblp */ /* instructions type Osblp */
case _either: case _either:
case _or_else: case _or_else:
clause_code = TRUE; clause_code = TRUE;
pp = pc->y_u.Osblp.p0; pp = pc->y_u.Osblp.p0;
pc = NEXTOP(pc, Osblp); pc = NEXTOP(pc,Osblp);
break; break;
/* instructions type Osbmp */ /* instructions type Osbmp */
case _p_execute: case _p_execute:
case _p_execute_tail: case _p_execute_tail:
pc = NEXTOP(pc, Osbmp); pc = NEXTOP(pc,Osbmp);
break; break;
/* instructions type Osbpa */ /* instructions type Osbpa */
case _ensure_space: case _ensure_space:
pc = NEXTOP(pc, Osbpa); pc = NEXTOP(pc,Osbpa);
break; break;
/* instructions type Osbpp */ /* instructions type Osbpp */
case _call_cpred: case _call_cpred:
@ -50,13 +52,18 @@ while (TRUE) {
case _call_usercpred: case _call_usercpred:
pp = pc->y_u.Osbpp.p; pp = pc->y_u.Osbpp.p;
return walk_found_c_pred(pp, startp, endp); return walk_found_c_pred(pp, startp, endp);
case _execute_cpred:
pp = pc->y_u.Osbpp.p;
return walk_found_c_pred(pp, startp, endp);
case _p_execute2: case _p_execute2:
return found_meta_call(startp, endp); return found_meta_call(startp, endp);
case _call: case _call:
case _dexecute:
case _execute:
case _fcall: case _fcall:
clause_code = TRUE; clause_code = TRUE;
pp = pc->y_u.Osbpp.p0; pp = pc->y_u.Osbpp.p0;
pc = NEXTOP(pc, Osbpp); pc = NEXTOP(pc,Osbpp);
break; break;
/* instructions type OtILl */ /* instructions type OtILl */
case _count_trust_logical: case _count_trust_logical:
@ -79,7 +86,7 @@ while (TRUE) {
case _try_userc: case _try_userc:
clause_code = TRUE; clause_code = TRUE;
pp = pc->y_u.OtapFs.p; pp = pc->y_u.OtapFs.p;
pc = NEXTOP(pc, OtapFs); pc = NEXTOP(pc,OtapFs);
break; break;
/* instructions type Otapl */ /* instructions type Otapl */
case _count_retry_and_mark: case _count_retry_and_mark:
@ -99,39 +106,39 @@ while (TRUE) {
case _try_me: case _try_me:
clause_code = FALSE; clause_code = FALSE;
pp = pc->y_u.Otapl.p; pp = pc->y_u.Otapl.p;
pc = NEXTOP(pc, Otapl); pc = NEXTOP(pc,Otapl);
break; break;
/* instructions type c */ /* instructions type c */
case _write_atom: case _write_atom:
pc = NEXTOP(pc, c); pc = NEXTOP(pc,c);
break; break;
/* instructions type cc */ /* instructions type cc */
case _get_2atoms: case _get_2atoms:
pc = NEXTOP(pc, cc); pc = NEXTOP(pc,cc);
break; break;
/* instructions type ccc */ /* instructions type ccc */
case _get_3atoms: case _get_3atoms:
pc = NEXTOP(pc, ccc); pc = NEXTOP(pc,ccc);
break; break;
/* instructions type cccc */ /* instructions type cccc */
case _get_4atoms: case _get_4atoms:
pc = NEXTOP(pc, cccc); pc = NEXTOP(pc,cccc);
break; break;
/* instructions type ccccc */ /* instructions type ccccc */
case _get_5atoms: case _get_5atoms:
pc = NEXTOP(pc, ccccc); pc = NEXTOP(pc,ccccc);
break; break;
/* instructions type cccccc */ /* instructions type cccccc */
case _get_6atoms: case _get_6atoms:
pc = NEXTOP(pc, cccccc); pc = NEXTOP(pc,cccccc);
break; break;
/* instructions type clll */ /* instructions type clll */
case _if_not_then: case _if_not_then:
pc = NEXTOP(pc, clll); pc = NEXTOP(pc,clll);
break; break;
/* instructions type d */ /* instructions type d */
case _write_float: case _write_float:
pc = NEXTOP(pc, d); pc = NEXTOP(pc,d);
break; break;
/* instructions type e */ /* instructions type e */
case _Nstop: case _Nstop:
@ -147,14 +154,14 @@ while (TRUE) {
case _op_fail: case _op_fail:
if (codeptr == FAILCODE) if (codeptr == FAILCODE)
return found_fail(pc, startp, endp PASS_REGS); return found_fail(pc, startp, endp PASS_REGS);
pc = NEXTOP(pc, e); pc = NEXTOP(pc,e);
break; break;
case _spy_pred: case _spy_pred:
return found_owner_op(pc, startp, endp PASS_REGS); return found_owner_op(pc, startp, endp PASS_REGS);
case _trust_fail: case _trust_fail:
if (codeptr == TRUSTFAILCODE) if (codeptr == TRUSTFAILCODE)
return found_fail(pc, startp, endp PASS_REGS); return found_fail(pc, startp, endp PASS_REGS);
pc = NEXTOP(pc, e); pc = NEXTOP(pc,e);
break; break;
case _undef_p: case _undef_p:
return found_owner_op(pc, startp, endp PASS_REGS); return found_owner_op(pc, startp, endp PASS_REGS);
@ -178,16 +185,16 @@ while (TRUE) {
case _write_l_list: case _write_l_list:
case _write_list: case _write_list:
case _write_void: case _write_void:
pc = NEXTOP(pc, e); pc = NEXTOP(pc,e);
break; break;
/* instructions type fa */ /* instructions type fa */
case _write_l_struc: case _write_l_struc:
case _write_struct: case _write_struct:
pc = NEXTOP(pc, fa); pc = NEXTOP(pc,fa);
break; break;
/* instructions type i */ /* instructions type i */
case _write_longint: case _write_longint:
pc = NEXTOP(pc, i); pc = NEXTOP(pc,i);
break; break;
/* instructions type l */ /* instructions type l */
case _Ystop: case _Ystop:
@ -195,10 +202,6 @@ while (TRUE) {
case _jump: case _jump:
case _jump_if_var: case _jump_if_var:
case _move_back: case _move_back:
#if INLINE_BIG_COMPARISONS
case _p_dif:
case _p_eq:
#endif
case _retry2: case _retry2:
case _retry3: case _retry3:
case _retry4: case _retry4:
@ -207,11 +210,11 @@ while (TRUE) {
case _try_clause3: case _try_clause3:
case _try_clause4: case _try_clause4:
case _try_in: case _try_in:
pc = NEXTOP(pc, l); pc = NEXTOP(pc,l);
break; break;
/* instructions type llll */ /* instructions type llll */
case _switch_on_type: case _switch_on_type:
pc = NEXTOP(pc, llll); pc = NEXTOP(pc,llll);
break; break;
/* instructions type lp */ /* instructions type lp */
case _retry_all_exo: case _retry_all_exo:
@ -221,7 +224,7 @@ while (TRUE) {
case _try_exo: case _try_exo:
case _try_exo_udi: case _try_exo_udi:
case _user_switch: case _user_switch:
pc = NEXTOP(pc, lp); pc = NEXTOP(pc,lp);
break; break;
/* instructions type o */ /* instructions type o */
case _unify_l_list: case _unify_l_list:
@ -232,51 +235,51 @@ while (TRUE) {
case _unify_list_write: case _unify_list_write:
case _unify_void: case _unify_void:
case _unify_void_write: case _unify_void_write:
pc = NEXTOP(pc, o); pc = NEXTOP(pc,o);
break; break;
/* instructions type oD */ /* instructions type oD */
case _unify_dbterm: case _unify_dbterm:
case _unify_l_dbterm: case _unify_l_dbterm:
pc = NEXTOP(pc, oD); pc = NEXTOP(pc,oD);
break; break;
/* instructions type oN */ /* instructions type oN */
case _unify_bigint: case _unify_bigint:
case _unify_l_bigint: case _unify_l_bigint:
pc = NEXTOP(pc, oN); pc = NEXTOP(pc,oN);
break; break;
/* instructions type oc */ /* instructions type oc */
case _unify_atom: case _unify_atom:
case _unify_atom_write: case _unify_atom_write:
case _unify_l_atom: case _unify_l_atom:
case _unify_l_atom_write: case _unify_l_atom_write:
pc = NEXTOP(pc, oc); pc = NEXTOP(pc,oc);
break; break;
/* instructions type od */ /* instructions type od */
case _unify_float: case _unify_float:
case _unify_float_write: case _unify_float_write:
case _unify_l_float: case _unify_l_float:
case _unify_l_float_write: case _unify_l_float_write:
pc = NEXTOP(pc, od); pc = NEXTOP(pc,od);
break; break;
/* instructions type ofa */ /* instructions type ofa */
case _unify_l_struc: case _unify_l_struc:
case _unify_l_struc_write: case _unify_l_struc_write:
case _unify_struct: case _unify_struct:
case _unify_struct_write: case _unify_struct_write:
pc = NEXTOP(pc, ofa); pc = NEXTOP(pc,ofa);
break; break;
/* instructions type oi */ /* instructions type oi */
case _unify_l_longint: case _unify_l_longint:
case _unify_l_longint_write: case _unify_l_longint_write:
case _unify_longint: case _unify_longint:
case _unify_longint_write: case _unify_longint_write:
pc = NEXTOP(pc, oi); pc = NEXTOP(pc,oi);
break; break;
/* instructions type ollll */ /* instructions type ollll */
case _switch_list_nl: case _switch_list_nl:
pc = NEXTOP(pc, ollll); pc = NEXTOP(pc,ollll);
break; break;
/* instructions type os */ /* instructions type os */
#ifdef BEAM #ifdef BEAM
case _run_eam: case _run_eam:
#endif #endif
@ -284,17 +287,17 @@ while (TRUE) {
case _unify_l_n_voids_write: case _unify_l_n_voids_write:
case _unify_n_voids: case _unify_n_voids:
case _unify_n_voids_write: case _unify_n_voids_write:
pc = NEXTOP(pc, os); pc = NEXTOP(pc,os);
break; break;
/* instructions type osc */ /* instructions type osc */
case _unify_n_atoms: case _unify_n_atoms:
case _unify_n_atoms_write: case _unify_n_atoms_write:
pc = NEXTOP(pc, osc); pc = NEXTOP(pc,osc);
break; break;
/* instructions type ou */ /* instructions type ou */
case _unify_l_string: case _unify_l_string:
case _unify_string: case _unify_string:
pc = NEXTOP(pc, ou); pc = NEXTOP(pc,ou);
break; break;
/* instructions type ox */ /* instructions type ox */
case _save_appl_x: case _save_appl_x:
@ -313,14 +316,14 @@ while (TRUE) {
case _unify_x_val_write: case _unify_x_val_write:
case _unify_x_var: case _unify_x_var:
case _unify_x_var_write: case _unify_x_var_write:
pc = NEXTOP(pc, ox); pc = NEXTOP(pc,ox);
break; break;
/* instructions type oxx */ /* instructions type oxx */
case _unify_l_x_var2: case _unify_l_x_var2:
case _unify_l_x_var2_write: case _unify_l_x_var2_write:
case _unify_x_var2: case _unify_x_var2:
case _unify_x_var2_write: case _unify_x_var2_write:
pc = NEXTOP(pc, oxx); pc = NEXTOP(pc,oxx);
break; break;
/* instructions type oy */ /* instructions type oy */
case _save_appl_y: case _save_appl_y:
@ -339,7 +342,7 @@ while (TRUE) {
case _unify_y_val_write: case _unify_y_val_write:
case _unify_y_var: case _unify_y_var:
case _unify_y_var_write: case _unify_y_var_write:
pc = NEXTOP(pc, oy); pc = NEXTOP(pc,oy);
break; break;
/* instructions type p */ /* instructions type p */
case _lock_lu: case _lock_lu:
@ -348,7 +351,7 @@ while (TRUE) {
if (pp->PredFlags & MegaClausePredFlag) if (pp->PredFlags & MegaClausePredFlag)
return found_mega_clause(pp, startp, endp); return found_mega_clause(pp, startp, endp);
clause_code = TRUE; clause_code = TRUE;
pc = NEXTOP(pc, p); pc = NEXTOP(pc,p);
break; break;
case _count_call: case _count_call:
case _count_retry: case _count_retry:
@ -357,30 +360,20 @@ while (TRUE) {
case _retry_profiled: case _retry_profiled:
case _retry_udi: case _retry_udi:
case _try_udi: case _try_udi:
pc = NEXTOP(pc, p); pc = NEXTOP(pc,p);
break; break;
/* instructions type plxxs */ /* instructions type plxxs */
case _call_bfunc_xx: case _call_bfunc_xx:
pc = NEXTOP(pc, plxxs); pc = NEXTOP(pc,plxxs);
break; break;
/* instructions type plxys */ /* instructions type plxys */
case _call_bfunc_xy: case _call_bfunc_xy:
case _call_bfunc_yx: case _call_bfunc_yx:
pc = NEXTOP(pc, plxys); pc = NEXTOP(pc,plxys);
break; break;
/* instructions type plyys */ /* instructions type plyys */
case _call_bfunc_yy: case _call_bfunc_yy:
pc = NEXTOP(pc, plyys); pc = NEXTOP(pc,plyys);
break;
/* instructions type pp */
case _execute_cpred:
pp = pc->y_u.pp.p;
return walk_found_c_pred(pp, startp, endp);
case _dexecute:
case _execute:
clause_code = TRUE;
pp = pc->y_u.pp.p0;
pc = NEXTOP(pc, pp);
break; break;
/* instructions type s */ /* instructions type s */
case _cut: case _cut:
@ -388,15 +381,15 @@ while (TRUE) {
case _cut_t: case _cut_t:
case _pop_n: case _pop_n:
case _write_n_voids: case _write_n_voids:
pc = NEXTOP(pc, s); pc = NEXTOP(pc,s);
break; break;
/* instructions type sc */ /* instructions type sc */
case _write_n_atoms: case _write_n_atoms:
pc = NEXTOP(pc, sc); pc = NEXTOP(pc,sc);
break; break;
/* instructions type sllll */ /* instructions type sllll */
case _switch_on_sub_arg_type: case _switch_on_sub_arg_type:
pc = NEXTOP(pc, sllll); pc = NEXTOP(pc,sllll);
break; break;
/* instructions type slpp */ /* instructions type slpp */
case _call_c_wfail: case _call_c_wfail:
@ -409,12 +402,12 @@ while (TRUE) {
case _if_func: case _if_func:
case _switch_on_cons: case _switch_on_cons:
case _switch_on_func: case _switch_on_func:
pc = NEXTOP(pc, sssl); pc = NEXTOP(pc,sssl);
break; break;
/* instructions type sssllp */ /* instructions type sssllp */
case _expand_clauses: case _expand_clauses:
return found_expand_index(pc, startp, endp, codeptr PASS_REGS); return found_expand_index(pc, startp, endp, codeptr PASS_REGS);
pc = NEXTOP(pc, sssllp); pc = NEXTOP(pc,sssllp);
break; break;
/* instructions type x */ /* instructions type x */
case _get_atom_exo: case _get_atom_exo:
@ -424,37 +417,37 @@ while (TRUE) {
case _write_x_loc: case _write_x_loc:
case _write_x_val: case _write_x_val:
case _write_x_var: case _write_x_var:
pc = NEXTOP(pc, x); pc = NEXTOP(pc,x);
break; break;
/* instructions type xD */ /* instructions type xD */
case _get_dbterm: case _get_dbterm:
case _put_dbterm: case _put_dbterm:
pc = NEXTOP(pc, xD); pc = NEXTOP(pc,xD);
break; break;
/* instructions type xN */ /* instructions type xN */
case _get_bigint: case _get_bigint:
case _put_bigint: case _put_bigint:
pc = NEXTOP(pc, xN); pc = NEXTOP(pc,xN);
break; break;
/* instructions type xc */ /* instructions type xc */
case _get_atom: case _get_atom:
case _put_atom: case _put_atom:
pc = NEXTOP(pc, xc); pc = NEXTOP(pc,xc);
break; break;
/* instructions type xd */ /* instructions type xd */
case _get_float: case _get_float:
case _put_float: case _put_float:
pc = NEXTOP(pc, xd); pc = NEXTOP(pc,xd);
break; break;
/* instructions type xfa */ /* instructions type xfa */
case _get_struct: case _get_struct:
case _put_struct: case _put_struct:
pc = NEXTOP(pc, xfa); pc = NEXTOP(pc,xfa);
break; break;
/* instructions type xi */ /* instructions type xi */
case _get_longint: case _get_longint:
case _put_longint: case _put_longint:
pc = NEXTOP(pc, xi); pc = NEXTOP(pc,xi);
break; break;
/* instructions type xl */ /* instructions type xl */
case _p_atom_x: case _p_atom_x:
@ -467,23 +460,23 @@ while (TRUE) {
case _p_number_x: case _p_number_x:
case _p_primitive_x: case _p_primitive_x:
case _p_var_x: case _p_var_x:
pc = NEXTOP(pc, xl); pc = NEXTOP(pc,xl);
break; break;
/* instructions type xll */ /* instructions type xll */
case _jump_if_nonvar: case _jump_if_nonvar:
pc = NEXTOP(pc, xll); pc = NEXTOP(pc,xll);
break; break;
/* instructions type xllll */ /* instructions type xllll */
case _switch_on_arg_type: case _switch_on_arg_type:
pc = NEXTOP(pc, xllll); pc = NEXTOP(pc,xllll);
break; break;
/* instructions type xps */ /* instructions type xps */
case _commit_b_x: case _commit_b_x:
pc = NEXTOP(pc, xps); pc = NEXTOP(pc,xps);
break; break;
/* instructions type xu */ /* instructions type xu */
case _get_string: case _get_string:
pc = NEXTOP(pc, xu); pc = NEXTOP(pc,xu);
break; break;
/* instructions type xx */ /* instructions type xx */
case _get_x_val: case _get_x_val:
@ -493,11 +486,11 @@ while (TRUE) {
case _glist_valx: case _glist_valx:
case _put_x_val: case _put_x_val:
case _put_x_var: case _put_x_var:
pc = NEXTOP(pc, xx); pc = NEXTOP(pc,xx);
break; break;
/* instructions type xxc */ /* instructions type xxc */
case _p_func2s_cv: case _p_func2s_cv:
pc = NEXTOP(pc, xxc); pc = NEXTOP(pc,xxc);
break; break;
/* instructions type xxn */ /* instructions type xxn */
case _p_and_vc: case _p_and_vc:
@ -513,7 +506,7 @@ while (TRUE) {
case _p_slr_cv: case _p_slr_cv:
case _p_slr_vc: case _p_slr_vc:
case _p_times_vc: case _p_times_vc:
pc = NEXTOP(pc, xxn); pc = NEXTOP(pc,xxn);
break; break;
/* instructions type xxx */ /* instructions type xxx */
case _p_and_vv: case _p_and_vv:
@ -527,22 +520,22 @@ while (TRUE) {
case _p_sll_vv: case _p_sll_vv:
case _p_slr_vv: case _p_slr_vv:
case _p_times_vv: case _p_times_vv:
pc = NEXTOP(pc, xxx); pc = NEXTOP(pc,xxx);
break; break;
/* instructions type xxxx */ /* instructions type xxxx */
case _put_xx_val: case _put_xx_val:
pc = NEXTOP(pc, xxxx); pc = NEXTOP(pc,xxxx);
break; break;
/* instructions type xxy */ /* instructions type xxy */
case _p_func2f_xy: case _p_func2f_xy:
pc = NEXTOP(pc, xxy); pc = NEXTOP(pc,xxy);
break; break;
/* instructions type y */ /* instructions type y */
case _save_b_y: case _save_b_y:
case _write_y_loc: case _write_y_loc:
case _write_y_val: case _write_y_val:
case _write_y_var: case _write_y_var:
pc = NEXTOP(pc, y); pc = NEXTOP(pc,y);
break; break;
/* instructions type yl */ /* instructions type yl */
case _p_atom_y: case _p_atom_y:
@ -555,11 +548,11 @@ while (TRUE) {
case _p_number_y: case _p_number_y:
case _p_primitive_y: case _p_primitive_y:
case _p_var_y: case _p_var_y:
pc = NEXTOP(pc, yl); pc = NEXTOP(pc,yl);
break; break;
/* instructions type yps */ /* instructions type yps */
case _commit_b_y: case _commit_b_y:
pc = NEXTOP(pc, yps); pc = NEXTOP(pc,yps);
break; break;
/* instructions type yx */ /* instructions type yx */
case _get_y_val: case _get_y_val:
@ -570,11 +563,11 @@ while (TRUE) {
case _put_unsafe: case _put_unsafe:
case _put_y_val: case _put_y_val:
case _put_y_var: case _put_y_var:
pc = NEXTOP(pc, yx); pc = NEXTOP(pc,yx);
break; break;
/* instructions type yxc */ /* instructions type yxc */
case _p_func2s_y_cv: case _p_func2s_y_cv:
pc = NEXTOP(pc, yxc); pc = NEXTOP(pc,yxc);
break; break;
/* instructions type yxn */ /* instructions type yxn */
case _p_and_y_vc: case _p_and_y_vc:
@ -590,7 +583,7 @@ while (TRUE) {
case _p_slr_y_cv: case _p_slr_y_cv:
case _p_slr_y_vc: case _p_slr_y_vc:
case _p_times_y_vc: case _p_times_y_vc:
pc = NEXTOP(pc, yxn); pc = NEXTOP(pc,yxn);
break; break;
/* instructions type yxx */ /* instructions type yxx */
case _p_and_y_vv: case _p_and_y_vv:
@ -604,16 +597,16 @@ while (TRUE) {
case _p_sll_y_vv: case _p_sll_y_vv:
case _p_slr_y_vv: case _p_slr_y_vv:
case _p_times_y_vv: case _p_times_y_vv:
pc = NEXTOP(pc, yxx); pc = NEXTOP(pc,yxx);
break; break;
/* instructions type yyx */ /* instructions type yyx */
case _p_func2f_yy: case _p_func2f_yy:
pc = NEXTOP(pc, yyx); pc = NEXTOP(pc,yyx);
break; break;
/* instructions type yyxx */ /* instructions type yyxx */
case _get_yy_var: case _get_yy_var:
case _put_y_vals: case _put_y_vals:
pc = NEXTOP(pc, yyxx); pc = NEXTOP(pc,yyxx);
break; break;
#ifdef YAPOR #ifdef YAPOR
/* instructions type Otapl */ /* instructions type Otapl */
@ -622,11 +615,11 @@ while (TRUE) {
case _sync: case _sync:
clause_code = FALSE; clause_code = FALSE;
pp = pc->y_u.Otapl.p; pp = pc->y_u.Otapl.p;
pc = NEXTOP(pc, Otapl); pc = NEXTOP(pc,Otapl);
break; break;
/* instructions type e */ /* instructions type e */
case _getwork_first_time: case _getwork_first_time:
pc = NEXTOP(pc, e); pc = NEXTOP(pc,e);
break; break;
#endif #endif
#ifdef TABLING #ifdef TABLING
@ -647,17 +640,17 @@ while (TRUE) {
case _table_try_single: case _table_try_single:
clause_code = FALSE; clause_code = FALSE;
pp = pc->y_u.Otapl.p; pp = pc->y_u.Otapl.p;
pc = NEXTOP(pc, Otapl); pc = NEXTOP(pc,Otapl);
break; break;
/* instructions type e */ /* instructions type e */
#ifdef TABLING_INNER_CUTS #ifdef TABLING_INNER_CUTS
case _clause_with_cut: case _clause_with_cut:
#endif #endif
pc = NEXTOP(pc, e); pc = NEXTOP(pc,e);
break; break;
/* instructions type s */ /* instructions type s */
case _table_new_answer: case _table_new_answer:
pc = NEXTOP(pc, s); pc = NEXTOP(pc,s);
break; break;
/* instructions type e */ /* instructions type e */
case _trie_do_appl: case _trie_do_appl:
@ -724,7 +717,7 @@ while (TRUE) {
case _trie_try_val_in_pair: case _trie_try_val_in_pair:
case _trie_try_var: case _trie_try_var:
case _trie_try_var_in_pair: case _trie_try_var_in_pair:
pc = NEXTOP(pc, e); pc = NEXTOP(pc,e);
break; break;
#endif #endif
/* this instruction is hardwired */ /* this instruction is hardwired */
@ -734,13 +727,13 @@ while (TRUE) {
if (pp->PredFlags & MegaClausePredFlag) if (pp->PredFlags & MegaClausePredFlag)
return found_mega_clause(pp, startp, endp); return found_mega_clause(pp, startp, endp);
clause_code = TRUE; clause_code = TRUE;
pc = NEXTOP(pc, Osblp); pc = NEXTOP(pc,Osblp);
#else #else
pp = pc->y_u.p.p; pp = pc->y_u.p.p;
if (pp->PredFlags & MegaClausePredFlag) if (pp->PredFlags & MegaClausePredFlag)
return found_mega_clause(pp, startp, endp); return found_mega_clause(pp, startp, endp);
clause_code = TRUE; clause_code = TRUE;
pc = NEXTOP(pc, p); pc = NEXTOP(pc,p);
#endif #endif
} }
} }