From c802669cf45ba20442db3045a03b94c9dd469aaf Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?V=C3=ADtor=20Santos=20Costa?= Date: Thu, 5 Feb 2015 01:05:08 +0000 Subject: [PATCH 1/9] cleanups --- packages/python/python.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/packages/python/python.c b/packages/python/python.c index 55e73feeb..c61f034e8 100644 --- a/packages/python/python.c +++ b/packages/python/python.c @@ -1,9 +1,10 @@ + +#include #include #include #ifdef HAVE_STAT #undef HAVE_STAT #endif -#include #include static atom_t ATOM_true, From bae7b716e2169f50ba240838933801443441c680 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?V=C3=ADtor=20Santos=20Costa?= Date: Fri, 6 Feb 2015 18:05:21 +0000 Subject: [PATCH 2/9] fix import term to handle overflows. --- C/utilpreds.c | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-) diff --git a/C/utilpreds.c b/C/utilpreds.c index 1bf1667f6..2b23d6ad4 100644 --- a/C/utilpreds.c +++ b/C/utilpreds.c @@ -1267,8 +1267,14 @@ Yap_ImportTerm(char * buf) { tret = MkAtomTerm(addAtom(NULL,(char *)(bc+3))); return tret; } - if (HR + sz > ASP) - return (Term)0; + // call the gc/stack shifter mechanism + // if not enough stack available + while (HR + sz > ASP - 4096) { + if (!Yap_gcl( (sz+4096)*sizeof(CELL), PP->ArityOfPE, ENV, gc_P(P,CP))) { + Yap_Error(OUT_OF_STACK_ERROR, TermNil, LOCAL_ErrorMessage); + return 0L; + } + } memcpy(HR, buf+bc[0], sizeof(CELL)*sz); if (IsApplTerm(tinp)) { tret = AbsAppl(HR); From 7b4cd0d256df0ddbb9fd10f7e11f6eecb8020f3b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?V=C3=ADtor=20Santos=20Costa?= Date: Fri, 6 Feb 2015 18:08:06 +0000 Subject: [PATCH 3/9] patch by Fab. Riguzzi to fix MPI interface --- library/lammpi/prologterms2c.c | 6 +----- library/lammpi/yap_mpi.c | 8 +++----- 2 files changed, 4 insertions(+), 10 deletions(-) diff --git a/library/lammpi/prologterms2c.c b/library/lammpi/prologterms2c.c index 6a1740940..6cfc4d07d 100644 --- a/library/lammpi/prologterms2c.c +++ b/library/lammpi/prologterms2c.c @@ -102,11 +102,7 @@ void change_buffer_size(const size_t newsize) { if ( BUFFER_SIZE>=BLOCK_SIZE && BUFFER_SIZE>=newsize) return; - if (BUFFER_PTR) { - free(BUFFER_PTR); - } - BUFFER_PTR = (char*)malloc(newsize); - if( BUFFER_PTR == NULL ) { + if (realloc( BUFFER_PTR, newsize) == NULL) { YAP_Error(0,0,"Prolog2Term: Out of memory.\n"); #ifdef MPI MPI_Finalize(); diff --git a/library/lammpi/yap_mpi.c b/library/lammpi/yap_mpi.c index 51c4fe4c5..6c122cf5c 100644 --- a/library/lammpi/yap_mpi.c +++ b/library/lammpi/yap_mpi.c @@ -1,5 +1,5 @@ /* -Copyright (C) 2004,2005,2006 (Nuno A. Fonseca) + Copyright (C) 2004,2005,2006 (Nuno A. Fonseca) This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License @@ -41,9 +41,7 @@ Comments: YAP interface to LAM/MPI #include "prologterms2c.h" -#ifndef _yap_c_interface_h #include -#endif #include "hash.h" @@ -976,7 +974,7 @@ mpi_gc(void) { RETURN(TRUE); } -int BLOCK_SIZE=4*1024; +size_t BLOCK_SIZE=4*1024; static int mpi_default_buffer_size(void) @@ -1022,7 +1020,7 @@ init_mpi(void) { YAP_UserCPredicate( "mpi_wait", mpi_wait,2); // mpi_wait(+Handle,-Status). YAP_UserCPredicate( "mpi_wait_recv", mpi_wait_recv,3); // mpi_wait_recv(+Handle,-Status,-Data). YAP_UserCPredicate( "mpi_test", mpi_test,2); // mpi_test(+Handle,-Status). - YAP_UserCPredicate( "mpi_test_rcv", mpi_test_recv,3); // mpi_test(+Handle,-Status,-Data). + YAP_UserCPredicate( "mpi_test_recv", mpi_test_recv,3); // mpi_test(+Handle,-Status,-Data). YAP_UserCPredicate( "mpi_bcast", mpi_bcast,2); // mpi_bcast(Root,Term) YAP_UserCPredicate( "mpi_bcast2", mpi_bcast2,2); // mpi_bcast2(Root,Term) YAP_UserCPredicate( "mpi_bcast3", mpi_bcast3,3); // mpi_bcast3(Root,Term,Tag) From 42d7b305c002e6529c1cdf751b6710efdd76e0e1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?V=C3=ADtor=20Santos=20Costa?= Date: Fri, 6 Feb 2015 18:11:44 +0000 Subject: [PATCH 4/9] patch by Fab. Riguzzi to fix MPI interface --- library/lam_mpi.yap | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/library/lam_mpi.yap b/library/lam_mpi.yap index 7a6da46c1..f6af6c84b 100644 --- a/library/lam_mpi.yap +++ b/library/lam_mpi.yap @@ -208,7 +208,8 @@ message and _Data_ with the message itself. mpi_barrier/0, mpi_msg_buffer_size/2, mpi_msg_size/2, - mpi_gc/0 + mpi_gc/0, + mpi_default_buffer_size/2 ]). :- load_foreign_files([yap_mpi], [], init_mpi). From ba978d8275f8a7369f3d7162cbb60345b89b9c85 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?V=C3=ADtor=20Santos=20Costa?= Date: Fri, 6 Feb 2015 18:11:52 +0000 Subject: [PATCH 5/9] just in time native code: now compiles by doing cmake; make. no workie in this version, though :) --- C/absmi.c | 71 +- C/absmi_insts.h | 3 +- C/init.c | 2 + C/stdpreds.c | 3 +- C/traced_absmi_insts.h | 2816 ++++++++++++++++--------------- CMakeLists.txt | 1 + H/YapOpcodes.h | 405 ----- H/absmi.h | 85 +- H/amijit.h | 3 + H/findclause.h | 6 - H/headclause.h | 6 - H/rclause.h | 897 ---------- H/saveclause.h | 910 ---------- H/walkclause.h | 672 -------- JIT/CMakeLists.txt | 5 +- JIT/HPP/IsGround.h | 1203 ------------- JIT/HPP/JIT.hpp | 3 + JIT/HPP/JIT_Compiler.hpp | 21 +- JIT/HPP/PassPrinters.hh | 20 +- JIT/HPP/lastop.h | 1194 +------------ JIT/HPP/nextof.hpp | 1193 +------------ JIT/HPP/sprint_op.hpp | 1587 +---------------- JIT/JIT_Init.cpp | 58 + JIT/JIT_interface.cpp | 38 + JIT/jit_analysispreds.c | 2 +- JIT/jit_traced.c | 267 +++ OPTYap/tab.tries.insts.h | 4 +- OPTYap/traced_or.insts.h | 8 +- OPTYap/traced_tab.insts.h | 38 +- OPTYap/traced_tab.tries.insts.h | 532 +++++- library/rltree/range_list.c | 2 +- misc/buildops | 47 +- 32 files changed, 2436 insertions(+), 9666 deletions(-) create mode 100644 JIT/JIT_Init.cpp create mode 100644 JIT/JIT_interface.cpp create mode 100644 JIT/jit_traced.c diff --git a/C/absmi.c b/C/absmi.c index ecbd48a86..bb5e39502 100755 --- a/C/absmi.c +++ b/C/absmi.c @@ -501,7 +501,8 @@ We next discuss several issues on trying to make Prolog programs run fast in YAP. We assume two different programming styles: -+ Execution of deterministic programs often ++ Execution of deterministic programs ofte +n boils down to a recursive loop of the form: ~~~~~ @@ -516,11 +517,30 @@ loop(Env) :- #define IN_ABSMI_C 1 #define HAS_CACHE_REGS 1 + + #include "absmi.h" #include "heapgc.h" #include "cut_c.h" +#if YAP_JIT +#include "IsGround.h" + +NativeContext *NativeArea; +IntermediatecodeContext *IntermediatecodeArea; + +CELL l; + +CELL nnexec; + +static Int traced_absmi(void) +{ + return Yap_traced_absmi(); +} + +#endif + #ifdef PUSH_X #else @@ -537,31 +557,6 @@ Term Yap_XREGS[MaxTemps]; /* 29 */ //#include "sprint_op.hpp" //#include "print_op.hpp" -#if YAP_JIT -#include "IsGround.h" -#include "yaam_macros.hpp" -#include "fprintblock.h" - -#if YAP_DBG_PREDS -#include "debug_printers.h" -#endif - -struct JIT_Compiler *J; - -NativeContext *NativeArea; -IntermediatecodeContext *IntermediatecodeArea; -void shutdown_llvm(void); - -CELL l; -short global; -CELL nnexec; -yamop* HEADPREG; -CELL BLOCK; -CELL BLOCKADDRESS; -CELL FAILED; - -#endif /* YAP_JIT */ - #ifdef COROUTINING /* Imagine we are interrupting the execution, say, because we have a spy @@ -1588,10 +1583,6 @@ Yap_absmi(int inp) #define I_R (XREGS[0]) #if YAP_JIT -#if YAP_STAT_PREDS - struct timeval timstart, timend; - struct rusage rustart, ruend; -#endif static void *control_labels[] = { &&fail, &&NoStackCut, &&NoStackCommitY, &&NoStackCutT, &&NoStackEither, &&NoStackExecute, &&NoStackCall, &&NoStackDExecute, &&NoStackDeallocate, &¬railleft, &&NoStackFail, &&NoStackCommitX }; curtrace = NULL; curpreg = NULL; @@ -1638,7 +1629,8 @@ Yap_absmi(int inp) }; #if YAP_JIT - ExpEnv.config_struc.TOTAL_OF_OPCODES = sizeof(OpAddress)/(2*sizeof(void*)); + ExpEnv.config_struc.TOTAL_OF_OPCODES = + sizeof(OpAddress)/(2*sizeof(void*)); #endif #endif /* USE_THREADED_CODE */ @@ -1692,7 +1684,8 @@ Yap_absmi(int inp) #if USE_THREADED_CODE /* absmadr */ if (inp > 0) { - Yap_ABSMI_OPCODES = OpAddress; + Yap_ABSMI_OPCODES = OpAddress; + Yap_ABSMI_ControlLabels = control_labels; #if BP_FREE P1REG = PCBACKUP; #endif @@ -1819,17 +1812,7 @@ Yap_absmi(int inp) // so that they are easier to analyse. #include "absmi_insts.h" -#if YAP_JIT -#include "traced_absmi_insts.h" -#if YAPOR -#include "traced_or.insts.h" -#endif -#if TABLING -#include "traced_tab.insts.h" -#include "traced_tab.tries.insts.h" -#endif -#endif - + #if !USE_THREADED_CODE default: saveregs(); @@ -1850,8 +1833,6 @@ Yap_absmi(int inp) return (0); #endif - - } /* dummy function that is needed for profiler */ diff --git a/C/absmi_insts.h b/C/absmi_insts.h index 1d5b86652..a46d63f2c 100644 --- a/C/absmi_insts.h +++ b/C/absmi_insts.h @@ -55,7 +55,8 @@ BOp(Ystop, l); fprintf(stderr, "%s", (char*)ExpEnv.debug_struc.pprint_me.criticals); } #endif - goto critical_lbl; + traced_absmi(); + } #if YAP_DBG_PREDS print_main_when_head(PREG, ON_INTERPRETER); diff --git a/C/init.c b/C/init.c index 4937762e1..e6976eb7b 100755 --- a/C/init.c +++ b/C/init.c @@ -93,6 +93,8 @@ int Yap_page_size; #if USE_THREADED_CODE /* easy access to instruction opcodes */ void **Yap_ABSMI_OPCODES; +void **Yap_ABSMI_ControlLabels; + #endif #if DEBUG diff --git a/C/stdpreds.c b/C/stdpreds.c index 4f9b1acca..6bdba7e9f 100644 --- a/C/stdpreds.c +++ b/C/stdpreds.c @@ -342,8 +342,9 @@ static Int p_set_yap_flags(USES_REGS1); static Int p_break(USES_REGS1); #if YAP_JIT -void* (*Yap_JitCall)(struct JIT_Compiler* jc, yamop* p); +void* (*Yap_JitCall)(JIT_Compiler* jc, yamop* p); void (* Yap_llvmShutdown)(void ) ; +Int (* Yap_traced_absmi)(void ) ; Environment ExpEnv; diff --git a/C/traced_absmi_insts.h b/C/traced_absmi_insts.h index 34bd063ed..f51164ad3 100644 --- a/C/traced_absmi_insts.h +++ b/C/traced_absmi_insts.h @@ -1,12 +1,39 @@ +#define PASS_REGS +#define undef_goal( x ) + +if (P == NULL) goto fail; +NoStackCut: +if (P == NULL) goto NoStackCut; +NoStackCommitY: +if (P == NULL) goto NoStackCommitY; +NoStackCutT: +if (P== NULL) goto NoStackCutT; +NoStackCutE: +if (P== NULL) goto NoStackCutE; +NoStackEither: +if (P== NULL) goto NoStackEither; +NoStackExecute: +if (P== NULL) goto NoStackExecute; +NoStackCall: +if (P== NULL) goto NoStackCall; +NoStackDExecute: +if (P== NULL) goto NoStackDExecute; +NoStackDeallocate: +if (P== NULL) goto NoStackDeallocate; +NoStackFail: +if (P== NULL) goto NoStackFail; +NoStackCommitX: +if (P== NULL) goto NoStackCommitX; + /***************************************************************** * TRACED INSTRUCTIONS * *****************************************************************/ - BOp(traced_Ystop, l); + BOp(Ystop, l); goto Ystop; ENDBOp(); - BOp(traced_Nstop, e); + BOp(Nstop, e); goto Nstop; ENDBOp(); @@ -14,7 +41,7 @@ * Plain try - retry - trust instructions * *****************************************************************/ /* try_me Label,NArgs */ - Op(traced_try_me, Otapl); + Op(try_me, Otapl); /* check if enough space between trail and codespace */ EMIT_ENTRY_BLOCK(PREG,TRY_ME_INSTINIT); check_trail(TR); @@ -44,7 +71,7 @@ CACHE_Y(YREG); ENDOp(); /* retry_me Label,NArgs */ - Op(traced_retry_me, Otapl); + Op(retry_me, Otapl); EMIT_ENTRY_BLOCK(PREG,RETRY_ME_INSTINIT); CACHE_Y(B); /* After retry, cut should be pointing at the parent @@ -67,7 +94,7 @@ CACHE_Y(YREG); ENDOp(); /* trust_me UnusedLabel,NArgs */ - Op(traced_trust_me, Otapl); + Op(trust_me, Otapl); EMIT_ENTRY_BLOCK(PREG,TRUST_ME_INSTINIT); CACHE_Y(B); EMIT_SIMPLE_BLOCK_TEST(TRUST_ME_IF); @@ -104,7 +131,7 @@ CACHE_Y(YREG); *****************************************************************/ /* profiled_enter_me Pred */ - Op(traced_enter_profiling, p); + Op(enter_profiling, p); EMIT_ENTRY_BLOCK(PREG,ENTER_PROFILING_INSTINIT); LOCK(PREG->y_u.p.p->StatisticsForPred.lock); PREG->y_u.p.p->StatisticsForPred.NOfEntries++; @@ -114,7 +141,7 @@ CACHE_Y(YREG); ENDOp(); /* profiled_retry Label,NArgs */ - Op(traced_retry_profiled, p); + Op(retry_profiled, p); EMIT_ENTRY_BLOCK(PREG,RETRY_PROFILED_INSTINIT); LOCK(PREG->y_u.p.p->StatisticsForPred.lock); PREG->y_u.p.p->StatisticsForPred.NOfRetries++; @@ -124,7 +151,7 @@ CACHE_Y(YREG); ENDOp(); /* profiled_retry_me Label,NArgs */ - Op(traced_profiled_retry_me, Otapl); + Op(profiled_retry_me, Otapl); EMIT_ENTRY_BLOCK(PREG,PROFILED_RETRY_ME_INSTINIT); CACHE_Y(B); /* After retry, cut should be pointing at the parent @@ -150,7 +177,7 @@ CACHE_Y(YREG); ENDOp(); /* profiled_trust_me UnusedLabel,NArgs */ - Op(traced_profiled_trust_me, Otapl); + Op(profiled_trust_me, Otapl); EMIT_ENTRY_BLOCK(PREG,PROFILED_TRUST_ME_INSTINIT); CACHE_Y(B); EMIT_SIMPLE_BLOCK(PROFILED_TRUST_ME_IF); @@ -185,7 +212,7 @@ CACHE_Y(YREG); GONext(); ENDOp(); - BOp(traced_profiled_retry_logical, OtaLl); + BOp(profiled_retry_logical, OtaLl); EMIT_ENTRY_BLOCK(PREG,PROFILED_RETRY_LOGICAL_INSTINIT); check_trail(TR); { @@ -224,7 +251,7 @@ CACHE_Y(YREG); JMPNext(); ENDBOp(); - BOp(traced_profiled_trust_logical, OtILl); + BOp(profiled_trust_logical, OtILl); EMIT_ENTRY_BLOCK(PREG,PROFILED_TRUST_LOGICAL_INSTINIT); EMIT_SIMPLE_BLOCK(PROFILED_TRUST_LOGICAL_END); CACHE_Y(B); @@ -341,7 +368,7 @@ CACHE_Y(YREG); *****************************************************************/ /* count_enter_me Label,NArgs */ - Op(traced_count_call, p); + Op(count_call, p); EMIT_ENTRY_BLOCK(PREG,COUNT_CALL_INSTINIT); LOCK(PREG->y_u.p.p->StatisticsForPred.lock); PREG->y_u.p.p->StatisticsForPred.NOfEntries++; @@ -367,7 +394,7 @@ CACHE_Y(YREG); ENDOp(); /* count_retry Label,NArgs */ - Op(traced_count_retry, p); + Op(count_retry, p); EMIT_ENTRY_BLOCK(PREG,COUNT_RETRY_INSTINIT); LOCK(PREG->y_u.p.p->StatisticsForPred.lock); PREG->y_u.p.p->StatisticsForPred.NOfRetries++; @@ -396,7 +423,7 @@ CACHE_Y(YREG); ENDOp(); /* count_retry_me Label,NArgs */ - Op(traced_count_retry_me, Otapl); + Op(count_retry_me, Otapl); EMIT_ENTRY_BLOCK(PREG,COUNT_RETRY_ME_INSTINIT); CACHE_Y(B); restore_yaam_regs(PREG->y_u.Otapl.d); @@ -435,7 +462,7 @@ CACHE_Y(YREG); ENDOp(); /* count_trust_me UnusedLabel,NArgs */ - Op(traced_count_trust_me, Otapl); + Op(count_trust_me, Otapl); EMIT_ENTRY_BLOCK(PREG,COUNT_TRUST_ME_INSTINIT); CACHE_Y(B); EMIT_SIMPLE_BLOCK(COUNT_TRUST_ME_MIDDLE); @@ -484,7 +511,7 @@ CACHE_Y(YREG); GONext(); ENDOp(); - BOp(traced_count_retry_logical, OtaLl); + BOp(count_retry_logical, OtaLl); EMIT_ENTRY_BLOCK(PREG,COUNT_RETRY_LOGICAL_INSTINIT); EMIT_SIMPLE_BLOCK(COUNT_RETRY_LOGICAL_END); check_trail(TR); @@ -533,7 +560,7 @@ CACHE_Y(YREG); JMPNext(); ENDBOp(); - BOp(traced_count_trust_logical, OtILl); + BOp(count_trust_logical, OtILl); EMIT_ENTRY_BLOCK(PREG,COUNT_TRUST_LOGICAL_INSTINIT); EMIT_SIMPLE_BLOCK(COUNT_TRUST_LOGICAL_END); CACHE_Y(B); @@ -667,7 +694,7 @@ CACHE_Y(YREG); /* only meaningful with THREADS on! */ /* lock logical updates predicate. */ - Op(traced_lock_lu, p); + Op(lock_lu, p); EMIT_SIMPLE_BLOCK(LOCK_LU_INSTINIT); EMIT_SIMPLE_BLOCK(LOCK_LU_END); #if PARALLEL_YAP @@ -683,7 +710,7 @@ CACHE_Y(YREG); /* only meaningful with THREADS on! */ /* lock logical updates predicate. */ - Op(traced_unlock_lu, e); + Op(unlock_lu, e); EMIT_SIMPLE_BLOCK(UNLOCK_LU_INSTINIT); #if defined(YAPOR) || defined(THREADS) EMIT_SIMPLE_BLOCK(UNLOCK_LU_YAPOR_THREADS); @@ -697,7 +724,7 @@ CACHE_Y(YREG); /* enter logical pred */ - BOp(traced_alloc_for_logical_pred, L); + BOp(alloc_for_logical_pred, L); EMIT_ENTRY_BLOCK(PREG,ALLOC_FOR_LOGICAL_PRED_INSTINIT); EMIT_SIMPLE_BLOCK(YAAM_CHECK_TRAIL_TR); check_trail(TR); @@ -735,7 +762,7 @@ CACHE_Y(YREG); ENDBOp(); /* copy database term */ - BOp(traced_copy_idb_term, e); + BOp(copy_idb_term, e); EMIT_ENTRY_BLOCK(PREG,COPY_IDB_TERM_INSTINIT); EMIT_MULTIPLE_DESTINY_BLOCK_TEST(COPY_IDB_TERM_END); { @@ -753,7 +780,7 @@ CACHE_Y(YREG); PP = NULL; #endif Yap_NilError(OUT_OF_ATTVARS_ERROR, LOCAL_ErrorMessage); - TRACED_FAIL(); + FAIL(); } } else { LOCAL_Error_TYPE = YAP_NO_ERROR; @@ -763,7 +790,7 @@ CACHE_Y(YREG); PP = NULL; #endif Yap_NilError(OUT_OF_STACK_ERROR, LOCAL_ErrorMessage); - TRACED_FAIL(); + FAIL(); } } } @@ -773,7 +800,7 @@ CACHE_Y(YREG); #if defined(YAPOR) || defined(THREADS) PP = NULL; #endif - TRACED_FAIL(); + FAIL(); } if (!Yap_IUnify(ARG3, MkDBRefTerm((DBRef)cl))) { setregs(); @@ -781,7 +808,7 @@ CACHE_Y(YREG); #if defined(YAPOR) || defined(THREADS) PP = NULL; #endif - TRACED_FAIL(); + FAIL(); } setregs(); @@ -812,7 +839,7 @@ CACHE_Y(YREG); /* unify with database term */ - BOp(traced_unify_idb_term, e); + BOp(unify_idb_term, e); EMIT_ENTRY_BLOCK(PREG,UNIFY_IDB_TERM_INSTINIT); EMIT_MULTIPLE_DESTINY_BLOCK_TEST(UNIFY_IDB_TERM_END); { @@ -825,7 +852,7 @@ CACHE_Y(YREG); #if defined(YAPOR) || defined(THREADS) PP = NULL; #endif - TRACED_FAIL(); + FAIL(); } if (!Yap_IUnify(ARG3, MkDBRefTerm((DBRef)cl))) { setregs(); @@ -833,7 +860,7 @@ CACHE_Y(YREG); #if defined(YAPOR) || defined(THREADS) PP = NULL; #endif - TRACED_FAIL(); + FAIL(); } setregs(); @@ -870,7 +897,7 @@ CACHE_Y(YREG); *****************************************************************/ /* ensure_space */ - BOp(traced_ensure_space, Osbpa); + BOp(ensure_space, Osbpa); EMIT_ENTRY_BLOCK(PREG,ENSURE_SPACE_INSTINIT); EMIT_SIMPLE_BLOCK(ENSURE_SPACE_END); { @@ -888,7 +915,7 @@ CACHE_Y(YREG); if (!Yap_gcl(sz, arity, YENV, PREG)) { Yap_NilError(OUT_OF_STACK_ERROR,LOCAL_ErrorMessage); setregs(); - TRACED_FAIL(); + FAIL(); } else { setregs(); } @@ -904,16 +931,16 @@ CACHE_Y(YREG); *****************************************************************/ /* spy_or_trymark */ - BOp(traced_spy_or_trymark, Otapl); + BOp(spy_or_trymark, Otapl); EMIT_ENTRY_BLOCK(PREG,SPY_OR_TRYMARK_INSTINIT); PELOCK(5, ((PredEntry *)(PREG->y_u.Otapl.p))); PREG = (yamop *)(&(((PredEntry *)(PREG->y_u.Otapl.p))->OpcodeOfPred)); UNLOCKPE(11,(PredEntry *)(PREG->y_u.Otapl.p)); - goto traced_dospy; + goto dospy; ENDBOp(); /* try_and_mark Label,NArgs */ - BOp(traced_try_and_mark, Otapl); + BOp(try_and_mark, Otapl); EMIT_ENTRY_BLOCK(PREG,TRY_AND_MARK_INSTINIT); check_trail(TR); #if defined(YAPOR) || defined(THREADS) @@ -981,7 +1008,7 @@ CACHE_Y(YREG); ENDBOp(); - BOp(traced_count_retry_and_mark, Otapl); + BOp(count_retry_and_mark, Otapl); EMIT_ENTRY_BLOCK(PREG,COUNT_RETRY_AND_MARK_INSTINIT); LOCAL_RetriesCounter--; if (LOCAL_RetriesCounter == 0) { @@ -1000,7 +1027,7 @@ CACHE_Y(YREG); /* enter a retry dynamic */ ENDBOp(); - BOp(traced_profiled_retry_and_mark, Otapl); + BOp(profiled_retry_and_mark, Otapl); EMIT_ENTRY_BLOCK(PREG,PROFILED_RETRY_AND_MARK_INSTINIT); LOCK(((PredEntry *)(PREG->y_u.Otapl.p))->StatisticsForPred.lock); ((PredEntry *)(PREG->y_u.Otapl.p))->StatisticsForPred.NOfRetries++; @@ -1009,7 +1036,7 @@ CACHE_Y(YREG); ENDBOp(); /* retry_and_mark Label,NArgs */ - BOp(traced_retry_and_mark, Otapl); + BOp(retry_and_mark, Otapl); EMIT_ENTRY_BLOCK(PREG,RETRY_AND_MARK_INSTINIT); #ifdef YAPOR EMIT_SIMPLE_BLOCK(RETRY_AND_MARK_YAPOR); @@ -1058,7 +1085,7 @@ CACHE_Y(YREG); *****************************************************************/ /* trust_fail */ - BOp(traced_trust_fail, e); + BOp(trust_fail, e); EMIT_ENTRY_BLOCK(PREG,TRUST_FAIL_INSTINIT); #ifdef CUT_C { @@ -1081,19 +1108,19 @@ CACHE_Y(YREG); EMIT_SIMPLE_BLOCK(TRUST_FAIL_NOYAPOR); B = B->cp_b; #endif /* YAPOR */ - goto traced_fail; + goto fail; ENDBOp(); #ifdef YAPOR - traced_shared_fail: + shared_fail: EMIT_SIMPLE_BLOCK(LBL_SHARED_FAIL); B = Get_LOCAL_top_cp(); SET_BB(PROTECT_FROZEN_B(B)); - goto traced_fail; + goto fail; #endif /* YAPOR */ - /* traced_fail */ - PBOp(traced_op_fail, e); + /* fail */ + PBOp(op_fail, e); EMIT_ENTRY_BLOCK(PREG,OP_FAIL_INSTINIT); if (PP) { UNLOCK(PP->PELock); @@ -1106,7 +1133,7 @@ CACHE_Y(YREG); ENDCACHE_Y_AS_ENV(); #endif - traced_fail: + fail: { EMIT_ENTRY_BLOCK(PREG,LBL_FAIL_INSTINIT); register tr_fr_ptr pt0 = TR; @@ -1120,7 +1147,7 @@ CACHE_Y(YREG); save_pc(); CACHE_TR(B->cp_tr); PREFETCH_OP(PREG); - traced_failloop: + failloop: if (pt0 == S_TR) { SP = SP0; #ifdef LOW_LEVEL_TRACER @@ -1298,7 +1325,7 @@ CACHE_Y(YREG); /* normal variable */ RESET_VARIABLE(d1); } - goto traced_failloop; + goto failloop; } /* pointer to code space */ /* or updatable variable */ @@ -1314,7 +1341,7 @@ CACHE_Y(YREG); TrailTerm(pt0) = AbsPair((CELL *)(pt0 - 1)); SgFr_state(sg_fr)--; /* complete_in_use --> complete : compiled_in_use --> compiled */ insert_into_global_sg_fr_list(sg_fr); - goto traced_failloop; + goto failloop; } #endif /* LIMIT_TABLING */ #ifdef FROZEN_STACKS /* TRAIL */ @@ -1327,19 +1354,19 @@ CACHE_Y(YREG); ) { pt0 = (tr_fr_ptr) pt1; - goto traced_failloop; + goto failloop; } else #endif /* FROZEN_STACKS */ if (IN_BETWEEN(H0,pt1,HR)) { if (IsAttVar(pt1)) { - goto traced_failloop; + goto failloop; } else if (*pt1 == (CELL)FunctorBigInt) { Yap_CleanOpaqueVariable(pt1); } } #ifdef FROZEN_STACKS /* TRAIL */ if (pt0 < TR_FZ) { - goto traced_failloop; + goto failloop; } #endif flags = *pt1; @@ -1436,7 +1463,7 @@ CACHE_Y(YREG); } } #endif - goto traced_failloop; + goto failloop; } #ifdef MULTI_ASSIGNMENT_VARIABLES else /* if (IsApplTerm(d1)) */ { @@ -1448,7 +1475,7 @@ CACHE_Y(YREG); pt[0] = TrailTerm(pt0-1); pt0 -= 2; #endif /* FROZEN_STACKS */ - goto traced_failloop; + goto failloop; } #endif ENDD(d1); @@ -1463,7 +1490,7 @@ CACHE_Y(YREG); \************************************************************************/ /* cut */ -Op(traced_cut, s); +Op(cut, s); EMIT_ENTRY_BLOCK(PREG,CUT_INSTINIT); #ifdef COROUTINING EMIT_SIMPLE_BLOCK_TEST(CUT_COROUTINING); @@ -1486,7 +1513,7 @@ Op(traced_cut, s); /* cut_t */ /* cut_t does the same as cut */ - Op(traced_cut_t, s); + Op(cut_t, s); EMIT_ENTRY_BLOCK(PREG,CUT_T_INSTINIT); #ifdef COROUTINING EMIT_SIMPLE_BLOCK_TEST(CUT_T_COROUTINING); @@ -1501,14 +1528,14 @@ Op(traced_cut, s); SET_ASP(YREG, PREG->y_u.s.s); /* assume cut is always in stack */ saveregs(); - prune((choiceptr)YREG[E_CB]); +prune((choiceptr)YREG[E_CB]); setregs(); PREG = NEXTOP(NEXTOP(NEXTOP(PREG, s),Osbpp),l); GONext(); ENDOp(); /* cut_e */ - Op(traced_cut_e, s); + Op(cut_e, s); EMIT_ENTRY_BLOCK(PREG,CUT_E_INSTINIT); #ifdef COROUTINING EMIT_SIMPLE_BLOCK_TEST(CUT_E_COROUTINING); @@ -1529,7 +1556,7 @@ Op(traced_cut, s); ENDOp(); /* save_b_x Xi */ - Op(traced_save_b_x, x); + Op(save_b_x, x); EMIT_ENTRY_BLOCK(PREG,SAVE_B_X_INSTINIT); BEGD(d0); d0 = PREG->y_u.x.x; @@ -1547,7 +1574,7 @@ Op(traced_cut, s); ENDOp(); /* save_b_y Yi */ - Op(traced_save_b_y, y); + Op(save_b_y, y); EMIT_ENTRY_BLOCK(PREG,SAVE_B_Y_INSTINIT); #if defined(YAPOR_SBA) EMIT_SIMPLE_BLOCK_TEST(SAVE_B_Y_YSBA); @@ -1562,7 +1589,7 @@ Op(traced_cut, s); ENDOp(); /* commit_b_x Xi */ - Op(traced_commit_b_x, xps); + Op(commit_b_x, xps); EMIT_ENTRY_BLOCK(PREG,COMMIT_B_X_INSTINIT); #ifdef COROUTINING CACHE_Y_AS_ENV(YREG); @@ -1573,8 +1600,8 @@ Op(traced_cut, s); EMIT_SIMPLE_BLOCK_TEST(COMMIT_B_X_DO_COMMIT_B_X); BEGD(d0); d0 = XREG(PREG->y_u.xps.x); - profiled_deref_head_TEST(d0, traced_commit_b_x_unk); - traced_commit_b_x_nvar: + profiled_deref_head_TEST(d0, commit_b_x_unk); + commit_b_x_nvar: /* skip a void call and a label */ EMIT_SIMPLE_BLOCK_TEST(COMMIT_B_X_COMMIT_B_X_NVAR); SET_ASP(YREG, PREG->y_u.xps.s); @@ -1596,17 +1623,17 @@ Op(traced_cut, s); GONext(); BEGP(pt1); - profiled_deref_body(d0, pt1, traced_commit_b_x_unk, traced_commit_b_x_nvar); + profiled_deref_body(d0, pt1, commit_b_x_unk, commit_b_x_nvar); EMIT_SIMPLE_BLOCK_TEST(COMMIT_B_X_END); ENDP(pt1); /* never cut to a variable */ /* Abort */ - TRACED_FAIL(); + FAIL(); ENDD(d0); ENDOp(); /* commit_b_y Yi */ - Op(traced_commit_b_y, yps); + Op(commit_b_y, yps); EMIT_ENTRY_BLOCK(PREG,COMMIT_B_Y_INSTINIT); #ifdef COROUTINING CACHE_Y_AS_ENV(YREG); @@ -1617,8 +1644,8 @@ Op(traced_cut, s); EMIT_SIMPLE_BLOCK_TEST(COMMIT_B_Y_DO_COMMIT_B_Y); BEGD(d0); d0 = YREG[PREG->y_u.yps.y]; - profiled_deref_head_TEST(d0, traced_commit_b_y_unk); - traced_commit_b_y_nvar: + profiled_deref_head_TEST(d0, commit_b_y_unk); + commit_b_y_nvar: EMIT_SIMPLE_BLOCK_TEST(COMMIT_B_Y_COMMIT_B_Y_NVAR); SET_ASP(YREG, PREG->y_u.yps.s); PREG = NEXTOP(NEXTOP(NEXTOP(PREG, yps),Osbpp),l); @@ -1639,12 +1666,12 @@ Op(traced_cut, s); GONext(); BEGP(pt1); - profiled_deref_body(d0, pt1, traced_commit_b_y_unk, traced_commit_b_y_nvar); + profiled_deref_body(d0, pt1, commit_b_y_unk, commit_b_y_nvar); EMIT_SIMPLE_BLOCK_TEST(COMMIT_B_Y_END); ENDP(pt1); /* never cut to a variable */ /* Abort */ - TRACED_FAIL(); + FAIL(); ENDD(d0); ENDOp(); @@ -1655,7 +1682,7 @@ Op(traced_cut, s); /* Macros for stack trimming */ /* execute Label */ - BOp(traced_execute, pp); + BOp(execute, pp); { EMIT_ENTRY_BLOCK(PREG,EXECUTE_INSTINIT); PredEntry *pt0; @@ -1688,7 +1715,7 @@ Op(traced_cut, s); EMIT_SIMPLE_BLOCK_TEST(EXECUTE_DEPTH_MINOR); if (pt0->ModuleOfPred) { if (DEPTH == MkIntTerm(0)) { - TRACED_FAIL(); + FAIL(); } else { DEPTH = RESET_DEPTH(); @@ -1730,7 +1757,7 @@ Op(traced_cut, s); /* dexecute Label */ /* joint deallocate and execute */ - BOp(traced_dexecute, pp); + BOp(dexecute, pp); EMIT_ENTRY_BLOCK(PREG,DEXECUTE_INSTINIT); #ifdef LOW_LEVEL_TRACER if (Yap_do_low_level_trace) { @@ -1756,7 +1783,7 @@ Op(traced_cut, s); EMIT_SIMPLE_BLOCK_TEST(DEXECUTE_DEPTH_MINOR); if (pt0->ModuleOfPred) { if (DEPTH == MkIntTerm(0)) { - TRACED_FAIL(); + FAIL(); } else { DEPTH = RESET_DEPTH(); @@ -1815,7 +1842,7 @@ Op(traced_cut, s); ENDCACHE_Y_AS_ENV(); ENDBOp(); - BOp(traced_fcall, Osbpp); + BOp(fcall, Osbpp); CACHE_Y_AS_ENV(YREG); ENV_YREG[E_CP] = (CELL) CPREG; ENV_YREG[E_E] = (CELL) ENV; @@ -1825,7 +1852,7 @@ Op(traced_cut, s); ENDCACHE_Y_AS_ENV(); ENDBOp(); - BOp(traced_call, Osbpp); + BOp(call, Osbpp); EMIT_ENTRY_BLOCK(PREG,CALL_INSTINIT); #ifdef LOW_LEVEL_TRACER if (Yap_do_low_level_trace) { @@ -1858,7 +1885,7 @@ Op(traced_cut, s); EMIT_SIMPLE_BLOCK_TEST(CALL_DEPTH_MINOR); if (pt->ModuleOfPred) { if (DEPTH == MkIntTerm(0)){ - TRACED_FAIL(); + FAIL(); } else { DEPTH = RESET_DEPTH(); } @@ -1906,7 +1933,7 @@ Op(traced_cut, s); ENDCACHE_Y_AS_ENV(); ENDBOp(); - BOp(traced_procceed, p); + BOp(procceed, p); EMIT_ENTRY_BLOCK(PREG,PROCCEED_INSTINIT); CACHE_Y_AS_ENV(YREG); ALWAYS_LOOKAHEAD(CPREG->opc); @@ -1925,7 +1952,7 @@ Op(traced_cut, s); ENDCACHE_Y_AS_ENV(); ENDBOp(); - Op(traced_allocate, e); + Op(allocate, e); EMIT_ENTRY_BLOCK(PREG,ALLOCATE_INSTINIT); CACHE_Y_AS_ENV(YREG); PREG = NEXTOP(PREG, e); @@ -1941,7 +1968,7 @@ Op(traced_cut, s); GONext(); ENDOp(); - Op(traced_deallocate, p); + Op(deallocate, p); EMIT_ENTRY_BLOCK(PREG,DEALLOCATE_INSTINIT); EMIT_SIMPLE_BLOCK_TEST(YAAM_CHECK_TRAIL_TR); check_trail(TR); @@ -1995,12 +2022,12 @@ Op(traced_cut, s); - Op(traced_retry_eam, e); + Op(retry_eam, e); //goto retry_eam; { printf("EAM not supported by JIT!!\n"); exit(1); } ENDOp(); - Op(traced_run_eam, os); + Op(run_eam, os); { printf("EAM not supported by JIT!!\n"); exit(1); } //goto run_eam; ENDOp(); @@ -2009,7 +2036,7 @@ Op(traced_cut, s); * Get Instructions * \************************************************************************/ - Op(traced_get_x_var, xx); + Op(get_x_var, xx); EMIT_ENTRY_BLOCK(PREG,GET_X_VAR_INSTINIT); BEGD(d0); d0 = XREG(PREG->y_u.xx.xr); @@ -2019,7 +2046,7 @@ Op(traced_cut, s); GONext(); ENDOp(); - Op(traced_get_y_var, yx); + Op(get_y_var, yx); EMIT_ENTRY_BLOCK(PREG,GET_Y_VAR_INSTINIT); BEGD(d0); BEGP(pt0); @@ -2032,7 +2059,7 @@ Op(traced_cut, s); ENDD(d0); ENDOp(); - Op(traced_get_yy_var, yyxx); + Op(get_yy_var, yyxx); EMIT_ENTRY_BLOCK(PREG,GET_YY_VAR_INSTINIT); CACHE_Y(YREG); BEGD(d0); @@ -2058,30 +2085,30 @@ Op(traced_cut, s); * lot of jumps. The convention is that in the label * gval_X_YREG X refers to the state of the first argument, and * YREG to the state of the second argument */ - Op(traced_get_x_val, xx); + Op(get_x_val, xx); EMIT_ENTRY_BLOCK(PREG,GET_X_VAL_INSTINIT); BEGD(d0); d0 = XREG(PREG->y_u.xx.xl); - profiled_deref_head_TEST(d0, traced_gvalx_unk); + profiled_deref_head_TEST(d0, gvalx_unk); /* d0 will keep the first argument */ - traced_gvalx_nonvar: + gvalx_nonvar: /* first argument is bound */ EMIT_SIMPLE_BLOCK_TEST(GET_X_VAL_GVALX_NONVAR); BEGD(d1); d1 = XREG(PREG->y_u.xx.xr); - profiled_deref_head_TEST(d1, traced_gvalx_nonvar_unk); + profiled_deref_head_TEST(d1, gvalx_nonvar_unk); - traced_gvalx_nonvar_nonvar: + gvalx_nonvar_nonvar: /* both arguments are bound */ /* we may have to bind structures */ EMIT_MULTIPLE_DESTINY_BLOCK_TEST(GET_X_VAL_GVALX_NONVAR_NONVAR); PREG = NEXTOP(PREG, xx); - traced_UnifyBound(d0, d1); + UnifyBound(d0, d1); BEGP(pt0); /* deref second argument */ - profiled_deref_body(d1, pt0, traced_gvalx_nonvar_unk, traced_gvalx_nonvar_nonvar); + profiled_deref_body(d1, pt0, gvalx_nonvar_unk, gvalx_nonvar_nonvar); /* first argument bound, second unbound */ EMIT_MULTIPLE_DESTINY_BLOCK_TEST(GET_X_VAL_GVALX_NONVAR_UNK); PREG = NEXTOP(PREG, xx); @@ -2093,14 +2120,14 @@ Bind(pt0, d0); BEGP(pt0); /* first argument may be unbound */ - profiled_deref_body(d0, pt0, traced_gvalx_unk, traced_gvalx_nonvar); + profiled_deref_body(d0, pt0, gvalx_unk, gvalx_nonvar); /* first argument is unbound and in pt0 and in d0 */ EMIT_SIMPLE_BLOCK_TEST(GET_X_VAL_GVALX_UNK); BEGD(d1); d1 = XREG(PREG->y_u.xx.xr); - profiled_deref_head_TEST(d1, traced_gvalx_var_unk); + profiled_deref_head_TEST(d1, gvalx_var_unk); - traced_gvalx_var_nonvar: + gvalx_var_nonvar: /* first unbound, second bound */ EMIT_SIMPLE_BLOCK_TEST(GET_X_VAL_GVALX_VAR_NONVAR); PREG = NEXTOP(PREG, xx); @@ -2108,7 +2135,7 @@ Bind(pt0, d0); GONext(); BEGP(pt1); - profiled_deref_body(d1, pt1, traced_gvalx_var_unk, traced_gvalx_var_nonvar); + profiled_deref_body(d1, pt1, gvalx_var_unk, gvalx_var_nonvar); /* both arguments are unbound */ EMIT_SIMPLE_BLOCK_TEST(GET_X_VAL_GVALX_VAR_UNK); PREG = NEXTOP(PREG, xx); @@ -2123,7 +2150,7 @@ Bind(pt0, d0); /* The code for get_y_val mostly uses the code for get_x_val */ - Op(traced_get_y_val, yx); + Op(get_y_val, yx); EMIT_ENTRY_BLOCK(PREG,GET_Y_VAL_INSTINIT); BEGD(d0); BEGD(d1); @@ -2132,24 +2159,24 @@ Bind(pt0, d0); d0 = *pt0; /* From now on, it's just a copy of the code for get_x_val */ - profiled_deref_head_TEST(d0, traced_gvaly_unk); - traced_gvaly_nonvar: + profiled_deref_head_TEST(d0, gvaly_unk); + gvaly_nonvar: /* first argument is bound */ EMIT_SIMPLE_BLOCK_TEST(GET_Y_VAL_GVALY_NONVAR); d1 = XREG(PREG->y_u.yx.x); - profiled_deref_head_TEST(d1, traced_gvaly_nonvar_unk); + profiled_deref_head_TEST(d1, gvaly_nonvar_unk); - traced_gvaly_nonvar_nonvar: + gvaly_nonvar_nonvar: /* both arguments are bound */ /* we may have to bind structures */ EMIT_MULTIPLE_DESTINY_BLOCK_TEST(GET_Y_VAL_GVALY_NONVAR_NONVAR); PREG = NEXTOP(PREG, yx); - traced_UnifyBound(d0, d1); + UnifyBound(d0, d1); BEGP(pt1); /* deref second argument */ - profiled_deref_body(d1, pt1, traced_gvaly_nonvar_unk, traced_gvaly_nonvar_nonvar); + profiled_deref_body(d1, pt1, gvaly_nonvar_unk, gvaly_nonvar_nonvar); /* first argument bound, second unbound */ EMIT_SIMPLE_BLOCK_TEST(GET_Y_VAL_GVALY_NONVAR_UNK); PREG = NEXTOP(PREG, yx); @@ -2158,12 +2185,12 @@ Bind(pt0, d0); ENDP(pt1); /* first argument may be unbound */ - profiled_derefa_body(d0, pt0, traced_gvaly_unk, traced_gvaly_nonvar); + profiled_derefa_body(d0, pt0, gvaly_unk, gvaly_nonvar); /* first argument is unbound */ EMIT_SIMPLE_BLOCK_TEST(GET_Y_VAL_GVALY_UNK); d1 = XREG(PREG->y_u.yx.x); - profiled_deref_head_TEST(d1, traced_gvaly_var_unk); - traced_gvaly_var_nonvar: + profiled_deref_head_TEST(d1, gvaly_var_unk); + gvaly_var_nonvar: /* first unbound, second bound */ EMIT_SIMPLE_BLOCK_TEST(GET_Y_VAL_GVALY_VAR_NONVAR); PREG = NEXTOP(PREG, yx); @@ -2171,7 +2198,7 @@ Bind(pt0, d0); GONext(); BEGP(pt1); - profiled_deref_body(d1, pt1, traced_gvaly_var_unk, traced_gvaly_var_nonvar); + profiled_deref_body(d1, pt1, gvaly_var_unk, gvaly_var_nonvar); /* both arguments are unbound */ EMIT_SIMPLE_BLOCK_TEST(GET_Y_VAL_GVALY_VAR_UNK); PREG = NEXTOP(PREG, yx); @@ -2183,7 +2210,7 @@ Bind(pt0, d0); ENDD(d0); ENDOp(); - Op(traced_get_atom, xc); + Op(get_atom, xc); EMIT_ENTRY_BLOCK(PREG,GET_ATOM_INSTINIT); BEGD(d0); BEGD(d1); @@ -2192,19 +2219,19 @@ Bind(pt0, d0); d1 = PREG->y_u.xc.c; BEGP(pt0); - profiled_deref_head_TEST(d0, traced_gatom_unk); + profiled_deref_head_TEST(d0, gatom_unk); /* argument is nonvar */ - traced_gatom_nonvar: + gatom_nonvar: EMIT_MULTIPLE_DESTINY_BLOCK_TEST(GET_ATOM_GATOM_NONVAR); if (d0 == d1) { PREG = NEXTOP(PREG, xc); GONext(); } else { - TRACED_FAIL(); + FAIL(); } - profiled_deref_body(d0, pt0, traced_gatom_unk, traced_gatom_nonvar); + profiled_deref_body(d0, pt0, gatom_unk, gatom_nonvar); /* argument is a variable */ EMIT_SIMPLE_BLOCK_TEST(GET_ATOM_GATOM_UNK); PREG = NEXTOP(PREG, xc); @@ -2215,7 +2242,7 @@ Bind(pt0, d0); ENDD(d0); ENDOp(); - Op(traced_get_2atoms, cc); + Op(get_2atoms, cc); EMIT_ENTRY_BLOCK(PREG,GET_2ATOMS_INSTINIT); BEGD(d0); BEGD(d1); @@ -2223,40 +2250,40 @@ Bind(pt0, d0); d0 = ARG1; BEGP(pt0); - profiled_deref_head_TEST(d0, traced_gatom_2unk); + profiled_deref_head_TEST(d0, gatom_2unk); /* argument is nonvar */ - traced_gatom_2nonvar: + gatom_2nonvar: if (d0 == PREG->y_u.cc.c1) { - goto traced_gatom_2b; + goto gatom_2b; } else { - TRACED_FAIL(); + FAIL(); } - profiled_deref_body(d0, pt0, traced_gatom_2unk, traced_gatom_2nonvar); + profiled_deref_body(d0, pt0, gatom_2unk, gatom_2nonvar); EMIT_SIMPLE_BLOCK_TEST(GET_2ATOMS_GATOM_2UNK); Bind(pt0, PREG->y_u.cc.c1); ENDP(pt0); - traced_gatom_2b: + gatom_2b: /* fetch arguments */ EMIT_SIMPLE_BLOCK_TEST(GET_2ATOMS_GATOM_2B); d0 = ARG2; d1 = PREG->y_u.cc.c2; BEGP(pt0); - profiled_deref_head_TEST(d0, traced_gatom_2bunk); + profiled_deref_head_TEST(d0, gatom_2bunk); /* argument is nonvar */ - traced_gatom_2bnonvar: + gatom_2bnonvar: EMIT_SIMPLE_BLOCK_TEST(GET_2ATOMS_GATOM_2BNONVAR); if (d0 == d1) { PREG = NEXTOP(PREG, cc); GONext(); } else { - TRACED_FAIL(); + FAIL(); } - profiled_deref_body(d0, pt0, traced_gatom_2bunk, traced_gatom_2bnonvar); + profiled_deref_body(d0, pt0, gatom_2bunk, gatom_2bnonvar); /* argument is a variable */ EMIT_SIMPLE_BLOCK_TEST(GET_2ATOMS_GATOM_2BUNK); PREG = NEXTOP(PREG, cc); @@ -2267,7 +2294,7 @@ Bind(pt0, d0); ENDD(d0); ENDOp(); - Op(traced_get_3atoms, ccc); + Op(get_3atoms, ccc); EMIT_ENTRY_BLOCK(PREG,GET_3ATOMS_INSTINIT); BEGD(d0); BEGD(d1); @@ -2275,62 +2302,62 @@ Bind(pt0, d0); d0 = ARG1; BEGP(pt0); - profiled_deref_head_TEST(d0, traced_gatom_3unk); + profiled_deref_head_TEST(d0, gatom_3unk); /* argument is nonvar */ - traced_gatom_3nonvar: + gatom_3nonvar: if (d0 == PREG->y_u.ccc.c1) { - goto traced_gatom_3b; + goto gatom_3b; } else { - TRACED_FAIL(); + FAIL(); } - profiled_deref_body(d0, pt0, traced_gatom_3unk, traced_gatom_3nonvar); + profiled_deref_body(d0, pt0, gatom_3unk, gatom_3nonvar); /* argument is a variable */ EMIT_SIMPLE_BLOCK_TEST(GET_3ATOMS_GATOM_3UNK); Bind(pt0, PREG->y_u.ccc.c1); ENDP(pt0); - traced_gatom_3b: + gatom_3b: /* fetch arguments */ EMIT_SIMPLE_BLOCK_TEST(GET_3ATOMS_GATOM_3B); d0 = ARG2; BEGP(pt0); - profiled_deref_head_TEST(d0, traced_gatom_3bunk); + profiled_deref_head_TEST(d0, gatom_3bunk); /* argument is nonvar */ - traced_gatom_3bnonvar: + gatom_3bnonvar: if (d0 == PREG->y_u.ccc.c2) { - goto traced_gatom_3c; + goto gatom_3c; } else { - TRACED_FAIL(); + FAIL(); } - profiled_deref_body(d0, pt0, traced_gatom_3bunk, traced_gatom_3bnonvar); + profiled_deref_body(d0, pt0, gatom_3bunk, gatom_3bnonvar); /* argument is a variable */ EMIT_SIMPLE_BLOCK_TEST(GET_3ATOMS_GATOM_3BUNK); Bind(pt0, PREG->y_u.ccc.c2); ENDP(pt0); - traced_gatom_3c: + gatom_3c: /* fetch arguments */ EMIT_SIMPLE_BLOCK_TEST(GET_3ATOMS_GATOM_3C); d0 = ARG3; d1 = PREG->y_u.ccc.c3; BEGP(pt0); - profiled_deref_head_TEST(d0, traced_gatom_3cunk); + profiled_deref_head_TEST(d0, gatom_3cunk); /* argument is nonvar */ - traced_gatom_3cnonvar: + gatom_3cnonvar: EMIT_SIMPLE_BLOCK_TEST(GET_3ATOMS_GATOM_3CNONVAR); if (d0 == d1) { PREG = NEXTOP(PREG, ccc); GONext(); } else { - TRACED_FAIL(); + FAIL(); } - profiled_deref_body(d0, pt0, traced_gatom_3cunk, traced_gatom_3cnonvar); + profiled_deref_body(d0, pt0, gatom_3cunk, gatom_3cnonvar); /* argument is a variable */ EMIT_SIMPLE_BLOCK_TEST(GET_3ATOMS_GATOM_3CUNK); PREG = NEXTOP(PREG, ccc); @@ -2341,7 +2368,7 @@ Bind(pt0, d0); ENDD(d0); ENDOp(); - Op(traced_get_4atoms, cccc); + Op(get_4atoms, cccc); EMIT_ENTRY_BLOCK(PREG,GET_4ATOMS_INSTINIT); BEGD(d0); BEGD(d1); @@ -2349,83 +2376,83 @@ Bind(pt0, d0); d0 = ARG1; BEGP(pt0); - profiled_deref_head_TEST(d0, traced_gatom_4unk); + profiled_deref_head_TEST(d0, gatom_4unk); /* argument is nonvar */ - traced_gatom_4nonvar: + gatom_4nonvar: if (d0 == PREG->y_u.cccc.c1) { - goto traced_gatom_4b; + goto gatom_4b; } else { - TRACED_FAIL(); + FAIL(); } - profiled_deref_body(d0, pt0, traced_gatom_4unk, traced_gatom_4nonvar); + profiled_deref_body(d0, pt0, gatom_4unk, gatom_4nonvar); /* argument is a variable */ EMIT_SIMPLE_BLOCK_TEST(GET_4ATOMS_GATOM_4UNK); Bind(pt0, PREG->y_u.cccc.c1); ENDP(pt0); - traced_gatom_4b: + gatom_4b: /* fetch arguments */ EMIT_SIMPLE_BLOCK_TEST(GET_4ATOMS_GATOM_4B); d0 = ARG2; BEGP(pt0); - profiled_deref_head_TEST(d0, traced_gatom_4bunk); + profiled_deref_head_TEST(d0, gatom_4bunk); /* argument is nonvar */ - traced_gatom_4bnonvar: + gatom_4bnonvar: if (d0 == PREG->y_u.cccc.c2) { - goto traced_gatom_4c; + goto gatom_4c; } else { - TRACED_FAIL(); + FAIL(); } - profiled_deref_body(d0, pt0, traced_gatom_4bunk, traced_gatom_4bnonvar); + profiled_deref_body(d0, pt0, gatom_4bunk, gatom_4bnonvar); /* argument is a variable */ EMIT_SIMPLE_BLOCK_TEST(GET_4ATOMS_GATOM_4BUNK); Bind(pt0, PREG->y_u.cccc.c2); ENDP(pt0); - traced_gatom_4c: + gatom_4c: /* fetch arguments */ EMIT_SIMPLE_BLOCK_TEST(GET_4ATOMS_GATOM_4C); d0 = ARG3; BEGP(pt0); - profiled_deref_head_TEST(d0, traced_gatom_4cunk); + profiled_deref_head_TEST(d0, gatom_4cunk); /* argument is nonvar */ - traced_gatom_4cnonvar: + gatom_4cnonvar: if (d0 == PREG->y_u.cccc.c3) { - goto traced_gatom_4d; + goto gatom_4d; } else { - TRACED_FAIL(); + FAIL(); } - profiled_deref_body(d0, pt0, traced_gatom_4cunk, traced_gatom_4cnonvar); + profiled_deref_body(d0, pt0, gatom_4cunk, gatom_4cnonvar); /* argument is a variable */ EMIT_SIMPLE_BLOCK_TEST(GET_4ATOMS_GATOM_4CUNK); Bind(pt0, PREG->y_u.cccc.c3); ENDP(pt0); - traced_gatom_4d: + gatom_4d: /* fetch arguments */ EMIT_SIMPLE_BLOCK_TEST(GET_4ATOMS_GATOM_4D); d0 = ARG4; d1 = PREG->y_u.cccc.c4; BEGP(pt0); - profiled_deref_head_TEST(d0, traced_gatom_4dunk); + profiled_deref_head_TEST(d0, gatom_4dunk); /* argument is nonvar */ - traced_gatom_4dnonvar: + gatom_4dnonvar: EMIT_SIMPLE_BLOCK_TEST(GET_4ATOMS_GATOM_4DNONVAR); if (d0 == d1) { PREG = NEXTOP(PREG, cccc); GONext(); } else { - TRACED_FAIL(); + FAIL(); } - profiled_deref_body(d0, pt0, traced_gatom_4dunk, traced_gatom_4dnonvar); + profiled_deref_body(d0, pt0, gatom_4dunk, gatom_4dnonvar); /* argument is a variable */ EMIT_SIMPLE_BLOCK_TEST(GET_4ATOMS_GATOM_4DUNK); PREG = NEXTOP(PREG, cccc); @@ -2436,7 +2463,7 @@ Bind(pt0, d0); ENDD(d0); ENDOp(); - Op(traced_get_5atoms, ccccc); + Op(get_5atoms, ccccc); EMIT_ENTRY_BLOCK(PREG,GET_5ATOMS_INSTINIT); BEGD(d0); BEGD(d1); @@ -2444,104 +2471,104 @@ Bind(pt0, d0); d0 = ARG1; BEGP(pt0); - profiled_deref_head_TEST(d0, traced_gatom_5unk); + profiled_deref_head_TEST(d0, gatom_5unk); /* argument is nonvar */ - traced_gatom_5nonvar: + gatom_5nonvar: if (d0 == PREG->y_u.ccccc.c1) { - goto traced_gatom_5b; + goto gatom_5b; } else { - TRACED_FAIL(); + FAIL(); } - profiled_deref_body(d0, pt0, traced_gatom_5unk, traced_gatom_5nonvar); + profiled_deref_body(d0, pt0, gatom_5unk, gatom_5nonvar); /* argument is a variable */ EMIT_SIMPLE_BLOCK_TEST(GET_5ATOMS_GATOM_5UNK); Bind(pt0, PREG->y_u.ccccc.c1); ENDP(pt0); - traced_gatom_5b: + gatom_5b: /* fetch arguments */ EMIT_SIMPLE_BLOCK_TEST(GET_5ATOMS_GATOM_5B); d0 = ARG2; BEGP(pt0); - profiled_deref_head_TEST(d0, traced_gatom_5bunk); + profiled_deref_head_TEST(d0, gatom_5bunk); /* argument is nonvar */ - traced_gatom_5bnonvar: + gatom_5bnonvar: if (d0 == PREG->y_u.ccccc.c2) { - goto traced_gatom_5c; + goto gatom_5c; } else { - TRACED_FAIL(); + FAIL(); } - profiled_deref_body(d0, pt0, traced_gatom_5bunk, traced_gatom_5bnonvar); + profiled_deref_body(d0, pt0, gatom_5bunk, gatom_5bnonvar); /* argument is a variable */ EMIT_SIMPLE_BLOCK_TEST(GET_5ATOMS_GATOM_5BUNK); Bind(pt0, PREG->y_u.ccccc.c2); ENDP(pt0); - traced_gatom_5c: + gatom_5c: /* fetch arguments */ EMIT_SIMPLE_BLOCK_TEST(GET_5ATOMS_GATOM_5C); d0 = ARG3; BEGP(pt0); - profiled_deref_head_TEST(d0, traced_gatom_5cunk); + profiled_deref_head_TEST(d0, gatom_5cunk); /* argument is nonvar */ - traced_gatom_5cnonvar: + gatom_5cnonvar: if (d0 == PREG->y_u.ccccc.c3) { - goto traced_gatom_5d; + goto gatom_5d; } else { - TRACED_FAIL(); + FAIL(); } - profiled_deref_body(d0, pt0, traced_gatom_5cunk, traced_gatom_5cnonvar); + profiled_deref_body(d0, pt0, gatom_5cunk, gatom_5cnonvar); /* argument is a variable */ EMIT_SIMPLE_BLOCK_TEST(GET_5ATOMS_GATOM_5CUNK); Bind(pt0, PREG->y_u.ccccc.c3); ENDP(pt0); - traced_gatom_5d: + gatom_5d: /* fetch arguments */ EMIT_SIMPLE_BLOCK_TEST(GET_5ATOMS_GATOM_5D); d0 = ARG4; BEGP(pt0); - profiled_deref_head_TEST(d0, traced_gatom_5dunk); + profiled_deref_head_TEST(d0, gatom_5dunk); /* argument is nonvar */ - traced_gatom_5dnonvar: + gatom_5dnonvar: if (d0 == PREG->y_u.ccccc.c4) { - goto traced_gatom_5e; + goto gatom_5e; } else { - TRACED_FAIL(); + FAIL(); } - profiled_deref_body(d0, pt0, traced_gatom_5dunk, traced_gatom_5dnonvar); + profiled_deref_body(d0, pt0, gatom_5dunk, gatom_5dnonvar); /* argument is a variable */ EMIT_SIMPLE_BLOCK_TEST(GET_5ATOMS_GATOM_5DUNK); Bind(pt0, PREG->y_u.ccccc.c4); ENDP(pt0); - traced_gatom_5e: + gatom_5e: /* fetch arguments */ EMIT_SIMPLE_BLOCK_TEST(GET_5ATOMS_GATOM_5E); d0 = ARG5; d1 = PREG->y_u.ccccc.c5; BEGP(pt0); - profiled_deref_head_TEST(d0, traced_gatom_5eunk); + profiled_deref_head_TEST(d0, gatom_5eunk); /* argument is nonvar */ - traced_gatom_5enonvar: + gatom_5enonvar: EMIT_SIMPLE_BLOCK_TEST(GET_5ATOMS_GATOM_5ENONVAR); if (d0 == d1) { PREG = NEXTOP(PREG, ccccc); GONext(); } else { - TRACED_FAIL(); + FAIL(); } - profiled_deref_body(d0, pt0, traced_gatom_5eunk, traced_gatom_5enonvar); + profiled_deref_body(d0, pt0, gatom_5eunk, gatom_5enonvar); /* argument is a variable */ EMIT_SIMPLE_BLOCK_TEST(GET_5ATOMS_GATOM_5EUNK); PREG = NEXTOP(PREG, ccccc); @@ -2552,7 +2579,7 @@ Bind(pt0, d0); ENDD(d0); ENDOp(); - Op(traced_get_6atoms, cccccc); + Op(get_6atoms, cccccc); EMIT_ENTRY_BLOCK(PREG,GET_6ATOMS_INSTINIT); BEGD(d0); BEGD(d1); @@ -2560,125 +2587,125 @@ Bind(pt0, d0); d0 = ARG1; BEGP(pt0); - profiled_deref_head_TEST(d0, traced_gatom_6unk); + profiled_deref_head_TEST(d0, gatom_6unk); /* argument is nonvar */ - traced_gatom_6nonvar: + gatom_6nonvar: if (d0 == PREG->y_u.cccccc.c1) { - goto traced_gatom_6b; + goto gatom_6b; } else { - TRACED_FAIL(); + FAIL(); } - profiled_deref_body(d0, pt0, traced_gatom_6unk, traced_gatom_6nonvar); + profiled_deref_body(d0, pt0, gatom_6unk, gatom_6nonvar); /* argument is a variable */ EMIT_SIMPLE_BLOCK_TEST(GET_6ATOMS_GATOM_6UNK); Bind(pt0, PREG->y_u.cccccc.c1); ENDP(pt0); - traced_gatom_6b: + gatom_6b: /* fetch arguments */ EMIT_SIMPLE_BLOCK_TEST(GET_6ATOMS_GATOM_6B); d0 = ARG2; BEGP(pt0); - profiled_deref_head_TEST(d0, traced_gatom_6bunk); + profiled_deref_head_TEST(d0, gatom_6bunk); /* argument is nonvar */ - traced_gatom_6bnonvar: + gatom_6bnonvar: if (d0 == PREG->y_u.cccccc.c2) { - goto traced_gatom_6c; + goto gatom_6c; } else { - TRACED_FAIL(); + FAIL(); } - profiled_deref_body(d0, pt0, traced_gatom_6bunk, traced_gatom_6bnonvar); + profiled_deref_body(d0, pt0, gatom_6bunk, gatom_6bnonvar); /* argument is a variable */ EMIT_SIMPLE_BLOCK_TEST(GET_6ATOMS_GATOM_6BUNK); Bind(pt0, PREG->y_u.cccccc.c2); ENDP(pt0); - traced_gatom_6c: + gatom_6c: /* fetch arguments */ EMIT_SIMPLE_BLOCK_TEST(GET_6ATOMS_GATOM_6C); d0 = ARG3; BEGP(pt0); - profiled_deref_head_TEST(d0, traced_gatom_6cunk); + profiled_deref_head_TEST(d0, gatom_6cunk); /* argument is nonvar */ - traced_gatom_6cnonvar: + gatom_6cnonvar: if (d0 == PREG->y_u.cccccc.c3) { - goto traced_gatom_6d; + goto gatom_6d; } else { - TRACED_FAIL(); + FAIL(); } - profiled_deref_body(d0, pt0, traced_gatom_6cunk, traced_gatom_6cnonvar); + profiled_deref_body(d0, pt0, gatom_6cunk, gatom_6cnonvar); /* argument is a variable */ EMIT_SIMPLE_BLOCK_TEST(GET_6ATOMS_GATOM_6CUNK); Bind(pt0, PREG->y_u.cccccc.c3); ENDP(pt0); - traced_gatom_6d: + gatom_6d: /* fetch arguments */ EMIT_SIMPLE_BLOCK_TEST(GET_6ATOMS_GATOM_6D); d0 = ARG4; BEGP(pt0); - profiled_deref_head_TEST(d0, traced_gatom_6dunk); + profiled_deref_head_TEST(d0, gatom_6dunk); /* argument is nonvar */ - traced_gatom_6dnonvar: + gatom_6dnonvar: if (d0 == PREG->y_u.cccccc.c4) { - goto traced_gatom_6e; + goto gatom_6e; } else { - TRACED_FAIL(); + FAIL(); } - profiled_deref_body(d0, pt0, traced_gatom_6dunk, traced_gatom_6dnonvar); + profiled_deref_body(d0, pt0, gatom_6dunk, gatom_6dnonvar); /* argument is a variable */ EMIT_SIMPLE_BLOCK_TEST(GET_6ATOMS_GATOM_6DUNK); Bind(pt0, PREG->y_u.cccccc.c4); ENDP(pt0); - traced_gatom_6e: + gatom_6e: /* fetch arguments */ EMIT_SIMPLE_BLOCK_TEST(GET_6ATOMS_GATOM_6E); d0 = ARG5; BEGP(pt0); - profiled_deref_head_TEST(d0, traced_gatom_6eunk); + profiled_deref_head_TEST(d0, gatom_6eunk); /* argument is nonvar */ - traced_gatom_6enonvar: + gatom_6enonvar: if (d0 == PREG->y_u.cccccc.c5) { - goto traced_gatom_6f; + goto gatom_6f; } else { - TRACED_FAIL(); + FAIL(); } - profiled_deref_body(d0, pt0, traced_gatom_6eunk, traced_gatom_6enonvar); + profiled_deref_body(d0, pt0, gatom_6eunk, gatom_6enonvar); /* argument is a variable */ EMIT_SIMPLE_BLOCK_TEST(GET_6ATOMS_GATOM_6EUNK); Bind(pt0, PREG->y_u.cccccc.c5); ENDP(pt0); - traced_gatom_6f: + gatom_6f: /* fetch arguments */ EMIT_SIMPLE_BLOCK_TEST(GET_6ATOMS_GATOM_6F); d0 = ARG6; d1 = PREG->y_u.cccccc.c6; BEGP(pt0); - profiled_deref_head_TEST(d0, traced_gatom_6funk); + profiled_deref_head_TEST(d0, gatom_6funk); /* argument is nonvar */ - traced_gatom_6fnonvar: + gatom_6fnonvar: EMIT_SIMPLE_BLOCK_TEST(GET_6ATOMS_GATOM_6FNONVAR); if (d0 == d1) { PREG = NEXTOP(PREG, cccccc); GONext(); } else { - TRACED_FAIL(); + FAIL(); } - profiled_deref_body(d0, pt0, traced_gatom_6funk, traced_gatom_6fnonvar); + profiled_deref_body(d0, pt0, gatom_6funk, gatom_6fnonvar); /* argument is a variable */ EMIT_SIMPLE_BLOCK_TEST(GET_6ATOMS_GATOM_6FUNK); PREG = NEXTOP(PREG, cccccc); @@ -2692,17 +2719,17 @@ Bind(pt0, d0); /* The next instructions can lead to either the READ stream * or the write stream */ - OpRW(traced_get_list, x); + OpRW(get_list, x); EMIT_ENTRY_BLOCK(PREG,GET_LIST_INSTINIT); BEGD(d0); d0 = XREG(PREG->y_u.x.x); - profiled_deref_head_TEST(d0, traced_glist_unk); + profiled_deref_head_TEST(d0, glist_unk); - traced_glist_nonvar: + glist_nonvar: /* did we find a list? */ EMIT_MULTIPLE_DESTINY_BLOCK_TEST(GET_LIST_GLIST_NONVAR); if (!IsPairTerm(d0)) { - TRACED_FAIL(); + FAIL(); } START_PREFETCH(x); PREG = NEXTOP(PREG, x); @@ -2712,7 +2739,7 @@ Bind(pt0, d0); END_PREFETCH(); BEGP(pt0); - profiled_deref_body(d0, pt0, traced_glist_unk, traced_glist_nonvar); + profiled_deref_body(d0, pt0, glist_unk, glist_nonvar); /* glist var */ /* enter write mode */ EMIT_SIMPLE_BLOCK_TEST(GET_LIST_GLIST_UNK); @@ -2738,16 +2765,16 @@ Bind(pt0, d0); ENDD(d0); ENDOpRW(); - OpRW(traced_get_struct, xfa); + OpRW(get_struct, xfa); EMIT_ENTRY_BLOCK(PREG,GET_STRUCT_INSTINIT); BEGD(d0); d0 = XREG(PREG->y_u.xfa.x); - profiled_deref_head_TEST(d0, traced_gstruct_unk); + profiled_deref_head_TEST(d0, gstruct_unk); - traced_gstruct_nonvar: + gstruct_nonvar: EMIT_MULTIPLE_DESTINY_BLOCK_TEST(GET_STRUCT_GSTRUCT_NONVAR); if (!IsApplTerm(d0)) { - TRACED_FAIL(); + FAIL(); } /* we have met a compound term */ START_PREFETCH(xfa); @@ -2756,7 +2783,7 @@ S_SREG = RepAppl(d0); /* check functor */ d0 = (CELL) (PREG->y_u.xfa.f); if (*S_SREG != d0) { - TRACED_FAIL(); + FAIL(); } WRITEBACK_S(S_SREG+1); ENDCACHE_S(); @@ -2766,7 +2793,7 @@ S_SREG = RepAppl(d0); END_PREFETCH(); BEGP(pt0); - profiled_deref_body(d0, pt0, traced_gstruct_unk, traced_gstruct_nonvar); + profiled_deref_body(d0, pt0, gstruct_unk, gstruct_nonvar); /* Enter Write mode */ /* set d1 to be the new structure we are going to create */ EMIT_SIMPLE_BLOCK_TEST(GET_STRUCT_GSTRUCT_UNK); @@ -2793,16 +2820,16 @@ S_SREG = RepAppl(d0); ENDD(d0); ENDOpRW(); - Op(traced_get_float, xd); + Op(get_float, xd); EMIT_ENTRY_BLOCK(PREG,GET_FLOAT_INSTINIT); BEGD(d0); d0 = XREG(PREG->y_u.xd.x); - profiled_deref_head_TEST(d0, traced_gfloat_unk); + profiled_deref_head_TEST(d0, gfloat_unk); - traced_gfloat_nonvar: + gfloat_nonvar: EMIT_MULTIPLE_DESTINY_BLOCK_TEST(GET_FLOAT_GFLOAT_NONVAR); if (!IsApplTerm(d0)) { - TRACED_FAIL(); + FAIL(); } /* we have met a preexisting float */ START_PREFETCH(xd); @@ -2810,7 +2837,7 @@ S_SREG = RepAppl(d0); pt0 = RepAppl(d0); /* check functor */ if (*pt0 != (CELL)FunctorDouble) { - TRACED_FAIL(); + FAIL(); } BEGP(pt1); pt1 = PREG->y_u.xd.d; @@ -2821,7 +2848,7 @@ S_SREG = RepAppl(d0); || pt1[2] != pt0[2] #endif ) { - TRACED_FAIL(); + FAIL(); } ENDP(pt1); ENDP(pt0); @@ -2830,7 +2857,7 @@ S_SREG = RepAppl(d0); END_PREFETCH(); BEGP(pt0); - profiled_deref_body(d0, pt0, traced_gfloat_unk, traced_gfloat_nonvar); + profiled_deref_body(d0, pt0, gfloat_unk, gfloat_nonvar); /* Enter Write mode */ /* set d1 to be the new structure we are going to create */ EMIT_SIMPLE_BLOCK_TEST(GET_FLOAT_GFLOAT_UNK); @@ -2847,16 +2874,16 @@ S_SREG = RepAppl(d0); ENDD(d0); ENDOp(); - Op(traced_get_longint, xi); + Op(get_longint, xi); EMIT_ENTRY_BLOCK(PREG,GET_LONGINT_INSTINIT); BEGD(d0); d0 = XREG(PREG->y_u.xi.x); - profiled_deref_head_TEST(d0, traced_glongint_unk); + profiled_deref_head_TEST(d0, glongint_unk); - traced_glongint_nonvar: + glongint_nonvar: EMIT_SIMPLE_BLOCK_TEST(GET_LONGINT_GLONGINT_NONVAR); if (!IsApplTerm(d0)) { - TRACED_FAIL(); + FAIL(); } /* we have met a preexisting longint */ START_PREFETCH(xi); @@ -2864,10 +2891,10 @@ S_SREG = RepAppl(d0); pt0 = RepAppl(d0); /* check functor */ if (*pt0 != (CELL)FunctorLongInt) { - TRACED_FAIL(); + FAIL(); } if (PREG->y_u.xi.i[1] != (CELL)pt0[1]) { - TRACED_FAIL(); + FAIL(); } ENDP(pt0); PREG = NEXTOP(PREG, xi); @@ -2876,7 +2903,7 @@ S_SREG = RepAppl(d0); END_PREFETCH(); BEGP(pt0); - profiled_deref_body(d0, pt0, traced_glongint_unk, traced_glongint_nonvar); + profiled_deref_body(d0, pt0, glongint_unk, glongint_nonvar); /* Enter Write mode */ /* set d1 to be the new structure we are going to create */ EMIT_SIMPLE_BLOCK_TEST(GET_LONGINT_GLONGINT_UNK); @@ -2893,17 +2920,17 @@ S_SREG = RepAppl(d0); ENDD(d0); ENDOp(); - Op(traced_get_bigint, xN); + Op(get_bigint, xN); #ifdef USE_GMP EMIT_ENTRY_BLOCK(PREG,GET_BIGINT_INSTINIT); BEGD(d0); d0 = XREG(PREG->y_u.xN.x); - profiled_deref_head_TEST(d0, traced_gbigint_unk); + profiled_deref_head_TEST(d0, gbigint_unk); - traced_gbigint_nonvar: + gbigint_nonvar: EMIT_SIMPLE_BLOCK_TEST(GET_BIGINT_GBIGINT_NONVAR); if (!IsApplTerm(d0)) { - TRACED_FAIL(); + FAIL(); } /* we have met a preexisting bigint */ START_PREFETCH(xN); @@ -2912,10 +2939,10 @@ S_SREG = RepAppl(d0); /* check functor */ if (*pt0 != (CELL)FunctorBigInt) { - TRACED_FAIL(); + FAIL(); } if (Yap_gmp_tcmp_big_big(d0,PREG->y_u.xN.b)) { - TRACED_FAIL(); + FAIL(); } PREG = NEXTOP(PREG, xN); ENDP(pt0); @@ -2924,7 +2951,7 @@ S_SREG = RepAppl(d0); END_PREFETCH(); BEGP(pt0); - profiled_deref_body(d0, pt0, traced_gbigint_unk, traced_gbigint_nonvar); + profiled_deref_body(d0, pt0, gbigint_unk, gbigint_nonvar); /* Enter Write mode */ /* set d1 to be the new structure we are going to create */ EMIT_SIMPLE_BLOCK_TEST(GET_BIGINT_GBIGINT_UNK); @@ -2940,28 +2967,28 @@ S_SREG = RepAppl(d0); ENDD(d0); #else - TRACED_FAIL(); + FAIL(); #endif ENDOp(); - Op(traced_get_dbterm, xD); + Op(get_dbterm, xD); EMIT_ENTRY_BLOCK(PREG,GET_DBTERM_INSTINIT); BEGD(d0); d0 = XREG(PREG->y_u.xD.x); - profiled_deref_head_TEST(d0, traced_gdbterm_unk); + profiled_deref_head_TEST(d0, gdbterm_unk); - traced_gdbterm_nonvar: + gdbterm_nonvar: BEGD(d1); /* we have met a preexisting dbterm */ EMIT_MULTIPLE_DESTINY_BLOCK_TEST(GET_DBTERM_GDBTERM_NONVAR); d1 = PREG->y_u.xD.D; PREG = NEXTOP(PREG, xD); - traced_UnifyBound(d0,d1); + UnifyBound(d0,d1); ENDD(d1); BEGP(pt0); - profiled_deref_body(d0, pt0, traced_gdbterm_unk, traced_gdbterm_nonvar); + profiled_deref_body(d0, pt0, gdbterm_unk, gdbterm_nonvar); /* Enter Write mode */ /* set d1 to be the new structure we are going to create */ EMIT_SIMPLE_BLOCK_TEST(GET_DBTERM_GDBTERM_UNK); @@ -2981,17 +3008,17 @@ S_SREG = RepAppl(d0); /************************************************************************\ * Optimised Get List Instructions * \************************************************************************/ - OpRW(traced_glist_valx, xx); + OpRW(glist_valx, xx); EMIT_ENTRY_BLOCK(PREG,GLIST_VALX_INSTINIT); BEGD(d0); d0 = XREG(PREG->y_u.xx.xl); - profiled_deref_head_TEST(d0, traced_glist_valx_write); - traced_glist_valx_read: + profiled_deref_head_TEST(d0, glist_valx_write); + glist_valx_read: BEGP(pt0); /* did we find a list? */ EMIT_MULTIPLE_DESTINY_BLOCK_TEST(GLIST_VALX_GLIST_VALX_READ); if (!IsPairTerm(d0)) { - TRACED_FAIL(); + FAIL(); } /* enter read mode */ START_PREFETCH(xx); @@ -2999,26 +3026,26 @@ S_SREG = RepAppl(d0); SREG = pt0 + 1; /* start unification with first argument */ d0 = *pt0; - profiled_deref_head_TEST(d0, traced_glist_valx_unk); + profiled_deref_head_TEST(d0, glist_valx_unk); /* first argument is in d0 */ - traced_glist_valx_nonvar: + glist_valx_nonvar: /* first argument is bound */ EMIT_SIMPLE_BLOCK_TEST(GLIST_VALX_GLIST_VALX_NONVAR); BEGD(d1); d1 = XREG(PREG->y_u.xx.xr); - profiled_deref_head_TEST(d1, traced_glist_valx_nonvar_unk); + profiled_deref_head_TEST(d1, glist_valx_nonvar_unk); - traced_glist_valx_nonvar_nonvar: + glist_valx_nonvar_nonvar: /* both arguments are bound */ /* we may have to bind structures */ EMIT_MULTIPLE_DESTINY_BLOCK_TEST(GLIST_VALX_GLIST_VALX_NONVAR_NONVAR); PREG = NEXTOP(PREG, xx); - traced_UnifyBound(d0, d1); + UnifyBound(d0, d1); BEGP(pt1); /* deref second argument */ - profiled_deref_body(d1, pt1, traced_glist_valx_nonvar_unk, traced_glist_valx_nonvar_nonvar); + profiled_deref_body(d1, pt1, glist_valx_nonvar_unk, glist_valx_nonvar_nonvar); /* head bound, argument unbound */ EMIT_SIMPLE_BLOCK_TEST(GLIST_VALX_GLIST_VALX_NONVAR_UNK); PREG = NEXTOP(PREG, xx); @@ -3030,13 +3057,13 @@ S_SREG = RepAppl(d0); ENDD(d1); /* head may be unbound */ - profiled_derefa_body(d0, pt0, traced_glist_valx_unk, traced_glist_valx_nonvar); + profiled_derefa_body(d0, pt0, glist_valx_unk, glist_valx_nonvar); /* head is unbound, pt0 has the value */ EMIT_SIMPLE_BLOCK_TEST(GLIST_VALX_GLIST_VALX_UNK); d0 = XREG(PREG->y_u.xx.xr); - profiled_deref_head_TEST(d0, traced_glist_valx_var_unk); + profiled_deref_head_TEST(d0, glist_valx_var_unk); - traced_glist_valx_var_nonvar: + glist_valx_var_nonvar: /* head is unbound, second arg bound */ EMIT_SIMPLE_BLOCK_TEST(GLIST_VALX_GLIST_VALX_VAR_NONVAR); PREG = NEXTOP(PREG, xx); @@ -3044,7 +3071,7 @@ S_SREG = RepAppl(d0); GONext(); BEGP(pt1); - profiled_deref_body(d0, pt1, traced_glist_valx_var_unk, traced_glist_valx_var_nonvar); + profiled_deref_body(d0, pt1, glist_valx_var_unk, glist_valx_var_nonvar); /* head and second argument are unbound */ EMIT_SIMPLE_BLOCK_TEST(GLIST_VALX_GLIST_VALX_VAR_UNK); PREG = NEXTOP(PREG, xx); @@ -3055,7 +3082,7 @@ S_SREG = RepAppl(d0); END_PREFETCH(); BEGP(pt0); - profiled_deref_body(d0, pt0, traced_glist_valx_write, traced_glist_valx_read); + profiled_deref_body(d0, pt0, glist_valx_write, glist_valx_read); EMIT_SIMPLE_BLOCK_TEST(GLIST_VALX_GLIST_VALX_WRITE); CACHE_S(); /* enter write mode */ @@ -3078,17 +3105,17 @@ S_SREG = RepAppl(d0); ENDD(d0); ENDOpRW(); - OpRW(traced_glist_valy, yx); + OpRW(glist_valy, yx); EMIT_ENTRY_BLOCK(PREG,GLIST_VALY_INSTINIT); BEGD(d0); d0 = XREG(PREG->y_u.yx.x); - profiled_deref_head_TEST(d0, traced_glist_valy_write); - traced_glist_valy_read: + profiled_deref_head_TEST(d0, glist_valy_write); + glist_valy_read: BEGP(pt0); /* did we find a list? */ EMIT_SIMPLE_BLOCK_TEST(GLIST_VALY_GLIST_VALY_READ); if (!IsPairTerm(d0)) { - TRACED_FAIL(); + FAIL(); } START_PREFETCH(yx); /* enter read mode */ @@ -3096,9 +3123,9 @@ S_SREG = RepAppl(d0); SREG = pt0 + 1; /* start unification with first argument */ d0 = *pt0; - profiled_deref_head_TEST(d0, traced_glist_valy_unk); + profiled_deref_head_TEST(d0, glist_valy_unk); - traced_glist_valy_nonvar: + glist_valy_nonvar: /* first argument is bound */ EMIT_SIMPLE_BLOCK_TEST(GLIST_VALY_GLIST_VALY_NONVAR); BEGD(d1); @@ -3106,17 +3133,17 @@ S_SREG = RepAppl(d0); pt1 = YREG + PREG->y_u.yx.y; d1 = *pt1; PREG = NEXTOP(PREG, yx); - profiled_deref_head_TEST(d1, traced_glist_valy_nonvar_unk); + profiled_deref_head_TEST(d1, glist_valy_nonvar_unk); - traced_glist_valy_nonvar_nonvar: + glist_valy_nonvar_nonvar: /* both arguments are bound */ /* we may have to bind structures */ EMIT_MULTIPLE_DESTINY_BLOCK_TEST(GLIST_VALY_GLIST_VALY_NONVAR_NONVAR); SREG = pt0 + 1; - traced_UnifyBound(d0, d1); + UnifyBound(d0, d1); /* deref second argument */ - profiled_derefa_body(d1, pt1, traced_glist_valy_nonvar_unk, traced_glist_valy_nonvar_nonvar); + profiled_derefa_body(d1, pt1, glist_valy_nonvar_unk, glist_valy_nonvar_nonvar); /* first argument bound, second unbound */ EMIT_SIMPLE_BLOCK_TEST(GLIST_VALY_GLIST_VALY_NONVAR_UNK); Bind(pt1, d0); @@ -3124,21 +3151,21 @@ S_SREG = RepAppl(d0); ENDP(pt1); /* first argument may be unbound */ - profiled_derefa_body(d0, pt0, traced_glist_valy_unk, traced_glist_valy_nonvar); + profiled_derefa_body(d0, pt0, glist_valy_unk, glist_valy_nonvar); /* first argument is unbound */ EMIT_SIMPLE_BLOCK_TEST(GLIST_VALY_GLIST_VALY_UNK); BEGP(pt1); pt1 = YREG+PREG->y_u.yx.y; d1 = *pt1; - profiled_deref_head_TEST(d1, traced_glist_valy_var_unk); - traced_glist_valy_var_nonvar: + profiled_deref_head_TEST(d1, glist_valy_var_unk); + glist_valy_var_nonvar: /* first unbound, second bound */ EMIT_SIMPLE_BLOCK_TEST(GLIST_VALY_GLIST_VALY_VAR_NONVAR); PREG = NEXTOP(PREG, yx); Bind_Global(pt0, d1); GONext(); - profiled_derefa_body(d1, pt1, traced_glist_valy_var_unk, traced_glist_valy_var_nonvar); + profiled_derefa_body(d1, pt1, glist_valy_var_unk, glist_valy_var_nonvar); /* both arguments are unbound */ EMIT_SIMPLE_BLOCK_TEST(GLIST_VALY_GLIST_VALY_VAR_UNK); PREG = NEXTOP(PREG, yx); @@ -3151,7 +3178,7 @@ S_SREG = RepAppl(d0); ENDP(pt0); BEGP(pt0); - profiled_deref_body(d0, pt0, traced_glist_valy_write, traced_glist_valy_read); + profiled_deref_body(d0, pt0, glist_valy_write, glist_valy_read); /* enter write mode */ EMIT_SIMPLE_BLOCK_TEST(GLIST_VALY_GLIST_VALY_WRITE); START_PREFETCH_W(yx); @@ -3175,16 +3202,16 @@ S_SREG = RepAppl(d0); ENDD(d0); ENDOpRW(); - Op(traced_gl_void_varx, xx); + Op(gl_void_varx, xx); EMIT_ENTRY_BLOCK(PREG,GL_VOID_VARX_INSTINIT); BEGD(d0); d0 = XREG(PREG->y_u.xx.xl); - profiled_deref_head_TEST(d0, traced_glist_void_varx_write); - traced_glist_void_varx_read: + profiled_deref_head_TEST(d0, glist_void_varx_write); + glist_void_varx_read: /* did we find a list? */ EMIT_MULTIPLE_DESTINY_BLOCK_TEST(GL_VOID_VARX_GLIST_VOID_VARX_READ); if (!IsPairTerm(d0)) { - TRACED_FAIL(); + FAIL(); } ALWAYS_START_PREFETCH(xx); /* enter read mode */ @@ -3198,7 +3225,7 @@ S_SREG = RepAppl(d0); ALWAYS_END_PREFETCH(); BEGP(pt0); - profiled_deref_body(d0, pt0, traced_glist_void_varx_write, traced_glist_void_varx_read); + profiled_deref_body(d0, pt0, glist_void_varx_write, glist_void_varx_read); EMIT_SIMPLE_BLOCK_TEST(GL_VOID_VARX_GLIST_VOID_VAR_WRITE); /* enter write mode */ BEGP(pt1); @@ -3220,16 +3247,16 @@ S_SREG = RepAppl(d0); ENDD(d0); ENDOp(); - Op(traced_gl_void_vary, yx); + Op(gl_void_vary, yx); EMIT_ENTRY_BLOCK(PREG,GL_VOID_VARY_INSTINIT); BEGD(d0); d0 = XREG(PREG->y_u.yx.x); - profiled_deref_head_TEST(d0, traced_glist_void_vary_write); - traced_glist_void_vary_read: + profiled_deref_head_TEST(d0, glist_void_vary_write); + glist_void_vary_read: /* did we find a list? */ EMIT_MULTIPLE_DESTINY_BLOCK_TEST(GL_VOID_VARY_GLIST_VOID_VARY_READ); if (!IsPairTerm(d0)) { - TRACED_FAIL(); + FAIL(); } /* enter read mode */ BEGP(pt0); @@ -3241,7 +3268,7 @@ S_SREG = RepAppl(d0); GONext(); BEGP(pt0); - profiled_deref_body(d0, pt0, traced_glist_void_vary_write, traced_glist_void_vary_read); + profiled_deref_body(d0, pt0, glist_void_vary_write, glist_void_vary_read); /* enter write mode */ EMIT_SIMPLE_BLOCK_TEST(GL_VOID_VARY_GLIST_VOID_VARY_WRITE); BEGP(pt1); @@ -3261,49 +3288,49 @@ S_SREG = RepAppl(d0); ENDD(d0); ENDOp(); - Op(traced_gl_void_valx, xx); + Op(gl_void_valx, xx); ///#ifdef PROFILED_ABSMI EMIT_ENTRY_BLOCK(PREG,GL_VOID_VALX_INSTINIT); ///#endif BEGD(d0); d0 = XREG(PREG->y_u.xx.xl); - deref_head(d0, traced_glist_void_valx_write); - traced_glist_void_valx_read: + deref_head(d0, glist_void_valx_write); + glist_void_valx_read: BEGP(pt0); /* did we find a list? */ ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(GL_VOID_VALX_GLIST_VOID_VALX_READ); ///#endif if (!IsPairTerm(d0)) { - TRACED_FAIL(); + FAIL(); } /* enter read mode */ pt0 = RepPair(d0)+1; /* start unification with first argument */ d0 = *pt0; - deref_head(d0, traced_glist_void_valx_unk); + deref_head(d0, glist_void_valx_unk); - traced_glist_void_valx_nonvar: + glist_void_valx_nonvar: /* first argument is bound */ ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(GL_VOID_VALX_GLIST_VOID_VALX_NONVAR); //#endif BEGD(d1); d1 = XREG(PREG->y_u.xx.xr); - deref_head(d1, traced_glist_void_valx_nonvar_unk); + deref_head(d1, glist_void_valx_nonvar_unk); - traced_glist_void_valx_nonvar_nonvar: + glist_void_valx_nonvar_nonvar: /* both arguments are bound */ /* we may have to bind structures */ ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(GL_VOID_VALX_GLIST_VOID_VALX_NONVAR_NONVAR); ///#endif PREG = NEXTOP(PREG, xx); - traced_UnifyBound(d0, d1); + UnifyBound(d0, d1); /* deref second argument */ BEGP(pt1); - deref_body(d1, pt1, traced_glist_void_valx_nonvar_unk, traced_glist_void_valx_nonvar_nonvar); + deref_body(d1, pt1, glist_void_valx_nonvar_unk, glist_void_valx_nonvar_nonvar); /* first argument bound, second unbound */ ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(GL_VOID_VALX_GLIST_VOID_VALX_NONVAR_UNK); @@ -3315,16 +3342,16 @@ S_SREG = RepAppl(d0); ENDD(d1); /* first argument may be unbound */ - derefa_body(d0, pt0, traced_glist_void_valx_unk, traced_glist_void_valx_nonvar); + derefa_body(d0, pt0, glist_void_valx_unk, glist_void_valx_nonvar); /* first argument is unbound */ ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(GL_VOID_VALX_GLIST_VOID_VALX_UNK); ///#endif BEGD(d1); d1 = XREG(PREG->y_u.xx.xr); - deref_head(d1, traced_glist_void_valx_var_unk); + deref_head(d1, glist_void_valx_var_unk); - traced_glist_void_valx_var_nonvar: + glist_void_valx_var_nonvar: /* first unbound, second bound */ ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(GL_VOID_VALX_GLIST_VOID_VALX_VAR_NONVAR); @@ -3334,7 +3361,7 @@ S_SREG = RepAppl(d0); GONext(); BEGP(pt1); - deref_body(d1, pt1, traced_glist_void_valx_var_unk, traced_glist_void_valx_var_nonvar); + deref_body(d1, pt1, glist_void_valx_var_unk, glist_void_valx_var_nonvar); ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(GL_VOID_VALX_GLIST_VOID_VALX_VAR_UNK); ///#endif @@ -3347,7 +3374,7 @@ S_SREG = RepAppl(d0); ENDP(pt0); BEGP(pt0); - deref_body(d0, pt0, traced_glist_void_valx_write, traced_glist_void_valx_read); + deref_body(d0, pt0, glist_void_valx_write, glist_void_valx_read); /* enter write mode */ ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(GL_VOID_VALX_GLIST_VOID_VALX_WRITE); @@ -3372,14 +3399,14 @@ S_SREG = RepAppl(d0); ENDD(d0); ENDOp(); - Op(traced_gl_void_valy, yx); + Op(gl_void_valy, yx); ///#ifdef PROFILED_ABSMI EMIT_ENTRY_BLOCK(PREG,GL_VOID_VALY_INSTINIT); ///#endif BEGD(d0); d0 = XREG(PREG->y_u.yx.x); - deref_head(d0, traced_glist_void_valy_write); - traced_glist_void_valy_read: + deref_head(d0, glist_void_valy_write); + glist_void_valy_read: ///#ifdef PROFILED_ABSMI ///#endif BEGP(pt0); @@ -3388,15 +3415,15 @@ S_SREG = RepAppl(d0); EMIT_SIMPLE_BLOCK(GL_VOID_VALY_GLIST_VOID_VALY_READ); ///#endif if (!IsPairTerm(d0)) { - TRACED_FAIL(); + FAIL(); } /* enter read mode */ pt0 = RepPair(d0)+1; /* start unification with first argument */ d0 = *pt0; - deref_head(d0, traced_glist_void_valy_unk); + deref_head(d0, glist_void_valy_unk); - traced_glist_void_valy_nonvar: + glist_void_valy_nonvar: /* first argument is bound */ ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(GL_VOID_VALY_GLIST_VOID_VALY_NONVAR); @@ -3405,19 +3432,19 @@ S_SREG = RepAppl(d0); BEGP(pt1); pt1 = YREG+PREG->y_u.yx.y; d1 = *pt1; - deref_head(d1, traced_glist_void_valy_nonvar_unk); + deref_head(d1, glist_void_valy_nonvar_unk); - traced_glist_void_valy_nonvar_nonvar: + glist_void_valy_nonvar_nonvar: /* both arguments are bound */ /* we may have to bind structures */ ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(GL_VOID_VALY_GLIST_VOID_VALY_NONVAR_NONVAR); ///#endif PREG = NEXTOP(PREG, yx); - traced_UnifyBound(d0, d1); + UnifyBound(d0, d1); /* deref second argument */ - derefa_body(d1, pt1, traced_glist_void_valy_nonvar_unk, traced_glist_void_valy_nonvar_nonvar); + derefa_body(d1, pt1, glist_void_valy_nonvar_unk, glist_void_valy_nonvar_nonvar); /* first argument bound, second unbound */ ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(GL_VOID_VALY_GLIST_VOID_VALY_NONVAR_UNK); @@ -3429,7 +3456,7 @@ S_SREG = RepAppl(d0); ENDP(pt1); /* first argument may be unbound */ - derefa_body(d0, pt0, traced_glist_void_valy_unk, traced_glist_void_valy_nonvar); + derefa_body(d0, pt0, glist_void_valy_unk, glist_void_valy_nonvar); /* first argument is unbound */ ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(GL_VOID_VALY_GLIST_VOID_VALY_UNK); @@ -3437,9 +3464,9 @@ S_SREG = RepAppl(d0); BEGP(pt1); pt1 = YREG+PREG->y_u.yx.y; d1 = *pt1; - deref_head(d1, traced_glist_void_valy_var_unk); + deref_head(d1, glist_void_valy_var_unk); - traced_glist_void_valy_var_nonvar: + glist_void_valy_var_nonvar: /* first unbound, second bound */ ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(GL_VOID_VALY_GLIST_VOID_VALY_VAR_NONVAR); @@ -3448,7 +3475,7 @@ S_SREG = RepAppl(d0); Bind_Global(pt0, d1); GONext(); - deref_body(d1, pt1, traced_glist_void_valy_var_unk, traced_glist_void_valy_var_nonvar); + deref_body(d1, pt1, glist_void_valy_var_unk, glist_void_valy_var_nonvar); /* both arguments are unbound */ ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(GL_VOID_VALY_GLIST_VOID_VALY_VAR_UNK); @@ -3461,7 +3488,7 @@ S_SREG = RepAppl(d0); ENDP(pt0); BEGP(pt0); - deref_body(d0, pt0, traced_glist_void_valy_write, traced_glist_void_valy_read); + deref_body(d0, pt0, glist_void_valy_write, glist_void_valy_read); /* enter write mode */ ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(GL_VOID_VALY_GLIST_VOID_VALY_WRITE); @@ -3491,7 +3518,7 @@ S_SREG = RepAppl(d0); * Unify instructions * \************************************************************************/ - Op(traced_unify_x_var, ox); + Op(unify_x_var, ox); EMIT_ENTRY_BLOCK(PREG,UNIFY_X_VAR_INSTINIT); CACHE_S(); READ_IN_S(); @@ -3514,7 +3541,7 @@ S_SREG = RepAppl(d0); ENDCACHE_S(); ENDOp(); - OpW(traced_unify_x_var_write, ox); + OpW(unify_x_var_write, ox); EMIT_ENTRY_BLOCK(PREG,UNIFY_X_VAR_WRITE_INSTINIT); CACHE_S(); READ_IN_S(); @@ -3529,7 +3556,7 @@ S_SREG = RepAppl(d0); GONextW(); ENDOpW(); - BOp(traced_unify_l_x_var, ox); + BOp(unify_l_x_var, ox); EMIT_ENTRY_BLOCK(PREG,UNIFY_L_X_VAR_INSTINIT); ALWAYS_START_PREFETCH(ox); BEGP(pt0); @@ -3551,7 +3578,7 @@ S_SREG = RepAppl(d0); ALWAYS_END_PREFETCH(); ENDBOp(); - BOp(traced_unify_l_x_var_write, ox); + BOp(unify_l_x_var_write, ox); EMIT_ENTRY_BLOCK(PREG,UNIFY_L_X_VAR_WRITE_INSTINIT); ALWAYS_START_PREFETCH(ox); CACHE_S(); @@ -3567,7 +3594,7 @@ S_SREG = RepAppl(d0); ENDBOp(); ALWAYS_END_PREFETCH(); - BOp(traced_unify_x_var2, oxx); + BOp(unify_x_var2, oxx); EMIT_ENTRY_BLOCK(PREG,UNIFY_X_VAR2_INSTINIT); CACHE_S(); ALWAYS_START_PREFETCH(oxx); @@ -3600,7 +3627,7 @@ S_SREG = RepAppl(d0); ALWAYS_END_PREFETCH(); ENDCACHE_S(); - OpW(traced_unify_x_var2_write, oxx); + OpW(unify_x_var2_write, oxx); EMIT_ENTRY_BLOCK(PREG,UNIFY_X_VAR2_WRITE_INSTINIT); CACHE_S(); READ_IN_S(); @@ -3618,7 +3645,7 @@ S_SREG = RepAppl(d0); GONextW(); ENDOpW(); - BOp(traced_unify_l_x_var2, oxx); + BOp(unify_l_x_var2, oxx); EMIT_ENTRY_BLOCK(PREG,UNIFY_L_X_VAR2_INSTINIT); ALWAYS_START_PREFETCH(oxx); CACHE_S(); @@ -3650,7 +3677,7 @@ S_SREG = RepAppl(d0); ENDBOp(); ALWAYS_END_PREFETCH(); - Op(traced_unify_l_x_var2_write, oxx); + Op(unify_l_x_var2_write, oxx); EMIT_ENTRY_BLOCK(PREG,UNIFY_L_X_VAR2_WRITE_INSTINIT); CACHE_S(); READ_IN_S(); @@ -3667,7 +3694,7 @@ S_SREG = RepAppl(d0); GONext(); ENDOp(); - Op(traced_unify_y_var, oy); + Op(unify_y_var, oy); EMIT_ENTRY_BLOCK(PREG,UNIFY_Y_VAR_INSTINIT); BEGD(d0); d0 = *SREG++; @@ -3683,7 +3710,7 @@ S_SREG = RepAppl(d0); ENDD(d0); ENDOp(); - OpW(traced_unify_y_var_write, oy); + OpW(unify_y_var_write, oy); EMIT_ENTRY_BLOCK(PREG,UNIFY_Y_VAR_WRITE_INSTINIT); CACHE_S(); READ_IN_S(); @@ -3695,7 +3722,7 @@ S_SREG = RepAppl(d0); GONextW(); ENDOpW(); - Op(traced_unify_l_y_var, oy); + Op(unify_l_y_var, oy); EMIT_ENTRY_BLOCK(PREG,UNIFY_L_Y_VAR_INSTINIT); BEGD(d0); d0 = SREG[0]; @@ -3711,7 +3738,7 @@ S_SREG = RepAppl(d0); ENDD(d0); ENDOp(); - Op(traced_unify_l_y_var_write, oy); + Op(unify_l_y_var_write, oy); EMIT_ENTRY_BLOCK(PREG,UNIFY_L_Y_VAR_WRITE_INSTINIT); CACHE_S(); READ_IN_S(); @@ -3724,7 +3751,7 @@ S_SREG = RepAppl(d0); /* We assume the value in X is pointing to an object in the * global stack */ - Op(traced_unify_x_val, ox); + Op(unify_x_val, ox); ///#ifdef PROFILED_ABSMI EMIT_ENTRY_BLOCK(PREG,UNIFY_X_VAL_INSTINIT); ///#endif @@ -3733,17 +3760,17 @@ S_SREG = RepAppl(d0); BEGP(pt0); pt0 = SREG; d0 = *pt0; - deref_head(d0, traced_uvalx_unk); + deref_head(d0, uvalx_unk); - traced_uvalx_nonvar: + uvalx_nonvar: /* first argument is bound */ ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(UNIFY_X_VAL_UVALX_NONVAR); ///#endif d1 = XREG(PREG->y_u.ox.x); - deref_head(d1, traced_uvalx_nonvar_unk); + deref_head(d1, uvalx_nonvar_unk); - traced_uvalx_nonvar_nonvar: + uvalx_nonvar_nonvar: /* both arguments are bound */ /* we may have to bind structures */ ///#ifdef PROFILED_ABSMI @@ -3751,12 +3778,12 @@ S_SREG = RepAppl(d0); ///#endif PREG = NEXTOP(PREG, ox); SREG++; - traced_UnifyBound(d0, d1); + UnifyBound(d0, d1); /* deref second argument */ /* pt0 is in the structure and pt1 the register */ BEGP(pt1); - deref_body(d1, pt1, traced_uvalx_nonvar_unk, traced_uvalx_nonvar_nonvar); + deref_body(d1, pt1, uvalx_nonvar_unk, uvalx_nonvar_nonvar); /* first argument bound, second unbound */ ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(UNIFY_X_VAL_UVALX_NONVAR_UNK); @@ -3768,15 +3795,15 @@ S_SREG = RepAppl(d0); ENDP(pt1); /* first argument may be unbound */ - derefa_body(d0, pt0, traced_uvalx_unk, traced_uvalx_nonvar); + derefa_body(d0, pt0, uvalx_unk, uvalx_nonvar); ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(UNIFY_X_VAL_UVALX_UNK); ///#endif /* first argument is unbound */ d1 = XREG(PREG->y_u.ox.x); - deref_head(d1, traced_uvalx_var_unk); + deref_head(d1, uvalx_var_unk); - traced_uvalx_var_nonvar: + uvalx_var_nonvar: /* first unbound, second bound */ ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(UNIFY_X_VAL_UVALX_VAR_NONVAR); @@ -3787,7 +3814,7 @@ S_SREG = RepAppl(d0); GONext(); BEGP(pt1); - deref_body(d1, pt1, traced_uvalx_var_unk, traced_uvalx_var_nonvar); + deref_body(d1, pt1, uvalx_var_unk, uvalx_var_nonvar); ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(UNIFY_X_VAL_UVALX_VAR_UNK); ///#endif @@ -3802,7 +3829,7 @@ S_SREG = RepAppl(d0); ENDD(d0); ENDOp(); - OpW(traced_unify_x_val_write, ox); + OpW(unify_x_val_write, ox); /* we are in write mode */ EMIT_ENTRY_BLOCK(PREG,UNIFY_X_VAL_WRITE_INSTINIT); *SREG++ = XREG(PREG->y_u.ox.x); @@ -3812,7 +3839,7 @@ S_SREG = RepAppl(d0); /* We assume the value in X is pointing to an object in the * global stack */ - Op(traced_unify_l_x_val, ox); + Op(unify_l_x_val, ox); ///#ifdef PROFILED_ABSMI EMIT_ENTRY_BLOCK(PREG,UNIFY_L_X_VAL_INSTINIT); ///#endif @@ -3821,28 +3848,28 @@ S_SREG = RepAppl(d0); BEGP(pt0); pt0 = SREG; d0 = *pt0; - deref_head(d0, traced_ulvalx_unk); + deref_head(d0, ulvalx_unk); - traced_ulvalx_nonvar: + ulvalx_nonvar: /* first argument is bound */ ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(UNIFY_L_X_VAL_ULVALX_NONVAR); ///#endif d1 = XREG(PREG->y_u.ox.x); - deref_head(d1, traced_ulvalx_nonvar_unk); + deref_head(d1, ulvalx_nonvar_unk); - traced_ulvalx_nonvar_nonvar: + ulvalx_nonvar_nonvar: ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(UNIFY_L_X_VAL_ULVALX_NONVAR_NONVAR); ///#endif /* both arguments are bound */ /* we may have to bind structures */ PREG = NEXTOP(PREG, ox); - traced_UnifyBound(d0, d1); + UnifyBound(d0, d1); BEGP(pt1); /* deref second argument */ - deref_body(d1, pt1, traced_ulvalx_nonvar_unk, traced_ulvalx_nonvar_nonvar); + deref_body(d1, pt1, ulvalx_nonvar_unk, ulvalx_nonvar_nonvar); /* first argument bound, second unbound */ ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(UNIFY_L_X_VAL_ULVALX_NONVAR_UNK); @@ -3853,15 +3880,15 @@ S_SREG = RepAppl(d0); ENDP(pt1); /* first argument may be unbound */ - derefa_body(d0, pt0, traced_ulvalx_unk, traced_ulvalx_nonvar); + derefa_body(d0, pt0, ulvalx_unk, ulvalx_nonvar); /* first argument is unbound */ ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(UNIFY_L_X_VAL_ULVALX_UNK); ///#endif d1 = XREG(PREG->y_u.ox.x); - deref_head(d1, traced_ulvalx_var_unk); + deref_head(d1, ulvalx_var_unk); - traced_ulvalx_var_nonvar: + ulvalx_var_nonvar: /* first unbound, second bound */ ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(UNIFY_L_X_VAL_ULVALX_VAR_NONVAR); @@ -3871,7 +3898,7 @@ S_SREG = RepAppl(d0); GONext(); BEGP(pt1); - deref_body(d1, pt1, traced_ulvalx_var_unk, traced_ulvalx_var_nonvar); + deref_body(d1, pt1, ulvalx_var_unk, ulvalx_var_nonvar); /* both arguments are unbound */ ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(UNIFY_L_X_VAL_ULVALX_VAR_UNK); @@ -3885,7 +3912,7 @@ S_SREG = RepAppl(d0); ENDD(d0); ENDOp(); - Op(traced_unify_l_x_val_write, ox); + Op(unify_l_x_val_write, ox); /* we are in write mode */ EMIT_ENTRY_BLOCK(PREG,UNIFY_L_X_VAL_WRITE_INSTINIT); SREG[0] = XREG(PREG->y_u.ox.x); @@ -3895,7 +3922,7 @@ S_SREG = RepAppl(d0); /* We assume the value in X is pointing to an object in the * global stack */ - Op(traced_unify_y_val, oy); + Op(unify_y_val, oy); ///#ifdef PROFILED_ABSMI EMIT_ENTRY_BLOCK(PREG,UNIFY_Y_VAL_INSTINIT); ///#endif @@ -3904,9 +3931,9 @@ S_SREG = RepAppl(d0); BEGP(pt0); pt0 = SREG; d0 = *pt0; - deref_head(d0, traced_uvaly_unk); + deref_head(d0, uvaly_unk); - traced_uvaly_nonvar: + uvaly_nonvar: /* first argument is bound */ ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK_TEST(UNIFY_Y_VAL_UVALY_NONVAR); @@ -3914,9 +3941,9 @@ S_SREG = RepAppl(d0); BEGP(pt1); pt1 = YREG+PREG->y_u.oy.y; d1 = *pt1; - deref_head(d1, traced_uvaly_nonvar_unk); + deref_head(d1, uvaly_nonvar_unk); - traced_uvaly_nonvar_nonvar: + uvaly_nonvar_nonvar: /* both arguments are bound */ /* we may have to bind structures */ ///#ifdef PROFILED_ABSMI @@ -3924,10 +3951,10 @@ S_SREG = RepAppl(d0); ///#endif PREG = NEXTOP(PREG, oy); SREG++; - traced_UnifyBound(d0, d1); + UnifyBound(d0, d1); /* deref second argument */ - derefa_body(d1, pt1, traced_uvaly_nonvar_unk, traced_uvaly_nonvar_nonvar); + derefa_body(d1, pt1, uvaly_nonvar_unk, uvaly_nonvar_nonvar); /* first argument bound, second unbound */ ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK_TEST(UNIFY_Y_VAL_UVALY_NONVAR_UNK); @@ -3939,7 +3966,7 @@ S_SREG = RepAppl(d0); ENDP(pt1); /* first argument may be unbound */ - derefa_body(d0, pt0, traced_uvaly_unk, traced_uvaly_nonvar); + derefa_body(d0, pt0, uvaly_unk, uvaly_nonvar); /* first argument is unbound */ ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK_TEST(UNIFY_Y_VAL_UVALY_UNK); @@ -3947,9 +3974,9 @@ S_SREG = RepAppl(d0); BEGP(pt1); pt1 = YREG+PREG->y_u.oy.y; d1 = *pt1; - deref_head(d1, traced_uvaly_var_unk); + deref_head(d1, uvaly_var_unk); - traced_uvaly_var_nonvar: + uvaly_var_nonvar: /* first unbound, second bound */ ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK_TEST(UNIFY_Y_VAL_UVALY_VAR_NONVAR); @@ -3959,7 +3986,7 @@ S_SREG = RepAppl(d0); Bind_Global(pt0, d1); GONext(); - derefa_body(d1, pt1, traced_uvaly_var_unk, traced_uvaly_var_nonvar); + derefa_body(d1, pt1, uvaly_var_unk, uvaly_var_nonvar); /* both arguments are unbound */ ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK_TEST(UNIFY_Y_VAL_UVALY_VAR_UNK); @@ -3974,7 +4001,7 @@ S_SREG = RepAppl(d0); ENDD(d0); ENDOp(); - OpW(traced_unify_y_val_write, oy); + OpW(unify_y_val_write, oy); EMIT_ENTRY_BLOCK(PREG,UNIFY_Y_VAL_WRITE_INSTINIT); /* we are in write mode */ BEGD(d0); @@ -3992,7 +4019,7 @@ S_SREG = RepAppl(d0); /* We assume the value in X is pointing to an object in the * global stack */ - Op(traced_unify_l_y_val, oy); + Op(unify_l_y_val, oy); ///#ifdef PROFILED_ABSMI EMIT_ENTRY_BLOCK(PREG,UNIFY_L_Y_VAL_INSTINIT); ///#endif @@ -4001,9 +4028,9 @@ S_SREG = RepAppl(d0); BEGP(pt0); pt0 = SREG; d0 = *pt0; - deref_head(d0, traced_ulvaly_unk); + deref_head(d0, ulvaly_unk); - traced_ulvaly_nonvar: + ulvaly_nonvar: /* first argument is bound */ ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK_TEST(UNIFY_L_Y_VAL_ULVALY_NONVAR); @@ -4011,19 +4038,19 @@ S_SREG = RepAppl(d0); BEGP(pt1); pt1 = YREG+PREG->y_u.oy.y; d1 = *pt1; - deref_head(d1, traced_ulvaly_nonvar_unk); + deref_head(d1, ulvaly_nonvar_unk); - traced_ulvaly_nonvar_nonvar: + ulvaly_nonvar_nonvar: /* both arguments are bound */ /* we may have to bind structures */ ///#ifdef PROFILED_ABSMI EMIT_MULTIPLE_DESTINY_BLOCK_TEST(UNIFY_L_Y_VAL_ULVALY_NONVAR_NONVAR); ///#endif PREG = NEXTOP(PREG, oy); - traced_UnifyBound(d0, d1); + UnifyBound(d0, d1); /* deref second argument */ - derefa_body(d1, pt1, traced_ulvaly_nonvar_unk, traced_ulvaly_nonvar_nonvar); + derefa_body(d1, pt1, ulvaly_nonvar_unk, ulvaly_nonvar_nonvar); /* first argument bound, second unbound */ ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK_TEST(UNIFY_L_Y_VAL_ULVALY_NONVAR_UNK); @@ -4034,7 +4061,7 @@ S_SREG = RepAppl(d0); ENDP(pt1); /* first argument may be unbound */ - derefa_body(d0, pt0, traced_ulvaly_unk, traced_ulvaly_nonvar); + derefa_body(d0, pt0, ulvaly_unk, ulvaly_nonvar); /* first argument is unbound */ ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK_TEST(UNIFY_L_Y_VAL_ULVALY_UNK); @@ -4042,9 +4069,9 @@ S_SREG = RepAppl(d0); BEGP(pt1); pt1 = YREG+PREG->y_u.oy.y; d1 = *pt1; - deref_head(d1, traced_ulvaly_var_unk); + deref_head(d1, ulvaly_var_unk); - traced_ulvaly_var_nonvar: + ulvaly_var_nonvar: /* first unbound, second bound */ ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK_TEST(UNIFY_L_Y_VAL_ULVALY_VAR_NONVAR); @@ -4055,7 +4082,7 @@ S_SREG = RepAppl(d0); /* Here we are in trouble: we have a clash between pt1 and * SREG. We address this by storing SREG in d0 for the duration. */ - derefa_body(d1, pt1, traced_ulvaly_var_unk, traced_ulvaly_var_nonvar); + derefa_body(d1, pt1, ulvaly_var_unk, ulvaly_var_nonvar); /* both arguments are unbound */ ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK_TEST(UNIFY_L_Y_VAL_ULVALY_VAR_UNK); @@ -4069,7 +4096,7 @@ S_SREG = RepAppl(d0); ENDD(d0); ENDOp(); - Op(traced_unify_l_y_val_write, oy); + Op(unify_l_y_val_write, oy); EMIT_ENTRY_BLOCK(PREG,UNIFY_L_Y_VAL_WRITE_INSTINIT); /* we are in write mode */ BEGD(d0); @@ -4087,7 +4114,7 @@ S_SREG = RepAppl(d0); /* In the next instructions, we do not know anything about * what is in X */ - Op(traced_unify_x_loc, ox); + Op(unify_x_loc, ox); EMIT_ENTRY_BLOCK(PREG,UNIFY_X_LOC_INSTINIT); BEGD(d0); BEGD(d1); @@ -4095,24 +4122,24 @@ S_SREG = RepAppl(d0); pt0 = SREG; d0 = *pt0; - profiled_deref_head_TEST(d0, traced_uvalx_loc_unk); - traced_uvalx_loc_nonvar: + profiled_deref_head_TEST(d0, uvalx_loc_unk); + uvalx_loc_nonvar: /* first argument is bound */ EMIT_SIMPLE_BLOCK_TEST(UNIFY_X_LOC_UVALX_LOC_NONVAR); d1 = XREG(PREG->y_u.ox.x); - profiled_deref_head_TEST(d1, traced_uvalx_loc_nonvar_unk); + profiled_deref_head_TEST(d1, uvalx_loc_nonvar_unk); - traced_uvalx_loc_nonvar_nonvar: + uvalx_loc_nonvar_nonvar: EMIT_MULTIPLE_DESTINY_BLOCK_TEST(UNIFY_X_LOC_UVALX_LOC_NONVAR_NONVAR); /* both arguments are bound */ /* we may have to bind structures */ PREG = NEXTOP(PREG, ox); SREG++; - traced_UnifyBound(d0, d1); + UnifyBound(d0, d1); BEGP(pt1); /* deref second argument */ - profiled_deref_body(d1, pt1, traced_uvalx_loc_nonvar_unk, traced_uvalx_loc_nonvar_nonvar); + profiled_deref_body(d1, pt1, uvalx_loc_nonvar_unk, uvalx_loc_nonvar_nonvar); /* first argument bound, second unbound */ EMIT_SIMPLE_BLOCK_TEST(UNIFY_X_LOC_UVALX_LOC_NONVAR_UNK); PREG = NEXTOP(PREG, ox); @@ -4123,12 +4150,12 @@ S_SREG = RepAppl(d0); /* first argument may be unbound */ - profiled_derefa_body(d0, pt0, traced_uvalx_loc_unk, traced_uvalx_loc_nonvar); + profiled_derefa_body(d0, pt0, uvalx_loc_unk, uvalx_loc_nonvar); /* first argument is unbound */ EMIT_SIMPLE_BLOCK_TEST(UNIFY_X_LOC_UVALX_LOC_UNK); d1 = XREG(PREG->y_u.ox.x); - profiled_deref_head_TEST(d1, traced_uvalx_loc_var_unk); - traced_uvalx_loc_var_nonvar: + profiled_deref_head_TEST(d1, uvalx_loc_var_unk); + uvalx_loc_var_nonvar: /* first unbound, second bound */ EMIT_SIMPLE_BLOCK_TEST(UNIFY_X_LOC_UVALX_LOC_VAR_NONVAR); PREG = NEXTOP(PREG, ox); @@ -4139,7 +4166,7 @@ S_SREG = RepAppl(d0); /* Here we are in trouble: we have a clash between pt1 and * SREG. We address this by storing SREG in d0 for the duration. */ BEGP(pt1); - profiled_deref_body(d1, pt1, traced_uvalx_loc_var_unk, traced_uvalx_loc_var_nonvar); + profiled_deref_body(d1, pt1, uvalx_loc_var_unk, uvalx_loc_var_nonvar); /* both arguments are unbound */ EMIT_SIMPLE_BLOCK_TEST(UNIFY_X_LOC_UVALX_LOC_VAR_UNK); PREG = NEXTOP(PREG, ox); @@ -4152,20 +4179,20 @@ S_SREG = RepAppl(d0); ENDD(d0); ENDOp(); - OpW(traced_unify_x_loc_write, ox); + OpW(unify_x_loc_write, ox); EMIT_ENTRY_BLOCK(PREG,UNIFY_X_LOC_WRITE_INSTINIT); /* we are in write mode */ BEGD(d0); d0 = XREG(PREG->y_u.ox.x); - profiled_deref_head_TEST(d0, traced_unify_x_loc_unk); - traced_unify_x_loc_nonvar: + profiled_deref_head_TEST(d0, unify_x_loc_unk); + unify_x_loc_nonvar: EMIT_SIMPLE_BLOCK_TEST(UNIFY_X_LOC_WRITE_UNIFY_X_LOC_NONVAR); *SREG++ = d0; PREG = NEXTOP(PREG, ox); GONextW(); BEGP(pt0); - profiled_deref_body(d0, pt0, traced_unify_x_loc_unk, traced_unify_x_loc_nonvar); + profiled_deref_body(d0, pt0, unify_x_loc_unk, unify_x_loc_nonvar); /* move ahead in the instructions */ EMIT_SIMPLE_BLOCK_TEST(UNIFY_X_LOC_WRITE_UNIFY_X_LOC_UNK); PREG = NEXTOP(PREG, ox); @@ -4191,7 +4218,7 @@ S_SREG = RepAppl(d0); /* In the next instructions, we do not know anything about * what is in X */ - Op(traced_unify_l_x_loc, ox); + Op(unify_l_x_loc, ox); ///#ifdef PROFILED_ABSMI EMIT_ENTRY_BLOCK(PREG,UNIFY_L_X_LOC_INSTINIT); ///#endif @@ -4200,27 +4227,27 @@ S_SREG = RepAppl(d0); BEGP(pt0); pt0 = SREG; d0 = *pt0; - deref_head(d0, traced_ulvalx_loc_unk); + deref_head(d0, ulvalx_loc_unk); - traced_ulvalx_loc_nonvar: + ulvalx_loc_nonvar: /* first argument is bound */ ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK_TEST(UNIFY_L_X_LOC_ULVALX_LOC_NONVAR); ///#endif d1 = XREG(PREG->y_u.ox.x); - deref_head(d1, traced_ulvalx_loc_nonvar_unk); + deref_head(d1, ulvalx_loc_nonvar_unk); - traced_ulvalx_loc_nonvar_nonvar: + ulvalx_loc_nonvar_nonvar: /* both arguments are bound */ /* we may have to bind structures */ ///#ifdef PROFILED_ABSMI EMIT_MULTIPLE_DESTINY_BLOCK_TEST(UNIFY_L_X_LOC_ULVALX_LOC_NONVAR_NONVAR); ///#endif PREG = NEXTOP(PREG, ox); - traced_UnifyBound(d0, d1); + UnifyBound(d0, d1); /* deref second argument */ - deref_body(d1, pt0, traced_ulvalx_loc_nonvar_unk, traced_ulvalx_loc_nonvar_nonvar); + deref_body(d1, pt0, ulvalx_loc_nonvar_unk, ulvalx_loc_nonvar_nonvar); /* first argument bound, second unbound */ ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK_TEST(UNIFY_L_X_LOC_ULVALX_LOC_NONVAR_UNK); @@ -4230,15 +4257,15 @@ S_SREG = RepAppl(d0); GONext(); /* first argument may be unbound */ - derefa_body(d0, pt0, traced_ulvalx_loc_unk, traced_ulvalx_loc_nonvar); + derefa_body(d0, pt0, ulvalx_loc_unk, ulvalx_loc_nonvar); /* first argument is unbound */ ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK_TEST(UNIFY_L_X_LOC_ULVALX_LOC_UNK); ///#endif d1 = XREG(PREG->y_u.ox.x); - deref_head(d1, traced_ulvalx_loc_var_unk); + deref_head(d1, ulvalx_loc_var_unk); - traced_ulvalx_loc_var_nonvar: + ulvalx_loc_var_nonvar: /* first unbound, second bound */ ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK_TEST(UNIFY_L_X_LOC_ULVALX_LOC_VAR_NONVAR); @@ -4248,7 +4275,7 @@ S_SREG = RepAppl(d0); GONext(); BEGP(pt1); - deref_body(d1, pt1, traced_ulvalx_loc_var_unk, traced_ulvalx_loc_var_nonvar); + deref_body(d1, pt1, ulvalx_loc_var_unk, ulvalx_loc_var_nonvar); /* both arguments are unbound */ ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK_TEST(UNIFY_L_X_LOC_ULVALX_LOC_VAR_UNK); @@ -4262,20 +4289,20 @@ S_SREG = RepAppl(d0); ENDD(d0); ENDOp(); - Op(traced_unify_l_x_loc_write, ox); + Op(unify_l_x_loc_write, ox); EMIT_ENTRY_BLOCK(PREG,UNIFY_L_X_LOC_WRITE_INSTINIT); /* we are in write mode */ BEGD(d0); d0 = XREG(PREG->y_u.ox.x); - profiled_deref_head_TEST(d0, traced_ulnify_x_loc_unk); - traced_ulnify_x_loc_nonvar: + profiled_deref_head_TEST(d0, ulnify_x_loc_unk); + ulnify_x_loc_nonvar: EMIT_SIMPLE_BLOCK_TEST(UNIFY_L_X_LOC_WRITE_ULNIFY_X_LOC_NONVAR); SREG[0] = d0; PREG = NEXTOP(PREG, ox); GONext(); BEGP(pt0); - profiled_deref_body(d0, pt0, traced_ulnify_x_loc_unk, traced_ulnify_x_loc_nonvar); + profiled_deref_body(d0, pt0, ulnify_x_loc_unk, ulnify_x_loc_nonvar); /* d0 is a variable, check whether we need to globalise it */ EMIT_SIMPLE_BLOCK_TEST(UNIFY_L_X_LOC_WRITE_ULNIFY_X_LOC_UNK); PREG = NEXTOP(PREG, ox); @@ -4294,7 +4321,7 @@ S_SREG = RepAppl(d0); ENDD(d0); ENDOpW(); - Op(traced_unify_y_loc, oy); + Op(unify_y_loc, oy); /* we are in read mode */ ///#ifdef PROFILED_ABSMI EMIT_ENTRY_BLOCK(PREG,UNIFY_Y_LOC_INSTINIT); @@ -4304,9 +4331,9 @@ S_SREG = RepAppl(d0); BEGP(pt0); pt0 = SREG; d0 = *pt0; - deref_head(d0, traced_uvaly_loc_unk); + deref_head(d0, uvaly_loc_unk); - traced_uvaly_loc_nonvar: + uvaly_loc_nonvar: /* structure is bound */ ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK_TEST(UNIFY_Y_LOC_UVALY_LOC_NONVAR); @@ -4314,9 +4341,9 @@ S_SREG = RepAppl(d0); BEGP(pt1); pt1 = YREG+PREG->y_u.oy.y; d1 = *pt1; - deref_head(d1, traced_uvaly_loc_nonvar_unk); + deref_head(d1, uvaly_loc_nonvar_unk); - traced_uvaly_loc_nonvar_nonvar: + uvaly_loc_nonvar_nonvar: /* both arguments are bound */ /* we may have to bind structures */ ///#ifdef PROFILED_ABSMI @@ -4324,10 +4351,10 @@ S_SREG = RepAppl(d0); ///#endif PREG = NEXTOP(PREG, oy); SREG++; - traced_UnifyBound(d0, d1); + UnifyBound(d0, d1); /* deref second argument */ - derefa_body(d1, pt1, traced_uvaly_loc_nonvar_unk, traced_uvaly_loc_nonvar_nonvar); + derefa_body(d1, pt1, uvaly_loc_nonvar_unk, uvaly_loc_nonvar_nonvar); /* first argument bound, second unbound */ ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK_TEST(UNIFY_Y_LOC_UVALY_LOC_NONVAR_UNK); @@ -4339,7 +4366,7 @@ S_SREG = RepAppl(d0); ENDP(pt1); /* first argument may be unbound */ - derefa_body(d0, pt0, traced_uvaly_loc_unk, traced_uvaly_loc_nonvar); + derefa_body(d0, pt0, uvaly_loc_unk, uvaly_loc_nonvar); /* first argument is unbound */ ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK_TEST(UNIFY_Y_LOC_UVALY_LOC_UNK); @@ -4347,9 +4374,9 @@ S_SREG = RepAppl(d0); BEGP(pt1); pt1 = YREG+PREG->y_u.oy.y; d1 = *pt1; - deref_head(d1, traced_uvaly_loc_var_unk); + deref_head(d1, uvaly_loc_var_unk); - traced_uvaly_loc_var_nonvar: + uvaly_loc_var_nonvar: /* first unbound, second bound */ ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK_TEST(UNIFY_Y_LOC_UVALY_LOC_VAR_NONVAR); @@ -4361,7 +4388,7 @@ S_SREG = RepAppl(d0); /* Here we are in trouble: we have a clash between pt1 and * SREG. We address this by storing SREG in d0 for the duration. */ - derefa_body(d1, pt1, traced_uvaly_loc_var_unk, traced_uvaly_loc_var_nonvar); + derefa_body(d1, pt1, uvaly_loc_var_unk, uvaly_loc_var_nonvar); /* both arguments are unbound */ ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK_TEST(UNIFY_Y_LOC_UVALY_LOC_VAR_UNK); @@ -4376,21 +4403,21 @@ S_SREG = RepAppl(d0); ENDD(d0); ENDOp(); - OpW(traced_unify_y_loc_write, oy); + OpW(unify_y_loc_write, oy); /* we are in write mode */ EMIT_ENTRY_BLOCK(PREG,UNIFY_Y_LOC_WRITE_INSTINIT); BEGD(d0); BEGP(pt0); pt0 = YREG+PREG->y_u.oy.y; d0 = *pt0; - profiled_deref_head_TEST(d0, traced_unify_y_loc_unk); - traced_unify_y_loc_nonvar: + profiled_deref_head_TEST(d0, unify_y_loc_unk); + unify_y_loc_nonvar: EMIT_SIMPLE_BLOCK_TEST(UNIFY_Y_LOC_WRITE_UNIFY_Y_LOC_NONVAR); *SREG++ = d0; PREG = NEXTOP(PREG, oy); GONextW(); - profiled_derefa_body(d0, pt0, traced_unify_y_loc_unk, traced_unify_y_loc_nonvar); + profiled_derefa_body(d0, pt0, unify_y_loc_unk, unify_y_loc_nonvar); /* d0 is a variable, check whether we need to globalise it */ EMIT_SIMPLE_BLOCK_TEST(UNIFY_Y_LOC_WRITE_UNIFY_Y_LOC_UNK); PREG = NEXTOP(PREG, oy); @@ -4413,7 +4440,7 @@ S_SREG = RepAppl(d0); ENDD(d0); ENDOpW(); - Op(traced_unify_l_y_loc, oy); + Op(unify_l_y_loc, oy); /* else we are in read mode */ ///#ifdef PROFILED_ABSMI EMIT_ENTRY_BLOCK(PREG,UNIFY_L_Y_LOC_INSTINIT); @@ -4423,9 +4450,9 @@ S_SREG = RepAppl(d0); BEGP(pt0); pt0 = SREG; d0 = *pt0; - deref_head(d0, traced_ulvaly_loc_unk); + deref_head(d0, ulvaly_loc_unk); - traced_ulvaly_loc_nonvar: + ulvaly_loc_nonvar: /* structure is bound */ ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK_TEST(UNIFY_L_Y_LOC_ULVALY_LOC_NONVAR); @@ -4433,19 +4460,19 @@ S_SREG = RepAppl(d0); BEGP(pt1); pt1 = YREG+PREG->y_u.oy.y; d1 = *pt1; - deref_head(d1, traced_ulvaly_loc_nonvar_unk); + deref_head(d1, ulvaly_loc_nonvar_unk); - traced_ulvaly_loc_nonvar_nonvar: + ulvaly_loc_nonvar_nonvar: /* both arguments are bound */ /* we may have to bind structures */ ///#ifdef PROFILED_ABSMI EMIT_MULTIPLE_DESTINY_BLOCK_TEST(UNIFY_L_Y_LOC_ULVALY_LOC_NONVAR_NONVAR); ///#endif PREG = NEXTOP(PREG, oy); - traced_UnifyBound(d0, d1); + UnifyBound(d0, d1); /* deref second argument */ - derefa_body(d1, pt1, traced_ulvaly_loc_nonvar_unk, traced_ulvaly_loc_nonvar_nonvar); + derefa_body(d1, pt1, ulvaly_loc_nonvar_unk, ulvaly_loc_nonvar_nonvar); /* first argument bound, second unbound */ ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK_TEST(UNIFY_L_Y_LOC_ULVALY_LOC_NONVAR_UNK); @@ -4456,7 +4483,7 @@ S_SREG = RepAppl(d0); ENDP(pt1); /* first argument may be unbound */ - derefa_body(d0, pt0, traced_ulvaly_loc_unk, traced_ulvaly_loc_nonvar); + derefa_body(d0, pt0, ulvaly_loc_unk, ulvaly_loc_nonvar); /* first argument is unbound */ ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK_TEST(UNIFY_L_Y_LOC_ULVALY_LOC_UNK); @@ -4464,9 +4491,9 @@ S_SREG = RepAppl(d0); BEGP(pt1); pt1 = YREG+PREG->y_u.oy.y; d1 = *pt1; - deref_head(d1, traced_ulvaly_loc_var_unk); + deref_head(d1, ulvaly_loc_var_unk); - traced_ulvaly_loc_var_nonvar: + ulvaly_loc_var_nonvar: /* first unbound, second bound */ ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK_TEST(UNIFY_L_Y_LOC_ULVALY_LOC_VAR_NONVAR); @@ -4477,7 +4504,7 @@ S_SREG = RepAppl(d0); /* Here we are in trouble: we have a clash between pt1 and * SREG. We address this by storing SREG in d0 for the duration. */ - derefa_body(d1, pt1, traced_ulvaly_loc_var_unk, traced_ulvaly_loc_var_nonvar); + derefa_body(d1, pt1, ulvaly_loc_var_unk, ulvaly_loc_var_nonvar); /* both arguments are unbound */ ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK_TEST(UNIFY_L_Y_LOC_ULVALY_LOC_VAR_UNK); @@ -4491,21 +4518,21 @@ S_SREG = RepAppl(d0); ENDD(d0); ENDOp(); - Op(traced_unify_l_y_loc_write, oy); + Op(unify_l_y_loc_write, oy); /* we are in write mode */ EMIT_ENTRY_BLOCK(PREG,UNIFY_L_Y_LOC_WRITE_INSTINIT); BEGD(d0); BEGP(pt0); pt0 = YREG+PREG->y_u.oy.y; d0 = *pt0; - profiled_deref_head_TEST(d0, traced_ulunify_y_loc_unk); - traced_ulunify_y_loc_nonvar: + profiled_deref_head_TEST(d0, ulunify_y_loc_unk); + ulunify_y_loc_nonvar: EMIT_SIMPLE_BLOCK_TEST(UNIFY_L_Y_LOC_WRITE_ULUNIFY_Y_LOC_NONVAR); SREG[0] = d0; PREG = NEXTOP(PREG, oy); GONext(); - profiled_derefa_body(d0, pt0, traced_ulunify_y_loc_unk, traced_ulunify_y_loc_nonvar); + profiled_derefa_body(d0, pt0, ulunify_y_loc_unk, ulunify_y_loc_nonvar); /* d0 is a variable, check whether we need to globalise it */ EMIT_SIMPLE_BLOCK_TEST(UNIFY_L_Y_LOC_WRITE_ULUNIFY_Y_LOC_UNK); PREG = NEXTOP(PREG, oy); @@ -4527,7 +4554,7 @@ S_SREG = RepAppl(d0); ENDD(d0); ENDOp(); - Op(traced_unify_void, o); + Op(unify_void, o); EMIT_ENTRY_BLOCK(PREG,UNIFY_VOID_INSTINIT); START_PREFETCH(o); PREG = NEXTOP(PREG, o); @@ -4536,7 +4563,7 @@ S_SREG = RepAppl(d0); END_PREFETCH(); ENDOp(); - OpW(traced_unify_void_write, o); + OpW(unify_void_write, o); EMIT_ENTRY_BLOCK(PREG,UNIFY_VOID_WRITE_INSTINIT); CACHE_S(); READ_IN_S(); @@ -4547,27 +4574,27 @@ S_SREG = RepAppl(d0); GONextW(); ENDOpW(); - Op(traced_unify_l_void, o); + Op(unify_l_void, o); EMIT_ENTRY_BLOCK(PREG,UNIFY_L_VOID_INSTINIT); PREG = NEXTOP(PREG, o); GONext(); ENDOp(); - Op(traced_unify_l_void_write, o); + Op(unify_l_void_write, o); EMIT_ENTRY_BLOCK(PREG,UNIFY_L_VOID_WRITE_INSTINIT); PREG = NEXTOP(PREG, o); RESET_VARIABLE(SREG); GONext(); ENDOp(); - Op(traced_unify_n_voids, os); + Op(unify_n_voids, os); EMIT_ENTRY_BLOCK(PREG,UNIFY_N_VOIDS_INSTINIT); SREG += PREG->y_u.os.s; PREG = NEXTOP(PREG, os); GONext(); ENDOp(); - OpW(traced_unify_n_voids_write, os); + OpW(unify_n_voids_write, os); EMIT_ENTRY_BLOCK(PREG,UNIFY_N_VOIDS_WRITE_INSTINIT); BEGD(d0); CACHE_S(); @@ -4584,13 +4611,13 @@ S_SREG = RepAppl(d0); GONextW(); ENDOpW(); - Op(traced_unify_l_n_voids, os); + Op(unify_l_n_voids, os); EMIT_ENTRY_BLOCK(PREG,UNIFY_L_N_VOIDS_INSTINIT); PREG = NEXTOP(PREG, os); GONext(); ENDOp(); - Op(traced_unify_l_n_voids_write, os); + Op(unify_l_n_voids_write, os); EMIT_ENTRY_BLOCK(PREG,UNIFY_L_N_VOIDS_WRITE_INSTINIT); BEGD(d0); d0 = PREG->y_u.os.s; @@ -4606,22 +4633,22 @@ S_SREG = RepAppl(d0); GONext(); ENDOp(); - Op(traced_unify_atom, oc); + Op(unify_atom, oc); EMIT_ENTRY_BLOCK(PREG,UNIFY_ATOM_INSTINIT); BEGD(d0); BEGP(pt0); pt0 = SREG++; d0 = *pt0; - profiled_deref_head_TEST(d0, traced_uatom_unk); - traced_uatom_nonvar: + profiled_deref_head_TEST(d0, uatom_unk); + uatom_nonvar: EMIT_MULTIPLE_DESTINY_BLOCK_TEST(UNIFY_ATOM_UATOM_NONVAR); if (d0 != PREG->y_u.oc.c) { - TRACED_FAIL(); + FAIL(); } PREG = NEXTOP(PREG, oc); GONext(); - profiled_derefa_body(d0, pt0, traced_uatom_unk, traced_uatom_nonvar); + profiled_derefa_body(d0, pt0, uatom_unk, uatom_nonvar); EMIT_SIMPLE_BLOCK_TEST(UNIFY_ATOM_UATOM_UNK); d0 = PREG->y_u.oc.c; PREG = NEXTOP(PREG, oc); @@ -4631,29 +4658,29 @@ S_SREG = RepAppl(d0); ENDD(d0); ENDOp(); - OpW(traced_unify_atom_write, oc); + OpW(unify_atom_write, oc); EMIT_ENTRY_BLOCK(PREG,UNIFY_ATOM_WRITE_INSTINIT); * SREG++ = PREG->y_u.oc.c; PREG = NEXTOP(PREG, oc); GONextW(); ENDOpW(); - Op(traced_unify_l_atom, oc); + Op(unify_l_atom, oc); EMIT_ENTRY_BLOCK(PREG,UNIFY_L_ATOM_INSTINIT); BEGD(d0); BEGP(pt0); pt0 = SREG; d0 = *SREG; - profiled_deref_head_TEST(d0, traced_ulatom_unk); - traced_ulatom_nonvar: + profiled_deref_head_TEST(d0, ulatom_unk); + ulatom_nonvar: EMIT_MULTIPLE_DESTINY_BLOCK_TEST(UNIFY_L_ATOM_ULATOM_NONVAR); if (d0 != PREG->y_u.oc.c) { - TRACED_FAIL(); + FAIL(); } PREG = NEXTOP(PREG, oc); GONext(); - profiled_derefa_body(d0, pt0, traced_ulatom_unk, traced_ulatom_nonvar); + profiled_derefa_body(d0, pt0, ulatom_unk, ulatom_nonvar); EMIT_SIMPLE_BLOCK_TEST(UNIFY_L_ATOM_ULATOM_UNK); d0 = PREG->y_u.oc.c; PREG = NEXTOP(PREG, oc); @@ -4663,14 +4690,14 @@ S_SREG = RepAppl(d0); ENDD(d0); ENDOp(); - Op(traced_unify_l_atom_write, oc); + Op(unify_l_atom_write, oc); EMIT_ENTRY_BLOCK(PREG,UNIFY_L_ATOM_WRITE_INSTINIT); SREG[0] = PREG->y_u.oc.c; PREG = NEXTOP(PREG, oc); GONext(); ENDOp(); - Op(traced_unify_n_atoms, osc); + Op(unify_n_atoms, osc); EMIT_ENTRY_BLOCK(PREG,UNIFY_N_ATOMS_INSTINIT); { register Int i = PREG->y_u.osc.s; /* not enough registers */ @@ -4682,18 +4709,18 @@ S_SREG = RepAppl(d0); BEGP(pt0); pt0 = SREG++; d0 = *pt0; - deref_head(d0, traced_uatom_n_var); - traced_uatom_n_nonvar: + deref_head(d0, uatom_n_var); + uatom_n_nonvar: if (d0 != d1) { - TRACED_FAIL(); + FAIL(); } continue; do { (pt0) = (CELL *)(d0); (d0) = *(CELL *)(d0); - if(!IsVarTerm(d0)) goto traced_uatom_n_nonvar; - traced_uatom_n_var:; + if(!IsVarTerm(d0)) goto uatom_n_nonvar; + uatom_n_var:; } while (Unsigned(pt0) != (d0)); Bind_Global(pt0, d1); continue; @@ -4706,7 +4733,7 @@ S_SREG = RepAppl(d0); GONext(); ENDOp(); - OpW(traced_unify_n_atoms_write, osc); + OpW(unify_n_atoms_write, osc); EMIT_ENTRY_BLOCK(PREG,UNIFY_N_ATOMS_WRITE_INSTINIT); BEGD(d0); BEGD(d1); @@ -4726,7 +4753,7 @@ S_SREG = RepAppl(d0); GONextW(); ENDOpW(); - Op(traced_unify_float, od); + Op(unify_float, od); ///#ifdef PROFILED_ABSMI EMIT_ENTRY_BLOCK(PREG,UNIFY_FLOAT_INSTINIT); ///#endif @@ -4734,10 +4761,10 @@ S_SREG = RepAppl(d0); BEGP(pt0); pt0 = SREG++; d0 = *pt0; - deref_head(d0, traced_ufloat_unk); - traced_ufloat_nonvar: + deref_head(d0, ufloat_unk); + ufloat_nonvar: if (!IsApplTerm(d0)) { - TRACED_FAIL(); + FAIL(); } /* look inside term */ ///#ifdef PROFILED_ABSMI @@ -4748,7 +4775,7 @@ S_SREG = RepAppl(d0); BEGD(d0); d0 = *pt0; if (d0 != (CELL)FunctorDouble) { - TRACED_FAIL(); + FAIL(); } ENDD(d0); ///#ifdef PROFILED_ABSMI @@ -4763,7 +4790,7 @@ S_SREG = RepAppl(d0); || pt1[2] != pt0[2] #endif ) { - TRACED_FAIL(); + FAIL(); } ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK_TEST(UNIFY_FLOAT_UFLOAT_NONVAR_END); @@ -4772,7 +4799,7 @@ S_SREG = RepAppl(d0); ENDP(pt0); GONext(); - derefa_body(d0, pt0, traced_ufloat_unk, traced_ufloat_nonvar); + derefa_body(d0, pt0, ufloat_unk, ufloat_nonvar); ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK_TEST(UNIFY_FLOAT_UFLOAT_UNK); ///#endif @@ -4786,14 +4813,14 @@ S_SREG = RepAppl(d0); ENDD(d0); ENDOp(); - OpW(traced_unify_float_write, od); + OpW(unify_float_write, od); EMIT_ENTRY_BLOCK(PREG,UNIFY_FLOAT_WRITE_INSTINIT); * SREG++ = AbsAppl(PREG->y_u.od.d); PREG = NEXTOP(PREG, od); GONextW(); ENDOpW(); - Op(traced_unify_l_float, od); + Op(unify_l_float, od); ///#ifdef PROFILED_ABSMI EMIT_ENTRY_BLOCK(PREG,UNIFY_L_FLOAT_INSTINIT); ///#endif @@ -4801,10 +4828,10 @@ S_SREG = RepAppl(d0); CACHE_S(); READ_IN_S(); d0 = *S_SREG; - deref_head(d0, traced_ulfloat_unk); - traced_ulfloat_nonvar: + deref_head(d0, ulfloat_unk); + ulfloat_nonvar: if (!IsApplTerm(d0)) { - TRACED_FAIL(); + FAIL(); } ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK_TEST(UNIFY_L_FLOAT_D0ISAPPL); @@ -4814,7 +4841,7 @@ S_SREG = RepAppl(d0); BEGD(d0); d0 = *pt0; if (d0 != (CELL)FunctorDouble) { - TRACED_FAIL(); + FAIL(); } ENDD(d0); ///#ifdef PROFILED_ABSMI @@ -4829,7 +4856,7 @@ S_SREG = RepAppl(d0); || pt1[2] != pt0[2] #endif ) { - TRACED_FAIL(); + FAIL(); } ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK_TEST(UNIFY_L_FLOAT_EQUALS); @@ -4838,7 +4865,7 @@ S_SREG = RepAppl(d0); ENDP(pt0); GONext(); - derefa_body(d0, S_SREG, traced_ulfloat_unk, traced_ulfloat_nonvar); + derefa_body(d0, S_SREG, ulfloat_unk, ulfloat_nonvar); ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK_TEST(UNIFY_L_FLOAT_ULFLOAT_UNK); ///#endif @@ -4852,14 +4879,14 @@ S_SREG = RepAppl(d0); ENDD(d0); ENDOp(); - Op(traced_unify_l_float_write, od); + Op(unify_l_float_write, od); EMIT_ENTRY_BLOCK(PREG,UNIFY_L_FLOAT_WRITE_INSTINIT); SREG[0] = AbsAppl(PREG->y_u.od.d); PREG = NEXTOP(PREG, od); GONext(); ENDOp(); - Op(traced_unify_longint, oi); + Op(unify_longint, oi); ///#ifdef PROFILED_ABSMI EMIT_ENTRY_BLOCK(PREG,UNIFY_LONGINT_INSTINIT); ///#endif @@ -4867,11 +4894,11 @@ S_SREG = RepAppl(d0); BEGP(pt0); pt0 = SREG++; d0 = *pt0; - deref_head(d0, traced_ulongint_unk); - traced_ulongint_nonvar: + deref_head(d0, ulongint_unk); + ulongint_nonvar: /* look inside term */ if (!IsApplTerm(d0)) { - TRACED_FAIL(); + FAIL(); } ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK_TEST(UNIFY_LONGINT_D0ISAPPL); @@ -4881,7 +4908,7 @@ S_SREG = RepAppl(d0); BEGD(d0); d0 = *pt0; if (d0 != (CELL)FunctorLongInt) { - TRACED_FAIL(); + FAIL(); } ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK_TEST(UNIFY_LONGINT_D0ISFUNC); @@ -4891,7 +4918,7 @@ S_SREG = RepAppl(d0); pt1 = PREG->y_u.oi.i; PREG = NEXTOP(PREG, oi); if (pt1[1] != pt0[1]) { - TRACED_FAIL(); + FAIL(); } ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK_TEST(UNIFY_LONGINT_EQUALS); @@ -4900,7 +4927,7 @@ S_SREG = RepAppl(d0); ENDP(pt0); GONext(); - derefa_body(d0, pt0, traced_ulongint_unk, traced_ulongint_nonvar); + derefa_body(d0, pt0, ulongint_unk, ulongint_nonvar); ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK_TEST(UNIFY_LONGINT_ULONGINT_UNK); ///#endif @@ -4914,14 +4941,14 @@ S_SREG = RepAppl(d0); ENDD(d0); ENDOp(); - OpW(traced_unify_longint_write, oi); + OpW(unify_longint_write, oi); EMIT_ENTRY_BLOCK(PREG,UNIFY_LONGINT_WRITE_INSTINIT); * SREG++ = AbsAppl(PREG->y_u.oi.i); PREG = NEXTOP(PREG, oi); GONextW(); ENDOpW(); - Op(traced_unify_l_longint, oi); + Op(unify_l_longint, oi); ///#ifdef PROFILED_ABSMI EMIT_ENTRY_BLOCK(PREG,UNIFY_L_LONGINT_INSTINIT); ///#endif @@ -4929,10 +4956,10 @@ S_SREG = RepAppl(d0); CACHE_S(); READ_IN_S(); d0 = *S_SREG; - deref_head(d0, traced_ullongint_unk); - traced_ullongint_nonvar: + deref_head(d0, ullongint_unk); + ullongint_nonvar: if (!IsApplTerm(d0)) { - TRACED_FAIL(); + FAIL(); } ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK_TEST(UNIFY_L_LONGINT_D0ISAPPL); @@ -4942,7 +4969,7 @@ S_SREG = RepAppl(d0); BEGD(d0); d0 = *pt0; if (d0 != (CELL)FunctorLongInt) { - TRACED_FAIL(); + FAIL(); } ENDD(d0); ///#ifdef PROFILED_ABSMI @@ -4952,7 +4979,7 @@ S_SREG = RepAppl(d0); pt1 = PREG->y_u.oi.i; PREG = NEXTOP(PREG, oi); if (pt1[1] != pt0[1]) { - TRACED_FAIL(); + FAIL(); } ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK_TEST(UNIFY_L_LONGINT_EQUALS); @@ -4961,7 +4988,7 @@ S_SREG = RepAppl(d0); ENDP(pt0); GONext(); - derefa_body(d0, S_SREG, traced_ullongint_unk, traced_ullongint_nonvar); + derefa_body(d0, S_SREG, ullongint_unk, ullongint_nonvar); ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK_TEST(UNIFY_L_LONGINT_ULLONGINT_UNK); ///#endif @@ -4975,14 +5002,14 @@ S_SREG = RepAppl(d0); ENDD(d0); ENDOp(); - Op(traced_unify_l_longint_write, oi); + Op(unify_l_longint_write, oi); EMIT_ENTRY_BLOCK(PREG,UNIFY_L_LONGINT_WRITE_INSTINIT); SREG[0] = AbsAppl(PREG->y_u.oi.i); PREG = NEXTOP(PREG, oi); GONext(); ENDOp(); - Op(traced_unify_bigint, oN); + Op(unify_bigint, oN); #ifdef USE_GMP ///#ifdef PROFILED_ABSMI EMIT_ENTRY_BLOCK(PREG,UNIFY_BIGINT_INSTINIT); @@ -4991,11 +5018,11 @@ S_SREG = RepAppl(d0); BEGP(pt0); pt0 = SREG++; d0 = *pt0; - deref_head(d0, traced_ubigint_unk); - traced_ubigint_nonvar: + deref_head(d0, ubigint_unk); + ubigint_nonvar: /* look inside term */ if (!IsApplTerm(d0)) { - TRACED_FAIL(); + FAIL(); } ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK_TEST(UNIFY_BIGINT_D0ISAPPL); @@ -5006,11 +5033,11 @@ S_SREG = RepAppl(d0); d1 = *pt0; if (d1 != (CELL)FunctorBigInt) { - TRACED_FAIL(); + FAIL(); } ENDD(d1); if (Yap_gmp_tcmp_big_big(d0,PREG->y_u.oN.b)) { - TRACED_FAIL(); + FAIL(); } ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK_TEST(UNIFY_BIGINT_D1ISFUNC_GMP); @@ -5019,7 +5046,7 @@ S_SREG = RepAppl(d0); ENDP(pt0); GONext(); - derefa_body(d0, pt0, traced_ubigint_unk, traced_ubigint_nonvar); + derefa_body(d0, pt0, ubigint_unk, ubigint_nonvar); ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK_TEST(UNIFY_BIGINT_UBIGINT_UNK); ///#endif @@ -5032,11 +5059,11 @@ S_SREG = RepAppl(d0); ENDP(pt0); ENDD(d0); #else - TRACED_FAIL(); + FAIL(); #endif ENDOp(); - Op(traced_unify_l_bigint, oN); + Op(unify_l_bigint, oN); #ifdef USE_GMP ///#ifdef PROFILED_ABSMI EMIT_ENTRY_BLOCK(PREG,UNIFY_L_BIGINT_INSTINIT); @@ -5045,10 +5072,10 @@ S_SREG = RepAppl(d0); CACHE_S(); READ_IN_S(); d0 = *S_SREG; - deref_head(d0, traced_ulbigint_unk); - traced_ulbigint_nonvar: + deref_head(d0, ulbigint_unk); + ulbigint_nonvar: if (!IsApplTerm(d0)) { - TRACED_FAIL(); + FAIL(); } ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK_TEST(UNIFY_L_BIGINT_D0ISAPPL); @@ -5059,11 +5086,11 @@ S_SREG = RepAppl(d0); d0 = *pt0; if (d0 != (CELL)FunctorBigInt) { - TRACED_FAIL(); + FAIL(); } ENDD(d0); if (Yap_gmp_tcmp_big_big(d0,PREG->y_u.oN.b)) { - TRACED_FAIL(); + FAIL(); } ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK_TEST(UNIFY_L_BIGINT_D0ISFUNC_GMP); @@ -5072,7 +5099,7 @@ S_SREG = RepAppl(d0); ENDP(pt0); GONext(); - derefa_body(d0, S_SREG, traced_ulbigint_unk, traced_ulbigint_nonvar); + derefa_body(d0, S_SREG, ulbigint_unk, ulbigint_nonvar); ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK_TEST(UNIFY_L_BIGINT_ULBIGINT_UNK); ///#endif @@ -5085,11 +5112,11 @@ S_SREG = RepAppl(d0); ENDCACHE_S(); ENDD(d0); #else - TRACED_FAIL(); + FAIL(); #endif ENDOp(); - Op(traced_unify_dbterm, oD); + Op(unify_dbterm, oD); ///#ifdef PROFILED_ABSMI EMIT_ENTRY_BLOCK(PREG,UNIFY_DBTERM_INSTINIT); ///#endif @@ -5097,8 +5124,8 @@ S_SREG = RepAppl(d0); BEGP(pt0); pt0 = SREG++; d0 = *pt0; - deref_head(d0, traced_udbterm_unk); - traced_udbterm_nonvar: + deref_head(d0, udbterm_unk); + udbterm_nonvar: ///#ifdef PROFILED_ABSMI EMIT_MULTIPLE_DESTINY_BLOCK_TEST(UNIFY_DBTERM_UDBTERM_NONVAR); ///#endif @@ -5106,10 +5133,10 @@ S_SREG = RepAppl(d0); /* we have met a preexisting dbterm */ d1 = PREG->y_u.oD.D; PREG = NEXTOP(PREG, oD); - traced_UnifyBound(d0,d1); + UnifyBound(d0,d1); ENDD(d1); - derefa_body(d0, pt0, traced_udbterm_unk, traced_udbterm_nonvar); + derefa_body(d0, pt0, udbterm_unk, udbterm_nonvar); ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK_TEST(UNIFY_DBTERM_UDBTERM_UNK); ///#endif @@ -5123,7 +5150,7 @@ S_SREG = RepAppl(d0); ENDD(d0); ENDOp(); - Op(traced_unify_l_dbterm, oD); + Op(unify_l_dbterm, oD); ///#ifdef PROFILED_ABSMI EMIT_ENTRY_BLOCK(PREG,UNIFY_L_DBTERM_INSTINIT); ///#endif @@ -5131,8 +5158,8 @@ S_SREG = RepAppl(d0); CACHE_S(); READ_IN_S(); d0 = *S_SREG; - deref_head(d0, traced_uldbterm_unk); - traced_uldbterm_nonvar: + deref_head(d0, uldbterm_unk); + uldbterm_nonvar: ///#ifdef PROFILED_ABSMI EMIT_MULTIPLE_DESTINY_BLOCK_TEST(UNIFY_L_DBTERM_ULDBTERM_NONVAR); ///#endif @@ -5140,10 +5167,10 @@ S_SREG = RepAppl(d0); /* we have met a preexisting dbterm */ d1 = PREG->y_u.oD.D; PREG = NEXTOP(PREG, oD); - traced_UnifyBound(d0,d1); + UnifyBound(d0,d1); ENDD(d1); - derefa_body(d0, S_SREG, traced_uldbterm_unk, traced_uldbterm_nonvar); + derefa_body(d0, S_SREG, uldbterm_unk, uldbterm_nonvar); ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK_TEST(UNIFY_L_DBTERM_ULDBTERM_UNK); ///#endif @@ -5157,7 +5184,7 @@ S_SREG = RepAppl(d0); ENDD(d0); ENDOp(); - OpRW(traced_unify_list, o); + OpRW(unify_list, o); EMIT_ENTRY_BLOCK(PREG,UNIFY_LIST_INSTINIT); *--SP = Unsigned(SREG + 1); *--SP = READ_MODE; @@ -5165,11 +5192,11 @@ S_SREG = RepAppl(d0); BEGP(pt0); pt0 = SREG; d0 = *pt0; - profiled_deref_head_TEST(d0, traced_ulist_unk); - traced_ulist_nonvar: + profiled_deref_head_TEST(d0, ulist_unk); + ulist_nonvar: EMIT_MULTIPLE_DESTINY_BLOCK_TEST(UNIFY_LIST_READMODE); if (!IsPairTerm(d0)) { - TRACED_FAIL(); + FAIL(); } /* we continue in read mode */ START_PREFETCH(o); @@ -5178,7 +5205,7 @@ S_SREG = RepAppl(d0); GONext(); END_PREFETCH(); - profiled_derefa_body(d0, pt0, traced_ulist_unk, traced_ulist_nonvar); + profiled_derefa_body(d0, pt0, ulist_unk, ulist_nonvar); EMIT_SIMPLE_BLOCK_TEST(UNIFY_LIST_WRITEMODE); /* we enter write mode */ START_PREFETCH_W(o); @@ -5199,7 +5226,7 @@ S_SREG = RepAppl(d0); ENDD(d0); ENDOpRW(); - OpW(traced_unify_list_write, o); + OpW(unify_list_write, o); EMIT_ENTRY_BLOCK(PREG,UNIFY_LIST_WRITE_INSTINIT); PREG = NEXTOP(PREG, o); BEGD(d0); @@ -5218,18 +5245,18 @@ S_SREG = RepAppl(d0); ENDD(d0); ENDOpW(); - OpRW(traced_unify_l_list, o); + OpRW(unify_l_list, o); EMIT_ENTRY_BLOCK(PREG,UNIFY_L_LIST_INSTINIT); BEGD(d0); BEGP(pt0); pt0 = SREG; d0 = *pt0; - profiled_deref_head_TEST(d0, traced_ullist_unk); - traced_ullist_nonvar: + profiled_deref_head_TEST(d0, ullist_unk); + ullist_nonvar: EMIT_MULTIPLE_DESTINY_BLOCK_TEST(UNIFY_L_LIST_READMODE); START_PREFETCH(o); if (!IsPairTerm(d0)) { - TRACED_FAIL(); + FAIL(); } /* we continue in read mode */ PREG = NEXTOP(PREG, o); @@ -5237,7 +5264,7 @@ S_SREG = RepAppl(d0); GONext(); END_PREFETCH(); - profiled_derefa_body(d0, pt0, traced_ullist_unk, traced_ullist_nonvar); + profiled_derefa_body(d0, pt0, ullist_unk, ullist_nonvar); /* we enter write mode */ EMIT_SIMPLE_BLOCK_TEST(UNIFY_L_LIST_WRITEMODE); START_PREFETCH_W(o); @@ -5257,7 +5284,7 @@ S_SREG = RepAppl(d0); ENDD(d0); ENDOpRW(); - OpW(traced_unify_l_list_write, o); + OpW(unify_l_list_write, o); /* we continue in write mode */ EMIT_ENTRY_BLOCK(PREG,UNIFY_L_LIST_WRITE_INSTINIT); BEGD(d0); @@ -5274,7 +5301,7 @@ S_SREG = RepAppl(d0); ENDD(d0); ENDOpW(); - OpRW(traced_unify_struct, ofa); + OpRW(unify_struct, ofa); EMIT_ENTRY_BLOCK(PREG,UNIFY_STRUCT_INSTINIT); *--SP = Unsigned(SREG + 1); *--SP = READ_MODE; @@ -5283,12 +5310,12 @@ S_SREG = RepAppl(d0); pt0 = SREG; d0 = *pt0; START_PREFETCH(ofa); - profiled_deref_head_TEST(d0, traced_ustruct_unk); - traced_ustruct_nonvar: + profiled_deref_head_TEST(d0, ustruct_unk); + ustruct_nonvar: /* we are in read mode */ EMIT_MULTIPLE_DESTINY_BLOCK_TEST(UNIFY_STRUCT_READMODE); if (!IsApplTerm(d0)) { - TRACED_FAIL(); + FAIL(); } CACHE_S(); READ_IN_S(); @@ -5297,7 +5324,7 @@ S_SREG = RepAppl(d0); /* just check functor */ d0 = (CELL) (PREG->y_u.ofa.f); if (*S_SREG != d0) { - TRACED_FAIL(); + FAIL(); } PREG = NEXTOP(PREG, ofa); WRITEBACK_S(S_SREG+1); @@ -5305,7 +5332,7 @@ S_SREG = RepAppl(d0); GONext(); END_PREFETCH(); - profiled_derefa_body(d0, pt0, traced_ustruct_unk, traced_ustruct_nonvar); + profiled_derefa_body(d0, pt0, ustruct_unk, ustruct_nonvar); /* Enter Write mode */ EMIT_SIMPLE_BLOCK_TEST(UNIFY_STRUCT_WRITEMODE); START_PREFETCH_W(ofa); @@ -5334,7 +5361,7 @@ S_SREG = RepAppl(d0); ENDD(d0); ENDOpRW(); - OpW(traced_unify_struct_write, ofa); + OpW(unify_struct_write, ofa); EMIT_ENTRY_BLOCK(PREG,UNIFY_STRUCT_WRITE_INSTINIT); CACHE_S(); READ_IN_S(); @@ -5355,32 +5382,32 @@ S_SREG = RepAppl(d0); GONextW(); ENDOpW(); - OpRW(traced_unify_l_struc, ofa); + OpRW(unify_l_struc, ofa); EMIT_ENTRY_BLOCK(PREG,UNIFY_L_STRUC_INSTINIT); BEGD(d0); BEGP(pt0); pt0 = SREG; d0 = *pt0; - profiled_deref_head_TEST(d0, traced_ulstruct_unk); - traced_ulstruct_nonvar: + profiled_deref_head_TEST(d0, ulstruct_unk); + ulstruct_nonvar: /* we are in read mode */ EMIT_MULTIPLE_DESTINY_BLOCK_TEST(UNIFY_L_STRUC_READMODE); START_PREFETCH(ofa); if (!IsApplTerm(d0)) { - TRACED_FAIL(); + FAIL(); } /* we continue in read mode */ SREG = RepAppl(d0); /* just check functor */ d0 = (CELL) (PREG->y_u.ofa.f); if (*SREG++ != d0) { - TRACED_FAIL(); + FAIL(); } PREG = NEXTOP(PREG, ofa); GONext(); END_PREFETCH(); - profiled_derefa_body(d0, pt0, traced_ulstruct_unk, traced_ulstruct_nonvar); + profiled_derefa_body(d0, pt0, ulstruct_unk, ulstruct_nonvar); /* Enter Write mode */ EMIT_SIMPLE_BLOCK_TEST(UNIFY_L_STRUC_WRITEMODE); /* set d1 to be the new structure we are going to create */ @@ -5408,7 +5435,7 @@ S_SREG = RepAppl(d0); ENDD(d0); ENDOpRW(); - OpW(traced_unify_l_struc_write, ofa); + OpW(unify_l_struc_write, ofa); EMIT_ENTRY_BLOCK(PREG,UNIFY_L_STRUC_WRITE_INSTINIT); BEGD(d0); d0 = AbsAppl(HR); @@ -5431,7 +5458,7 @@ S_SREG = RepAppl(d0); * Put Instructions * \************************************************************************/ - Op(traced_put_x_var, xx); + Op(put_x_var, xx); EMIT_ENTRY_BLOCK(PREG,PUT_X_VAR_INSTINIT); BEGP(pt0); pt0 = HR; @@ -5444,7 +5471,7 @@ S_SREG = RepAppl(d0); GONext(); ENDOp(); - Op(traced_put_y_var, yx); + Op(put_y_var, yx); EMIT_ENTRY_BLOCK(PREG,PUT_Y_VAR_INSTINIT); BEGP(pt0); pt0 = YREG + PREG->y_u.yx.y; @@ -5462,7 +5489,7 @@ S_SREG = RepAppl(d0); GONext(); ENDOp(); - Op(traced_put_x_val, xx); + Op(put_x_val, xx); EMIT_ENTRY_BLOCK(PREG,PUT_X_VAL_INSTINIT); BEGD(d0); d0 = XREG(PREG->y_u.xx.xl); @@ -5472,7 +5499,7 @@ S_SREG = RepAppl(d0); GONext(); ENDOp(); - Op(traced_put_xx_val, xxxx); + Op(put_xx_val, xxxx); EMIT_ENTRY_BLOCK(PREG,PUT_XX_VAL_INSTINIT); BEGD(d0); BEGD(d1); @@ -5486,7 +5513,7 @@ S_SREG = RepAppl(d0); GONext(); ENDOp(); - Op(traced_put_y_val, yx); + Op(put_y_val, yx); EMIT_ENTRY_BLOCK(PREG,PUT_Y_VAL_INSTINIT); BEGD(d0); d0 = YREG[PREG->y_u.yx.y]; @@ -5501,7 +5528,7 @@ S_SREG = RepAppl(d0); GONext(); ENDOp(); - Op(traced_put_y_vals, yyxx); + Op(put_y_vals, yyxx); EMIT_ENTRY_BLOCK(PREG,PUT_Y_VALS_INSTINIT); ALWAYS_START_PREFETCH(yyxx); BEGD(d0); @@ -5519,7 +5546,7 @@ S_SREG = RepAppl(d0); d1 = YREG[PREVOP(PREG,yyxx)->y_u.yyxx.y2]; #ifdef YAPOR_SBA if (d1 == 0) /* new variable */ - XREG(PREVOP(traced_PREG->y_u.yyxx,yyxx).x2) = (CELL)(YREG+PREG->y_u.yyxx.y2); + XREG(PREVOP(PREG->y_u.yyxx,yyxx).x2) = (CELL)(YREG+PREG->y_u.yyxx.y2); else #endif XREG(PREVOP(PREG,yyxx)->y_u.yyxx.x2) = d1; @@ -5528,20 +5555,20 @@ S_SREG = RepAppl(d0); ALWAYS_END_PREFETCH(); ENDOp(); - Op(traced_put_unsafe, yx); + Op(put_unsafe, yx); EMIT_ENTRY_BLOCK(PREG,PUT_UNSAFE_INSTINIT); BEGD(d0); BEGP(pt0); pt0 = YREG+PREG->y_u.yx.y; d0 = *pt0; - profiled_deref_head_TEST(d0, traced_punsafe_unk); - traced_punsafe_nonvar: + profiled_deref_head_TEST(d0, punsafe_unk); + punsafe_nonvar: EMIT_SIMPLE_BLOCK_TEST(PUT_UNSAFE_PUNSAFE_NONVAR); XREG(PREG->y_u.yx.x) = d0; PREG = NEXTOP(PREG, yx); GONext(); - profiled_derefa_body(d0, pt0, traced_punsafe_unk, traced_punsafe_nonvar); + profiled_derefa_body(d0, pt0, punsafe_unk, punsafe_nonvar); EMIT_SIMPLE_BLOCK_TEST(PUT_UNSAFE_PUNSAFE_UNK); /* d0 is a variable, check whether we need to globalise it */ if (pt0 <= HR || pt0 >= YREG) { @@ -5563,7 +5590,7 @@ S_SREG = RepAppl(d0); ENDD(d0); ENDOp(); - Op(traced_put_atom, xc); + Op(put_atom, xc); EMIT_ENTRY_BLOCK(PREG,PUT_ATOM_INSTINIT); BEGD(d0); d0 = PREG->y_u.xc.c; @@ -5573,7 +5600,7 @@ S_SREG = RepAppl(d0); ENDD(d0); ENDOp(); - Op(traced_put_dbterm, xD); + Op(put_dbterm, xD); EMIT_ENTRY_BLOCK(PREG,PUT_DBTERM_INSTINIT); BEGD(d0); d0 = PREG->y_u.xD.D; @@ -5583,7 +5610,7 @@ S_SREG = RepAppl(d0); ENDD(d0); ENDOp(); - Op(traced_put_bigint, xN); + Op(put_bigint, xN); EMIT_ENTRY_BLOCK(PREG,PUT_BIGINT_INSTINIT); BEGD(d0); d0 = PREG->y_u.xN.b; @@ -5593,7 +5620,7 @@ S_SREG = RepAppl(d0); ENDD(d0); ENDOp(); - Op(traced_put_float, xd); + Op(put_float, xd); EMIT_ENTRY_BLOCK(PREG,PUT_FLOAT_INSTINIT); BEGD(d0); d0 = AbsAppl(PREG->y_u.xd.d); @@ -5603,7 +5630,7 @@ S_SREG = RepAppl(d0); ENDD(d0); ENDOp(); - Op(traced_put_longint, xi); + Op(put_longint, xi); EMIT_ENTRY_BLOCK(PREG,PUT_LONGINT_INSTINIT); BEGD(d0); d0 = AbsAppl(PREG->y_u.xi.i); @@ -5613,7 +5640,7 @@ S_SREG = RepAppl(d0); ENDD(d0); ENDOp(); - Op(traced_put_list, x); + Op(put_list, x); EMIT_ENTRY_BLOCK(PREG,PUT_LIST_INSTINIT); CACHE_S(); READ_IN_S(); @@ -5629,7 +5656,7 @@ S_SREG = RepAppl(d0); GONext(); ENDOp(); - Op(traced_put_struct, xfa); + Op(put_struct, xfa); EMIT_ENTRY_BLOCK(PREG,PUT_STRUCT_INSTINIT); BEGD(d0); d0 = AbsAppl(HR); @@ -5647,7 +5674,7 @@ S_SREG = RepAppl(d0); * Write Instructions * \************************************************************************/ - Op(traced_write_x_var, x); + Op(write_x_var, x); EMIT_ENTRY_BLOCK(PREG,WRITE_X_VAR_INSTINIT); XREG(PREG->y_u.x.x) = Unsigned(SREG); PREG = NEXTOP(PREG, x); @@ -5656,7 +5683,7 @@ S_SREG = RepAppl(d0); GONext(); ENDOp(); - Op(traced_write_void, e); + Op(write_void, e); EMIT_ENTRY_BLOCK(PREG,WRITE_VOID_INSTINIT); PREG = NEXTOP(PREG, e); RESET_VARIABLE(SREG); @@ -5664,7 +5691,7 @@ S_SREG = RepAppl(d0); GONext(); ENDOp(); - Op(traced_write_n_voids, s); + Op(write_n_voids, s); EMIT_ENTRY_BLOCK(PREG,WRITE_N_VOIDS_INSTINIT); BEGD(d0); d0 = PREG->y_u.s.s; @@ -5677,7 +5704,7 @@ S_SREG = RepAppl(d0); GONext(); ENDOp(); - Op(traced_write_y_var, y); + Op(write_y_var, y); EMIT_ENTRY_BLOCK(PREG,WRITE_Y_VAR_INSTINIT); INITIALIZE_PERMVAR(YREG+PREG->y_u.y.y,Unsigned(SREG)); PREG = NEXTOP(PREG, y); @@ -5686,7 +5713,7 @@ S_SREG = RepAppl(d0); GONext(); ENDOp(); - Op(traced_write_x_val, x); + Op(write_x_val, x); EMIT_ENTRY_BLOCK(PREG,WRITE_X_VAL_INSTINIT); BEGD(d0); d0 = XREG(PREG->y_u.x.x); @@ -5696,19 +5723,19 @@ S_SREG = RepAppl(d0); GONext(); ENDOp(); - Op(traced_write_x_loc, x); + Op(write_x_loc, x); EMIT_ENTRY_BLOCK(PREG,WRITE_X_LOC_INSTINIT); BEGD(d0); d0 = XREG(PREG->y_u.x.x); PREG = NEXTOP(PREG, x); - profiled_deref_head_TEST(d0, traced_w_x_unk); - traced_w_x_bound: + profiled_deref_head_TEST(d0, w_x_unk); + w_x_bound: EMIT_SIMPLE_BLOCK_TEST(WRITE_X_LOC_W_X_BOUND); *SREG++ = d0; GONext(); BEGP(pt0); - profiled_deref_body(d0, pt0, traced_w_x_unk, traced_w_x_bound); + profiled_deref_body(d0, pt0, w_x_unk, w_x_bound); EMIT_SIMPLE_BLOCK_TEST(WRITE_X_LOC_W_X_UNK); #if defined(YAPOR_SBA) && defined(FROZEN_STACKS) if (pt0 > HR && pt0<(CELL *)B_FZ) { @@ -5734,7 +5761,7 @@ S_SREG = RepAppl(d0); ENDD(d0); ENDOp(); - Op(traced_write_y_val, y); + Op(write_y_val, y); EMIT_ENTRY_BLOCK(PREG,WRITE_Y_VAL_INSTINIT); BEGD(d0); d0 = YREG[PREG->y_u.y.y]; @@ -5749,20 +5776,20 @@ S_SREG = RepAppl(d0); GONext(); ENDOp(); - Op(traced_write_y_loc, y); + Op(write_y_loc, y); EMIT_ENTRY_BLOCK(PREG,WRITE_Y_LOC_INSTINIT); BEGD(d0); BEGP(pt0); pt0 = YREG+PREG->y_u.y.y; d0 = *pt0; - profiled_deref_head_TEST(d0, traced_w_y_unk); - traced_w_y_bound: + profiled_deref_head_TEST(d0, w_y_unk); + w_y_bound: EMIT_SIMPLE_BLOCK_TEST(WRITE_Y_LOC_W_Y_BOUND); PREG = NEXTOP(PREG, y); *SREG++ = d0; GONext(); - profiled_derefa_body(d0, pt0, traced_w_y_unk, traced_w_y_bound); + profiled_derefa_body(d0, pt0, w_y_unk, w_y_bound); EMIT_SIMPLE_BLOCK_TEST(WRITE_Y_LOC_W_Y_UNK); if (pt0 > HR #if defined(YAPOR_SBA) && defined(FROZEN_STACKS) @@ -5789,7 +5816,7 @@ S_SREG = RepAppl(d0); ENDD(d0); ENDOp(); - Op(traced_write_atom, c); + Op(write_atom, c); EMIT_ENTRY_BLOCK(PREG,WRITE_ATOM_INSTINIT); BEGD(d0); d0 = PREG->y_u.c.c; @@ -5799,7 +5826,7 @@ S_SREG = RepAppl(d0); GONext(); ENDOp(); - Op(traced_write_bigint, N); + Op(write_bigint, N); EMIT_ENTRY_BLOCK(PREG,WRITE_BIGINT_INSTINIT); BEGD(d0); d0 = PREG->y_u.N.b; @@ -5809,7 +5836,7 @@ S_SREG = RepAppl(d0); GONext(); ENDOp(); - Op(traced_write_dbterm, D); + Op(write_dbterm, D); EMIT_ENTRY_BLOCK(PREG,WRITE_DBTERM_INSTINIT); BEGD(d0); d0 = PREG->y_u.D.D; @@ -5819,7 +5846,7 @@ S_SREG = RepAppl(d0); GONext(); ENDOp(); - Op(traced_write_float, d); + Op(write_float, d); EMIT_ENTRY_BLOCK(PREG,WRITE_FLOAT_INSTINIT); BEGD(d0); d0 = AbsAppl(PREG->y_u.d.d); @@ -5829,7 +5856,7 @@ S_SREG = RepAppl(d0); GONext(); ENDOp(); - Op(traced_write_longint, i); + Op(write_longint, i); EMIT_ENTRY_BLOCK(PREG,WRITE_LONGIT_INSTINIT); BEGD(d0); d0 = AbsAppl(PREG->y_u.i.i); @@ -5839,7 +5866,7 @@ S_SREG = RepAppl(d0); GONext(); ENDOp(); - Op(traced_write_n_atoms, sc); + Op(write_n_atoms, sc); EMIT_ENTRY_BLOCK(PREG,WRITE_N_ATOMS_INSTINIT); BEGD(d0); BEGD(d1); @@ -5854,7 +5881,7 @@ S_SREG = RepAppl(d0); GONext(); ENDOp(); - Op(traced_write_list, e); + Op(write_list, e); EMIT_ENTRY_BLOCK(PREG,WRITE_LIST_INSTINIT); BEGD(d0); d0 = AbsPair(HR); @@ -5870,7 +5897,7 @@ S_SREG = RepAppl(d0); GONext(); ENDOp(); - Op(traced_write_l_list, e); + Op(write_l_list, e); EMIT_ENTRY_BLOCK(PREG,WRITE_L_LIST_INSTINIT); ALWAYS_START_PREFETCH(e); PREG = NEXTOP(PREG, e); @@ -5887,7 +5914,7 @@ S_SREG = RepAppl(d0); ALWAYS_END_PREFETCH(); ENDOp(); - Op(traced_write_struct, fa); + Op(write_struct, fa); EMIT_ENTRY_BLOCK(PREG,WRITE_STRUCT_INSTINIT); BEGD(d0); d0 = AbsAppl(HR); @@ -5907,7 +5934,7 @@ S_SREG = RepAppl(d0); GONext(); ENDOp(); - Op(traced_write_l_struc, fa); + Op(write_l_struc, fa); EMIT_ENTRY_BLOCK(PREG,WRITE_L_STRUC_INSTINIT); BEGD(d0); d0 = AbsAppl(HR); @@ -5932,56 +5959,56 @@ S_SREG = RepAppl(d0); * othe instructions. */ - Op(traced_save_pair_x, ox); + Op(save_pair_x, ox); EMIT_ENTRY_BLOCK(PREG,SAVE_PAIR_X_INSTINIT); XREG(PREG->y_u.ox.x) = AbsPair(SREG); PREG = NEXTOP(PREG, ox); GONext(); ENDOp(); - OpW(traced_save_pair_x_write, ox); + OpW(save_pair_x_write, ox); EMIT_ENTRY_BLOCK(PREG,SAVE_PAIR_X_WRITE_INSTINIT); XREG(PREG->y_u.ox.x) = AbsPair(SREG); PREG = NEXTOP(PREG, ox); GONextW(); ENDOpW(); - Op(traced_save_pair_y, oy); + Op(save_pair_y, oy); EMIT_ENTRY_BLOCK(PREG,SAVE_PAIR_Y_INSTINIT); INITIALIZE_PERMVAR(YREG+PREG->y_u.oy.y,AbsPair(SREG)); PREG = NEXTOP(PREG, oy); GONext(); ENDOp(); - OpW(traced_save_pair_y_write, oy); + OpW(save_pair_y_write, oy); EMIT_ENTRY_BLOCK(PREG,SAVE_PAIR_Y_WRITE_INSTINIT); INITIALIZE_PERMVAR(YREG+PREG->y_u.oy.y,AbsPair(SREG)); PREG = NEXTOP(PREG, oy); GONextW(); ENDOpW(); - Op(traced_save_appl_x, ox); + Op(save_appl_x, ox); EMIT_ENTRY_BLOCK(PREG,SAVE_APPL_X_INSTINIT); XREG(PREG->y_u.ox.x) = AbsAppl(SREG - 1); PREG = NEXTOP(PREG, ox); GONext(); ENDOp(); - OpW(traced_save_appl_x_write, ox); + OpW(save_appl_x_write, ox); EMIT_ENTRY_BLOCK(PREG,SAVE_APPL_X_WRITE_INSTINIT); XREG(PREG->y_u.ox.x) = AbsAppl(SREG - 1); PREG = NEXTOP(PREG, ox); GONextW(); ENDOpW(); - Op(traced_save_appl_y, oy); + Op(save_appl_y, oy); EMIT_ENTRY_BLOCK(PREG,SAVE_APPL_Y_INSTINIT); INITIALIZE_PERMVAR(YREG+PREG->y_u.oy.y,AbsAppl(SREG-1)); PREG = NEXTOP(PREG, oy); GONext(); ENDOp(); - OpW(traced_save_appl_y_write, oy); + OpW(save_appl_y_write, oy); EMIT_ENTRY_BLOCK(PREG,SAVE_APPL_Y_WRITE_INSTINIT); INITIALIZE_PERMVAR(YREG+PREG->y_u.oy.y,AbsAppl(SREG-1)); PREG = NEXTOP(PREG, oy); @@ -5993,7 +6020,7 @@ S_SREG = RepAppl(d0); * Instructions for implemeting 'or;' * \************************************************************************/ - BOp(traced_jump, l); + BOp(jump, l); EMIT_ENTRY_BLOCK(PREG,JUMP_INSTINIT); PREG = PREG->y_u.l.l; JMPNext(); @@ -6002,7 +6029,7 @@ S_SREG = RepAppl(d0); /* This instruction is called when the previous goal was interrupted when waking up goals */ - BOp(traced_move_back, l); + BOp(move_back, l); EMIT_ENTRY_BLOCK(PREG,MOVE_BACK_INSTINIT); PREG = (yamop *)(((char *)PREG)-(Int)(NEXTOP((yamop *)NULL,Osbpp))); JMPNext(); @@ -6011,13 +6038,13 @@ S_SREG = RepAppl(d0); /* This instruction is called when the previous goal was interrupted when waking up goals */ - BOp(traced_skip, l); + BOp(skip, l); EMIT_ENTRY_BLOCK(PREG,SKIP_INSTINIT); PREG = NEXTOP(PREG,l); JMPNext(); ENDBOp(); - Op(traced_either, Osblp); + Op(either, Osblp); EMIT_ENTRY_BLOCK(PREG,EITHER_INSTINIT); #ifdef LOW_LEVEL_TRACER if (Yap_do_low_level_trace) { @@ -6069,7 +6096,7 @@ S_SREG = RepAppl(d0); ENDD(d0); ENDOp(); - Op(traced_or_else, Osblp); + Op(or_else, Osblp); ///#ifdef PROFILED_ABSMI EMIT_ENTRY_BLOCK(PREG,OR_ELSE_INSTINIT); ///#endif @@ -6104,9 +6131,9 @@ S_SREG = RepAppl(d0); ENDOp(); #ifdef YAPOR - Op(traced_or_last, Osblp); + Op(or_last, Osblp); #else - Op(traced_or_last, p); + Op(or_last, p); #endif /* YAPOR */ EMIT_ENTRY_BLOCK(PREG,OR_LAST_INSTINIT); BEGCHO(pt0); @@ -6156,7 +6183,7 @@ S_SREG = RepAppl(d0); * Pop operations * \************************************************************************/ - OpRW(traced_pop_n, s); + OpRW(pop_n, s); /* write mode might have been called from read mode */ EMIT_ENTRY_BLOCK(PREG,POP_N_INSTINIT); EMIT_MULTIPLE_DESTINY_BLOCK_TEST(POP_N_END); @@ -6185,7 +6212,7 @@ S_SREG = RepAppl(d0); ENDD(d0); ENDOpRW(); - OpRW(traced_pop, e); + OpRW(pop, e); EMIT_ENTRY_BLOCK(PREG,POP_INSTINIT); EMIT_MULTIPLE_DESTINY_BLOCK_TEST(POP_END); BEGD(d0); @@ -6211,7 +6238,7 @@ S_SREG = RepAppl(d0); * Call C predicates instructions * \************************************************************************/ - BOp(traced_call_cpred, Osbpp); + BOp(call_cpred, Osbpp); EMIT_ENTRY_BLOCK(PREG,CALL_CPRED_INSTINIT); EMIT_SIMPLE_BLOCK_TEST(YAAM_CHECK_TRAIL_TR); check_trail(TR); @@ -6262,7 +6289,7 @@ S_SREG = RepAppl(d0); #endif EMIT_MULTIPLE_DESTINY_BLOCK_TEST(CALL_CPRED_END); if (!d0) { - TRACED_FAIL(); + FAIL(); } CACHE_A1(); ENDD(d0); @@ -6270,7 +6297,7 @@ S_SREG = RepAppl(d0); ENDBOp(); /* execute Label */ - BOp(traced_execute_cpred, pp); + BOp(execute_cpred, pp); EMIT_ENTRY_BLOCK(PREG,EXECUTE_CPRED_INSTINIT); EMIT_SIMPLE_BLOCK_TEST(YAAM_CHECK_TRAIL_TR); check_trail(TR); @@ -6331,7 +6358,7 @@ S_SREG = RepAppl(d0); EMIT_SIMPLE_BLOCK_TEST(EXECUTE_CPRED_DEPTH_MINOR); if (pt0->ModuleOfPred) { if (DEPTH == MkIntTerm(0)) { - TRACED_FAIL(); + FAIL(); } else { DEPTH = RESET_DEPTH(); @@ -6361,7 +6388,7 @@ S_SREG = RepAppl(d0); SREG = Yap_REGS.S_; #endif if (!d0) { - TRACED_FAIL(); + FAIL(); } if (oldPREG == PREG) { /* we did not update PREG */ @@ -6387,7 +6414,7 @@ S_SREG = RepAppl(d0); /* trust the C-function we are calling and hence we must */ /* guarantee that *all* machine registers are saved and */ /* restored */ - BOp(traced_call_usercpred, Osbpp); + BOp(call_usercpred, Osbpp); EMIT_ENTRY_BLOCK(PREG,CALL_USERCPRED_INSTINIT); CACHE_Y_AS_ENV(YREG); EMIT_SIMPLE_BLOCK_TEST(NoStackCall_Exception); @@ -6422,7 +6449,7 @@ S_SREG = RepAppl(d0); /* make sure that we can still have access to our old PREG after calling user defined goals and backtracking or failing */ yamop *savedP; - Yap_StartSlots( PASS_REGS1 ); + Yap_StartSlots( ); LOCAL_PrologMode = UserCCallMode; { PredEntry *p = PREG->y_u.Osbpp.p; @@ -6446,7 +6473,7 @@ S_SREG = RepAppl(d0); Yap_JumpToEnv(Yap_PopTermFromDB(exp)); } if (!SREG) { - TRACED_FAIL(); + FAIL(); } /* in case we call Execute */ YENV = ENV; @@ -6454,7 +6481,7 @@ S_SREG = RepAppl(d0); JMPNext(); ENDBOp(); - BOp(traced_call_c_wfail, slp); + BOp(call_c_wfail, slp); //printf("call_c_wfail!!\n\n"); #ifdef LOW_LEVEL_TRACER if (Yap_do_low_level_trace) { @@ -6503,7 +6530,7 @@ S_SREG = RepAppl(d0); JMPNext(); ENDBOp(); - BOp(traced_try_c, OtapFs); + BOp(try_c, OtapFs); //printf("try_c!!\n\n"); #ifdef YAPOR CUT_wait_leftmost(); @@ -6523,7 +6550,7 @@ S_SREG = RepAppl(d0); SET_BB(B_YREG); ENDCACHE_Y(); - traced_TRYCC: + TRYCC: ASP = (CELL *)B; { CPredicate f = (CPredicate)(PREG->y_u.OtapFs.f); @@ -6545,7 +6572,7 @@ S_SREG = RepAppl(d0); while(POP_CHOICE_POINT(B)) cut_c_pop(); #endif - TRACED_FAIL(); + FAIL(); } if ((CELL *) B == YREG && ASP != (CELL *) B) { /* as Luis says, the predicate that did the try C might @@ -6560,7 +6587,7 @@ S_SREG = RepAppl(d0); JMPNext(); ENDBOp(); - BOp(traced_retry_c, OtapFs); + BOp(retry_c, OtapFs); //printf("retry_c!!\n\n"); #ifdef YAPOR CUT_wait_leftmost(); @@ -6575,10 +6602,10 @@ S_SREG = RepAppl(d0); HBREG = HR; restore_args(PREG->y_u.OtapFs.s); ENDCACHE_Y(); - goto traced_TRYCC; + goto TRYCC; ENDBOp(); - BOp(traced_cut_c, OtapFs); + BOp(cut_c, OtapFs); //printf("cut_c!!\n"); /*This is a phantom instruction. This is not executed by the WAM*/ #ifdef DEBUG @@ -6588,7 +6615,7 @@ S_SREG = RepAppl(d0); printf ("ERROR: Should not print this message FILE: absmi.c %d\n",__LINE__); ENDBOp(); - BOp(traced_try_userc, OtapFs); + BOp(try_userc, OtapFs); //printf("try_userc!!\n\n"); #ifdef YAPOR CUT_wait_leftmost(); @@ -6610,7 +6637,7 @@ S_SREG = RepAppl(d0); LOCAL_PrologMode = UserCCallMode; ASP = YREG; /* for slots to work */ - Yap_StartSlots( PASS_REGS1 ); + Yap_StartSlots( ); saveregs(); save_machine_regs(); SREG = (CELL *) YAP_ExecuteFirst(PREG->y_u.OtapFs.p, (CPredicate)(PREG->y_u.OtapFs.f)); @@ -6619,7 +6646,7 @@ S_SREG = RepAppl(d0); setregs(); LOCAL_PrologMode = UserMode; if (!SREG) { - TRACED_FAIL(); + FAIL(); } if ((CELL *) B == YREG && ASP != (CELL *) B) { /* as Luis says, the predicate that did the try C might @@ -6634,7 +6661,7 @@ S_SREG = RepAppl(d0); JMPNext(); ENDBOp(); - BOp(traced_retry_userc, OtapFs); + BOp(retry_userc, OtapFs); //printf("retry_userc!!\n\n"); #ifdef YAPOR CUT_wait_leftmost(); @@ -6667,7 +6694,7 @@ S_SREG = RepAppl(d0); while(POP_CHOICE_POINT(B)) cut_c_pop(); #endif - TRACED_FAIL(); + FAIL(); } if ((CELL *) B == YREG && ASP != (CELL *) B) { /* as Luis says, the predicate that did the try C might @@ -6683,7 +6710,7 @@ S_SREG = RepAppl(d0); ENDBOp(); #ifdef CUT_C - BOp(traced_cut_userc, OtapFs); + BOp(cut_userc, OtapFs); //printf("cut_userc!!\n"); /*This is a phantom instruction. This is not executed by the WAM*/ #ifdef DEBUG @@ -6701,7 +6728,7 @@ S_SREG = RepAppl(d0); * support instructions * \************************************************************************/ - BOp(traced_lock_pred, e); + BOp(lock_pred, e); { ///#ifdef PROFILED_ABSMI EMIT_ENTRY_BLOCK(PREG,LOCK_PRED_INSTINIT); @@ -6714,7 +6741,7 @@ S_SREG = RepAppl(d0); EMIT_SIMPLE_BLOCK(LOCK_PRED_FIRSTIFOK); ///#endif UNLOCKPE(11,ap); - TRACED_FAIL(); + FAIL(); } /* we do not lock access to the predicate, @@ -6743,7 +6770,7 @@ S_SREG = RepAppl(d0); JMPNext(); ENDBOp(); - BOp(traced_index_pred, e); + BOp(index_pred, e); { EMIT_ENTRY_BLOCK(PREG,INDEX_PRED_INSTINIT); EMIT_MULTIPLE_DESTINY_BLOCK_TEST(INDEX_PRED_END); @@ -6788,7 +6815,7 @@ S_SREG = RepAppl(d0); JMPNext(); ENDBOp(); - BOp(traced_thread_local, e); + BOp(thread_local, e); { #if THREADS EMIT_ENTRY_BLOCK(PREG,THREAD_LOCAL_INSTINIT); @@ -6807,7 +6834,7 @@ S_SREG = RepAppl(d0); JMPNext(); ENDBOp(); - BOp(traced_expand_index, e); + BOp(expand_index, e); { printf("expand index ainda não perfilado!\n"); exit(1); @@ -6881,7 +6908,7 @@ S_SREG = RepAppl(d0); } ENDBOp(); - BOp(traced_expand_clauses, sssllp); + BOp(expand_clauses, sssllp); { ///#ifdef PROFILED_ABSMI EMIT_ENTRY_BLOCK(PREG,EXPAND_CLAUSES_INSTINIT); @@ -6939,7 +6966,7 @@ S_SREG = RepAppl(d0); } ENDBOp(); - BOp(traced_undef_p, e); + BOp(undef_p, e); /* save S for module name */ EMIT_ENTRY_BLOCK(PREG,UNDEF_P_INSTINIT); EMIT_MULTIPLE_DESTINY_BLOCK_TEST(UNDEF_P_END); @@ -6953,7 +6980,7 @@ S_SREG = RepAppl(d0); PP = NULL; #endif UNLOCKPE(19,pe); - TRACED_FAIL(); + FAIL(); } d0 = pe->ArityOfPE; UNLOCKPE(19,pe); @@ -6971,8 +6998,8 @@ S_SREG = RepAppl(d0); BEGP(pt0); pt0 = pt1++; d1 = *pt0; - deref_head(d1, traced_undef_unk); - traced_undef_nonvar: + deref_head(d1, undef_unk); + undef_nonvar: /* just copy it to the heap */ *HR++ = d1; continue; @@ -6980,8 +7007,8 @@ S_SREG = RepAppl(d0); do { (pt0) = (CELL *)(d1); (d1) = *(CELL *)(d1); - if(!IsVarTerm(d1)) goto traced_undef_nonvar; - traced_undef_unk:; + if(!IsVarTerm(d1)) goto undef_nonvar; + undef_unk:; } while (Unsigned(pt0) != (d1)); if (pt0 <= HR) { @@ -7017,8 +7044,8 @@ S_SREG = RepAppl(d0); JMPNext(); ENDBOp(); - BOp(traced_spy_pred, e); - traced_dospy: + BOp(spy_pred, e); + dospy: { ///#ifdef PROFILED_ABSMI EMIT_ENTRY_BLOCK(PREG,SPY_PRED_INSTINIT); @@ -7136,8 +7163,8 @@ S_SREG = RepAppl(d0); BEGP(pt0); pt0 = pt1++; d1 = *pt0; - deref_head(d1, traced_dospy_unk); - traced_dospy_nonvar: + deref_head(d1, dospy_unk); + dospy_nonvar: /* just copy it to the heap */ ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(SPY_PRED_D0ISNOZERO_INSIDEFOR_DOSPY_NONVAR); @@ -7145,7 +7172,7 @@ S_SREG = RepAppl(d0); *HR++ = d1; continue; - derefa_body(d1, pt0, traced_dospy_unk, traced_dospy_nonvar); + derefa_body(d1, pt0, dospy_unk, dospy_nonvar); if (pt0 <= HR) { /* variable is safe */ ///#ifdef PROFILED_ABSMI @@ -7221,7 +7248,7 @@ S_SREG = RepAppl(d0); * Try / Retry / Trust for main indexing blocks * \************************************************************************/ - BOp(traced_try_clause, Otapl); + BOp(try_clause, Otapl); EMIT_ENTRY_BLOCK(PREG,TRY_CLAUSE_INSTINIT); check_trail(TR); CACHE_Y(YREG); @@ -7241,7 +7268,7 @@ S_SREG = RepAppl(d0); JMPNext(); ENDBOp(); - BOp(traced_try_clause2, l); + BOp(try_clause2, l); EMIT_ENTRY_BLOCK(PREG,TRY_CLAUSE2_INSTINIT); check_trail(TR); CACHE_Y(YREG); @@ -7267,7 +7294,7 @@ S_SREG = RepAppl(d0); JMPNext(); ENDBOp(); - BOp(traced_try_clause3, l); + BOp(try_clause3, l); EMIT_ENTRY_BLOCK(PREG,TRY_CLAUSE3_INSTINIT); check_trail(TR); CACHE_Y(YREG); @@ -7291,7 +7318,7 @@ S_SREG = RepAppl(d0); JMPNext(); ENDBOp(); - BOp(traced_try_clause4, l); + BOp(try_clause4, l); EMIT_ENTRY_BLOCK(PREG,TRY_CLAUSE4_INSTINIT); check_trail(TR); CACHE_Y(YREG); @@ -7316,7 +7343,7 @@ S_SREG = RepAppl(d0); JMPNext(); ENDBOp(); - BOp(traced_retry, Otapl); + BOp(retry, Otapl); EMIT_ENTRY_BLOCK(PREG,RETRY_INSTINIT); CACHE_Y(B); restore_yaam_regs(NEXTOP(PREG, Otapl)); @@ -7336,7 +7363,7 @@ S_SREG = RepAppl(d0); JMPNext(); ENDBOp(); - BOp(traced_retry2, l); + BOp(retry2, l); EMIT_ENTRY_BLOCK(PREG,RETRY2_INSTINIT); CACHE_Y(B); restore_yaam_regs(NEXTOP(PREG, l)); @@ -7357,7 +7384,7 @@ S_SREG = RepAppl(d0); JMPNext(); ENDBOp(); - BOp(traced_retry3, l); + BOp(retry3, l); EMIT_ENTRY_BLOCK(PREG,RETRY3_INSTINIT); CACHE_Y(B); restore_yaam_regs(NEXTOP(PREG, l)); @@ -7379,7 +7406,7 @@ S_SREG = RepAppl(d0); JMPNext(); ENDBOp(); - BOp(traced_retry4, l); + BOp(retry4, l); EMIT_ENTRY_BLOCK(PREG,RETRY4_INSTINIT); CACHE_Y(B); restore_yaam_regs(NEXTOP(PREG, l)); @@ -7402,7 +7429,7 @@ S_SREG = RepAppl(d0); JMPNext(); ENDBOp(); - BOp(traced_trust, Otapl); + BOp(trust, Otapl); EMIT_ENTRY_BLOCK(PREG,TRUST_INSTINIT); CACHE_Y(B); #ifdef YAPOR @@ -7436,7 +7463,7 @@ S_SREG = RepAppl(d0); JMPNext(); ENDBOp(); - BOp(traced_try_in, l); + BOp(try_in, l); EMIT_ENTRY_BLOCK(PREG,TRY_IN_INSTINIT); EMIT_MULTIPLE_DESTINY_BLOCK_TEST(TRY_IN_END); B->cp_ap = NEXTOP(PREG, l); @@ -7451,7 +7478,7 @@ S_SREG = RepAppl(d0); \************************************************************************/ /* enter logical pred */ - BOp(traced_enter_lu_pred, Illss); + BOp(enter_lu_pred, Illss); check_trail(TR); /* mark the indexing code */ { @@ -7487,7 +7514,7 @@ S_SREG = RepAppl(d0); JMPNext(); ENDBOp(); - BOp(traced_try_logical, OtaLl); + BOp(try_logical, OtaLl); check_trail(TR); { UInt timestamp; @@ -7519,7 +7546,7 @@ S_SREG = RepAppl(d0); JMPNext(); ENDBOp(); - BOp(traced_retry_logical, OtaLl); + BOp(retry_logical, OtaLl); check_trail(TR); { UInt timestamp; @@ -7556,7 +7583,7 @@ S_SREG = RepAppl(d0); JMPNext(); ENDBOp(); - BOp(traced_trust_logical, OtILl); + BOp(trust_logical, OtILl); CACHE_Y(B); { LogUpdIndex *cl = PREG->y_u.OtILl.block; @@ -7677,7 +7704,7 @@ S_SREG = RepAppl(d0); * Indexing in ARG1 * \************************************************************************/ - BOp(traced_user_switch, lp); + BOp(user_switch, lp); { EMIT_ENTRY_BLOCK(PREG,USER_SWITCH_INSTINIT); EMIT_MULTIPLE_DESTINY_BLOCK_TEST(USER_SWITCH_END); @@ -7691,14 +7718,14 @@ S_SREG = RepAppl(d0); } ENDBOp(); - BOp(traced_switch_on_type, llll); + BOp(switch_on_type, llll); EMIT_ENTRY_BLOCK(PREG,SWITCH_ON_TYPE_INSTINIT); EMIT_MULTIPLE_DESTINY_BLOCK_TEST(SWITCH_ON_TYPE_END); BEGD(d0); d0 = CACHED_A1(); - deref_head(d0, traced_swt_unk); + deref_head(d0, swt_unk); /* nonvar */ - traced_swt_nvar: + swt_nvar: if (IsPairTerm(d0)) { /* pair */ SREG = RepPair(d0); @@ -7723,8 +7750,8 @@ S_SREG = RepAppl(d0); BEGP(pt0); do { - if(!IsVarTerm(d0)) goto traced_swt_nvar; - traced_swt_unk: + if(!IsVarTerm(d0)) goto swt_nvar; + swt_unk: (pt0) = (CELL *)(d0); (d0) = *(CELL *)(d0); } while (Unsigned(pt0) != (d0)); @@ -7744,20 +7771,20 @@ S_SREG = RepAppl(d0); * a variable; * */ - BOp(traced_switch_list_nl, ollll); + BOp(switch_list_nl, ollll); EMIT_ENTRY_BLOCK(PREG,SWITCH_LIST_NL_INSTINIT); EMIT_MULTIPLE_DESTINY_BLOCK_TEST(SWITCH_LIST_NL_END); ALWAYS_LOOKAHEAD(PREG->y_u.ollll.pop); BEGD(d0); d0 = CACHED_A1(); #if UNIQUE_TAG_FOR_PAIRS - deref_list_head(d0, traced_swlnl_unk_p); - traced_swlnl_list_p: + deref_list_head(d0, swlnl_unk_p); + swlnl_list_p: { #else - deref_head(d0, traced_swlnl_unk_p); + deref_head(d0, swlnl_unk_p); /* non variable */ - traced_swlnl_nvar_p: + swlnl_nvar_p: if (__builtin_expect(IsPairTerm(d0),1)) { /* pair */ #endif @@ -7767,7 +7794,7 @@ S_SREG = RepAppl(d0); ALWAYS_GONext(); } #if UNIQUE_TAG_FOR_PAIRS - traced_swlnl_nlist_p: + swlnl_nlist_p: #endif if (d0 == TermNil) { /* empty list */ @@ -7791,10 +7818,10 @@ S_SREG = RepAppl(d0); BEGP(pt0); #if UNIQUE_TAG_FOR_PAIRS - traced_swlnl_unk_p: - deref_list_body(d0, pt0, traced_swlnl_list_p, traced_swlnl_nlist_p); + swlnl_unk_p: + deref_list_body(d0, pt0, swlnl_list_p, swlnl_nlist_p); #else - deref_body(d0, pt0, traced_swlnl_unk_p, traced_swlnl_nvar_p); + deref_body(d0, pt0, swlnl_unk_p, swlnl_nvar_p); #endif ENDP(pt0); /* variable */ @@ -7805,14 +7832,14 @@ S_SREG = RepAppl(d0); } ENDBOp(); - BOp(traced_switch_on_arg_type, xllll); + BOp(switch_on_arg_type, xllll); EMIT_ENTRY_BLOCK(PREG,SWITCH_ON_ARG_TYPE_INSTINIT); EMIT_MULTIPLE_DESTINY_BLOCK_TEST(SWITCH_ON_ARG_TYPE_END); BEGD(d0); d0 = XREG(PREG->y_u.xllll.x); - deref_head(d0, traced_arg_swt_unk); + deref_head(d0, arg_swt_unk); /* nonvar */ - traced_arg_swt_nvar: + arg_swt_nvar: if (IsPairTerm(d0)) { /* pair */ copy_jmp_address(PREG->y_u.xllll.l1); @@ -7836,7 +7863,7 @@ S_SREG = RepAppl(d0); } BEGP(pt0); - deref_body(d0, pt0, traced_arg_swt_unk, traced_arg_swt_nvar); + deref_body(d0, pt0, arg_swt_unk, arg_swt_nvar); /* variable */ copy_jmp_address(PREG->y_u.xllll.l4); PREG = PREG->y_u.xllll.l4; @@ -7845,14 +7872,14 @@ S_SREG = RepAppl(d0); ENDD(d0); ENDBOp(); - BOp(traced_switch_on_sub_arg_type, sllll); + BOp(switch_on_sub_arg_type, sllll); EMIT_ENTRY_BLOCK(PREG,SWITCH_ON_SUB_ARG_TYPE_INSTINIT); EMIT_MULTIPLE_DESTINY_BLOCK_TEST(SWITCH_ON_SUB_ARG_TYPE_END); BEGD(d0); d0 = SREG[PREG->y_u.sllll.s]; - deref_head(d0, traced_sub_arg_swt_unk); + deref_head(d0, sub_arg_swt_unk); /* nonvar */ - traced_sub_arg_swt_nvar: + sub_arg_swt_nvar: if (IsPairTerm(d0)) { /* pair */ copy_jmp_address(PREG->y_u.sllll.l1); @@ -7877,8 +7904,8 @@ S_SREG = RepAppl(d0); BEGP(pt0); do { - if(!IsVarTerm(d0)) goto traced_sub_arg_swt_nvar; - traced_sub_arg_swt_unk: + if(!IsVarTerm(d0)) goto sub_arg_swt_nvar; + sub_arg_swt_unk: (pt0) = (CELL *)(d0); (d0) = *(CELL *)(d0); } while (Unsigned(pt0) != (d0)); @@ -7891,19 +7918,19 @@ S_SREG = RepAppl(d0); ENDD(d0); ENDBOp(); - BOp(traced_jump_if_var, l); + BOp(jump_if_var, l); EMIT_ENTRY_BLOCK(PREG,JUMP_IF_VAR_INSTINIT); EMIT_MULTIPLE_DESTINY_BLOCK_TEST(JUMP_IF_VAR_END); BEGD(d0); d0 = CACHED_A1(); - deref_head(d0, traced_jump_if_unk); + deref_head(d0, jump_if_unk); /* non var */ - traced_jump0_if_nonvar: + jump0_if_nonvar: PREG = NEXTOP(PREG, l); JMPNext(); BEGP(pt0); - deref_body(d0, pt0, traced_jump_if_unk, traced_jump0_if_nonvar); + deref_body(d0, pt0, jump_if_unk, jump0_if_nonvar); /* variable */ copy_jmp_address(PREG->y_u.l.l); PREG = PREG->y_u.l.l; @@ -7912,22 +7939,22 @@ S_SREG = RepAppl(d0); ENDD(d0); ENDBOp(); - BOp(traced_jump_if_nonvar, xll); + BOp(jump_if_nonvar, xll); EMIT_ENTRY_BLOCK(PREG,JUMP_IF_NONVAR_INSTINIT); EMIT_MULTIPLE_DESTINY_BLOCK_TEST(JUMP_IF_NONVAR_END); BEGD(d0); d0 = XREG(PREG->y_u.xll.x); - deref_head(d0, traced_jump2_if_unk); + deref_head(d0, jump2_if_unk); /* non var */ - traced_jump2_if_nonvar: + jump2_if_nonvar: copy_jmp_address(PREG->y_u.xll.l1); PREG = PREG->y_u.xll.l1; JMPNext(); BEGP(pt0); do { - if(!IsVarTerm(d0)) goto traced_jump2_if_nonvar; - traced_jump2_if_unk: + if(!IsVarTerm(d0)) goto jump2_if_nonvar; + jump2_if_unk: (pt0) = (CELL *)(d0); (d0) = *(CELL *)(d0); } while (Unsigned(pt0) != (d0)); @@ -7939,13 +7966,13 @@ S_SREG = RepAppl(d0); ENDD(d0); ENDBOp(); - BOp(traced_if_not_then, clll); + BOp(if_not_then, clll); EMIT_ENTRY_BLOCK(PREG,IF_NOT_THEN_INSTINIT); EMIT_MULTIPLE_DESTINY_BLOCK_TEST(IF_NOT_THEN_END); BEGD(d0); d0 = CACHED_A1(); - deref_head(d0, traced_if_n_unk); - traced_if_n_nvar: + deref_head(d0, if_n_unk); + if_n_nvar: /* not variable */ if (d0 == PREG->y_u.clll.c) { /* equal to test value */ @@ -7963,8 +7990,8 @@ S_SREG = RepAppl(d0); BEGP(pt0); do { - if(!IsVarTerm(d0)) goto traced_if_n_nvar; - traced_if_n_unk: + if(!IsVarTerm(d0)) goto if_n_nvar; + if_n_unk: (pt0) = (CELL *)(d0); (d0) = *(CELL *)(d0); } while (Unsigned(pt0) != (d0)); @@ -7983,7 +8010,7 @@ S_SREG = RepAppl(d0); #define HRASH_SHIFT 6 - BOp(traced_switch_on_func, sssl); + BOp(switch_on_func, sssl); EMIT_ENTRY_BLOCK(PREG,SWITCH_ON_FUNC_INSTINIT); EMIT_MULTIPLE_DESTINY_BLOCK_TEST(SWITCH_ON_FUNC_END); BEGD(d1); @@ -8032,7 +8059,7 @@ S_SREG = RepAppl(d0); ENDD(d1); ENDBOp(); - BOp(traced_switch_on_cons, sssl); + BOp(switch_on_cons, sssl); EMIT_ENTRY_BLOCK(PREG,SWITCH_ON_CONS_INSTINIT); EMIT_MULTIPLE_DESTINY_BLOCK_TEST(SWITCH_ON_CONS_END); BEGD(d1); @@ -8081,7 +8108,7 @@ S_SREG = RepAppl(d0); ENDD(d1); ENDBOp(); - BOp(traced_go_on_func, sssl); + BOp(go_on_func, sssl); EMIT_ENTRY_BLOCK(PREG,GO_ON_FUNC_INSTINIT); EMIT_MULTIPLE_DESTINY_BLOCK_TEST(GO_ON_FUNC_END); BEGD(d0); @@ -8102,7 +8129,7 @@ S_SREG = RepAppl(d0); ENDD(d0); ENDBOp(); - BOp(traced_go_on_cons, sssl); + BOp(go_on_cons, sssl); EMIT_ENTRY_BLOCK(PREG,GO_ON_CONS_INSTINIT); EMIT_MULTIPLE_DESTINY_BLOCK_TEST(GO_ON_CONS_END); BEGD(d0); @@ -8123,7 +8150,7 @@ S_SREG = RepAppl(d0); ENDD(d0); ENDBOp(); - BOp(traced_if_func, sssl); + BOp(if_func, sssl); EMIT_ENTRY_BLOCK(PREG,IF_FUNC_INSTINIT); EMIT_MULTIPLE_DESTINY_BLOCK_TEST(IF_FUNC_END); BEGD(d1); @@ -8140,7 +8167,7 @@ S_SREG = RepAppl(d0); ENDD(d1); ENDBOp(); - BOp(traced_if_cons, sssl); + BOp(if_cons, sssl); EMIT_ENTRY_BLOCK(PREG,IF_CONS_INSTINIT); EMIT_MULTIPLE_DESTINY_BLOCK_TEST(IF_CONS_END); BEGD(d1); @@ -8157,7 +8184,7 @@ S_SREG = RepAppl(d0); ENDD(d1); ENDBOp(); - Op(traced_index_dbref, e); + Op(index_dbref, e); EMIT_ENTRY_BLOCK(PREG,INDEX_DBREF_INSTINIT); EMIT_MULTIPLE_DESTINY_BLOCK_TEST(INDEX_DBREF_END); PREG = NEXTOP(PREG, e); @@ -8165,7 +8192,7 @@ S_SREG = RepAppl(d0); GONext(); ENDOp(); - Op(traced_index_blob, e); + Op(index_blob, e); EMIT_ENTRY_BLOCK(PREG,INDEX_BLOB_INSTINIT); EMIT_MULTIPLE_DESTINY_BLOCK_TEST(INDEX_BLOB_END); PREG = NEXTOP(PREG, e); @@ -8173,7 +8200,7 @@ S_SREG = RepAppl(d0); GONext(); ENDOp(); - Op(traced_index_long, e); + Op(index_long, e); EMIT_ENTRY_BLOCK(PREG,INDEX_LONG_INSTINIT); EMIT_MULTIPLE_DESTINY_BLOCK_TEST(INDEX_LONG_END); PREG = NEXTOP(PREG, e); @@ -8188,7 +8215,7 @@ S_SREG = RepAppl(d0); \************************************************************************/ /* native_me */ - BOp(traced_jit_handler, J); + BOp(jit_handler, J); /* Needs to recompile */ if (PREG->y_u.J.jh->jitman.torecomp) { @@ -8405,12 +8432,12 @@ S_SREG = RepAppl(d0); * Basic Primitive Predicates * \************************************************************************/ - Op(traced_p_atom_x, xl); + Op(p_atom_x, xl); EMIT_ENTRY_BLOCK(PREG,P_ATOM_X_INSTINIT); BEGD(d0); d0 = XREG(PREG->y_u.xl.x); - profiled_deref_head_TEST(d0, traced_atom_x_unk); - traced_atom_x_nvar: + profiled_deref_head_TEST(d0, atom_x_unk); + atom_x_nvar: if (IsAtomTerm(d0) && !IsBlob(AtomOfTerm(d0))) { EMIT_SIMPLE_BLOCK_TEST(P_ATOM_X_ATOM); PREG = NEXTOP(PREG, xl); @@ -8423,7 +8450,7 @@ S_SREG = RepAppl(d0); } BEGP(pt0); - profiled_deref_body(d0, pt0, traced_atom_x_unk, traced_atom_x_nvar); + profiled_deref_body(d0, pt0, atom_x_unk, atom_x_nvar); EMIT_SIMPLE_BLOCK_TEST(P_ATOM_X_NOATOM); PREG = PREG->y_u.xl.F; GONext(); @@ -8431,7 +8458,7 @@ S_SREG = RepAppl(d0); ENDD(d0); ENDOp(); - Op(traced_p_atom_y, yl); + Op(p_atom_y, yl); ///#ifdef PROFILED_ABSMI EMIT_ENTRY_BLOCK(PREG,P_ATOM_Y_INSTINIT); ///#endif @@ -8439,8 +8466,8 @@ S_SREG = RepAppl(d0); BEGP(pt0); pt0 = YREG + PREG->y_u.yl.y; d0 = *pt0; - deref_head(d0, traced_atom_y_unk); - traced_atom_y_nvar: + deref_head(d0, atom_y_unk); + atom_y_nvar: if (IsAtomTerm(d0) && !IsBlob(AtomOfTerm(d0))) { ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(P_ATOM_Y_IFOK); @@ -8456,7 +8483,7 @@ S_SREG = RepAppl(d0); GONext(); } - derefa_body(d0, pt0, traced_atom_y_unk, traced_atom_y_nvar); + derefa_body(d0, pt0, atom_y_unk, atom_y_nvar); ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(P_ATOM_Y_END); //#endif @@ -8466,14 +8493,14 @@ S_SREG = RepAppl(d0); ENDD(d0); ENDOp(); - Op(traced_p_atomic_x, xl); + Op(p_atomic_x, xl); ///#ifdef PROFILED_ABSMI EMIT_ENTRY_BLOCK(PREG,P_ATOMIC_X_INSTINIT); ///#endif BEGD(d0); d0 = XREG(PREG->y_u.xl.x); - deref_head(d0, traced_atomic_x_unk); - traced_atomic_x_nvar: + deref_head(d0, atomic_x_unk); + atomic_x_nvar: /* non variable */ if (IsAtomicTerm(d0)) { ///#ifdef PROFILED_ABSMI @@ -8491,7 +8518,7 @@ S_SREG = RepAppl(d0); } BEGP(pt0); - deref_body(d0, pt0, traced_atomic_x_unk, traced_atomic_x_nvar); + deref_body(d0, pt0, atomic_x_unk, atomic_x_nvar); ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(P_ATOMIC_X_END); //#endif @@ -8501,7 +8528,7 @@ S_SREG = RepAppl(d0); ENDD(d0); ENDOp(); - Op(traced_p_atomic_y, yl); + Op(p_atomic_y, yl); ///#ifdef PROFILED_ABSMI EMIT_ENTRY_BLOCK(PREG,P_ATOMIC_Y_INSTINIT); ///#endif @@ -8509,8 +8536,8 @@ S_SREG = RepAppl(d0); BEGP(pt0); pt0 = YREG + PREG->y_u.yl.y; d0 = *pt0; - deref_head(d0, traced_atomic_y_unk); - traced_atomic_y_nvar: + deref_head(d0, atomic_y_unk); + atomic_y_nvar: /* non variable */ if (IsAtomicTerm(d0)) { ///#ifdef PROFILED_ABSMI @@ -8527,7 +8554,7 @@ S_SREG = RepAppl(d0); GONext(); } - derefa_body(d0, pt0, traced_atomic_y_unk, traced_atomic_y_nvar); + derefa_body(d0, pt0, atomic_y_unk, atomic_y_nvar); ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(P_ATOMIC_Y_END); ///#endif @@ -8537,12 +8564,12 @@ S_SREG = RepAppl(d0); ENDD(d0); ENDOp(); - Op(traced_p_integer_x, xl); + Op(p_integer_x, xl); EMIT_ENTRY_BLOCK(PREG,P_INTEGER_X_INSTINIT); BEGD(d0); d0 = XREG(PREG->y_u.xl.x); - profiled_deref_head_TEST(d0, traced_integer_x_unk); - traced_integer_x_nvar: + profiled_deref_head_TEST(d0, integer_x_unk); + integer_x_nvar: /* non variable */ if (IsIntTerm(d0)) { EMIT_CONDITIONAL_SUCCESS("IsIntTerm(d0)"); @@ -8581,7 +8608,7 @@ S_SREG = RepAppl(d0); GONext(); BEGP(pt0); - profiled_deref_body(d0, pt0, traced_integer_x_unk, traced_integer_x_nvar); + profiled_deref_body(d0, pt0, integer_x_unk, integer_x_nvar); EMIT_SIMPLE_BLOCK_TEST(P_INTEGER_X_INTEGER_X_UNK); PREG = PREG->y_u.xl.F; GONext(); @@ -8589,14 +8616,14 @@ S_SREG = RepAppl(d0); ENDD(d0); ENDOp(); - Op(traced_p_integer_y, yl); + Op(p_integer_y, yl); EMIT_ENTRY_BLOCK(PREG,P_INTEGER_Y_INSTINIT); BEGD(d0); BEGP(pt0); pt0 = YREG + PREG->y_u.yl.y; d0 = *pt0; - profiled_deref_head_TEST(d0, traced_integer_y_unk); - traced_integer_y_nvar: + profiled_deref_head_TEST(d0, integer_y_unk); + integer_y_nvar: /* non variable */ if (IsIntTerm(d0)) { EMIT_CONDITIONAL_SUCCESS("IsIntTerm(d0)"); @@ -8636,7 +8663,7 @@ S_SREG = RepAppl(d0); PREG = PREG->y_u.yl.F; GONext(); - profiled_derefa_body(d0, pt0, traced_integer_y_unk, traced_integer_y_nvar); + profiled_derefa_body(d0, pt0, integer_y_unk, integer_y_nvar); EMIT_SIMPLE_BLOCK(P_INTEGER_Y_INTEGER_Y_UNK); PREG = PREG->y_u.yl.F; GONext(); @@ -8644,18 +8671,18 @@ S_SREG = RepAppl(d0); ENDD(d0); ENDOp(); - Op(traced_p_nonvar_x, xl); + Op(p_nonvar_x, xl); EMIT_ENTRY_BLOCK(PREG,P_NONVAR_X_INSTINIT); BEGD(d0); d0 = XREG(PREG->y_u.xl.x); - profiled_deref_head_TEST(d0, traced_nonvar_x_unk); - traced_nonvar_x_nvar: + profiled_deref_head_TEST(d0, nonvar_x_unk); + nonvar_x_nvar: EMIT_SIMPLE_BLOCK_TEST(P_NONVAR_X_NONVAR); PREG = NEXTOP(PREG, xl); GONext(); BEGP(pt0); - profiled_deref_body(d0, pt0, traced_nonvar_x_unk, traced_nonvar_x_nvar); + profiled_deref_body(d0, pt0, nonvar_x_unk, nonvar_x_nvar); EMIT_MULTIPLE_DESTINY_BLOCK_TEST(P_NONVAR_X_NONONVAR); PREG = PREG->y_u.xl.F; GONext(); @@ -8663,19 +8690,19 @@ S_SREG = RepAppl(d0); ENDD(d0); ENDOp(); - Op(traced_p_nonvar_y, yl); + Op(p_nonvar_y, yl); EMIT_ENTRY_BLOCK(PREG,P_NONVAR_Y_INSTINIT); BEGD(d0); BEGP(pt0); pt0 = YREG + PREG->y_u.yl.y; d0 = *pt0; - profiled_deref_head_TEST(d0, traced_nonvar_y_unk); - traced_nonvar_y_nvar: + profiled_deref_head_TEST(d0, nonvar_y_unk); + nonvar_y_nvar: EMIT_SIMPLE_BLOCK_TEST(P_NONVAR_Y_NONVAR); PREG = NEXTOP(PREG, yl); GONext(); - profiled_derefa_body(d0, pt0, traced_nonvar_y_unk, traced_nonvar_y_nvar); + profiled_derefa_body(d0, pt0, nonvar_y_unk, nonvar_y_nvar); EMIT_MULTIPLE_DESTINY_BLOCK_TEST(P_NONVAR_Y_NONONVAR); PREG = PREG->y_u.yl.F; GONext(); @@ -8683,14 +8710,14 @@ S_SREG = RepAppl(d0); ENDD(d0); ENDOp(); - Op(traced_p_number_x, xl); + Op(p_number_x, xl); ///#ifdef PROFILED_ABSMI EMIT_ENTRY_BLOCK(PREG,P_NUMBER_X_INSTINIT); ///#endif BEGD(d0); d0 = XREG(PREG->y_u.xl.x); - deref_head(d0, traced_number_x_unk); - traced_number_x_nvar: + deref_head(d0, number_x_unk); + number_x_nvar: /* non variable */ if (IsIntTerm(d0)) { @@ -8730,7 +8757,7 @@ S_SREG = RepAppl(d0); GONext(); BEGP(pt0); - deref_body(d0, pt0, traced_number_x_unk, traced_number_x_nvar); + deref_body(d0, pt0, number_x_unk, number_x_nvar); ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(P_NUMBER_X_NUMBER_X_UNK); ///#endif @@ -8740,7 +8767,7 @@ S_SREG = RepAppl(d0); ENDD(d0); ENDOp(); - Op(traced_p_number_y, yl); + Op(p_number_y, yl); ///#ifdef PROFILED_ABSMI EMIT_ENTRY_BLOCK(PREG,P_NUMBER_Y_INSTINIT); ///#endif @@ -8748,8 +8775,8 @@ S_SREG = RepAppl(d0); BEGP(pt0); pt0 = YREG + PREG->y_u.yl.y; d0 = *pt0; - deref_head(d0, traced_number_y_unk); - traced_number_y_nvar: + deref_head(d0, number_y_unk); + number_y_nvar: /* non variable */ /* non variable */ if (IsIntTerm(d0)) { @@ -8788,7 +8815,7 @@ S_SREG = RepAppl(d0); PREG = PREG->y_u.xl.F; GONext(); - derefa_body(d0, pt0, traced_number_y_unk, traced_number_y_nvar); + derefa_body(d0, pt0, number_y_unk, number_y_nvar); ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(P_NUMBER_Y_NUMBER_Y_UNK); ///#endif @@ -8798,19 +8825,19 @@ S_SREG = RepAppl(d0); ENDD(d0); ENDOp(); - Op(traced_p_var_x, xl); + Op(p_var_x, xl); EMIT_ENTRY_BLOCK(PREG,P_VAR_X_INSTINIT); BEGD(d0); d0 = XREG(PREG->y_u.xl.x); - profiled_deref_head_TEST(d0, traced_var_x_unk); - traced_var_x_nvar: + profiled_deref_head_TEST(d0, var_x_unk); + var_x_nvar: /* non variable */ EMIT_MULTIPLE_DESTINY_BLOCK_TEST(P_VAR_X_NONVAR); PREG = PREG->y_u.xl.F; GONext(); BEGP(pt0); - profiled_deref_body(d0, pt0, traced_var_x_unk, traced_var_x_nvar); + profiled_deref_body(d0, pt0, var_x_unk, var_x_nvar); EMIT_SIMPLE_BLOCK_TEST(P_VAR_X_VAR); PREG = NEXTOP(PREG, xl); GONext(); @@ -8818,20 +8845,20 @@ S_SREG = RepAppl(d0); ENDD(d0); ENDOp(); - Op(traced_p_var_y, yl); + Op(p_var_y, yl); EMIT_ENTRY_BLOCK(PREG,P_VAR_Y_INSTINIT); BEGD(d0); BEGP(pt0); pt0 = YREG + PREG->y_u.yl.y; d0 = *pt0; - profiled_deref_head_TEST(d0, traced_var_y_unk); - traced_var_y_nvar: + profiled_deref_head_TEST(d0, var_y_unk); + var_y_nvar: /* non variable */ EMIT_MULTIPLE_DESTINY_BLOCK_TEST(P_VAR_Y_NONVAR); PREG = PREG->y_u.yl.F; GONext(); - profiled_derefa_body(d0, pt0, traced_var_y_unk, traced_var_y_nvar); + profiled_derefa_body(d0, pt0, var_y_unk, var_y_nvar); EMIT_SIMPLE_BLOCK_TEST(P_VAR_Y_VAR); PREG = NEXTOP(PREG, yl); GONext(); @@ -8839,14 +8866,14 @@ S_SREG = RepAppl(d0); ENDD(d0); ENDOp(); - Op(traced_p_db_ref_x, xl); + Op(p_db_ref_x, xl); ///#ifdef PROFILED_ABSMI EMIT_ENTRY_BLOCK(PREG,P_DB_REF_X_INSTINIT); ///#endif BEGD(d0); d0 = XREG(PREG->y_u.xl.x); - deref_head(d0, traced_dbref_x_unk); - traced_dbref_x_nvar: + deref_head(d0, dbref_x_unk); + dbref_x_nvar: /* non variable */ if (IsDBRefTerm(d0)) { /* only allow references to the database, not general references @@ -8866,7 +8893,7 @@ S_SREG = RepAppl(d0); } BEGP(pt0); - deref_body(d0, pt0, traced_dbref_x_unk, traced_dbref_x_nvar); + deref_body(d0, pt0, dbref_x_unk, dbref_x_nvar); ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(P_DB_REF_X_DBREF_X_UNK); ///#endif @@ -8876,7 +8903,7 @@ S_SREG = RepAppl(d0); ENDD(d0); ENDOp(); - Op(traced_p_db_ref_y, yl); + Op(p_db_ref_y, yl); ///#ifdef PROFILED_ABSMI EMIT_ENTRY_BLOCK(PREG,P_DB_REF_Y_INSTINIT); ///#endif @@ -8884,8 +8911,8 @@ S_SREG = RepAppl(d0); BEGP(pt0); pt0 = YREG + PREG->y_u.yl.y; d0 = *pt0; - deref_head(d0, traced_dbref_y_unk); - traced_dbref_y_nvar: + deref_head(d0, dbref_y_unk); + dbref_y_nvar: /* non variable */ if (IsDBRefTerm(d0)) { /* only allow references to the database, not general references @@ -8904,7 +8931,7 @@ S_SREG = RepAppl(d0); GONext(); } - derefa_body(d0, pt0, traced_dbref_y_unk, traced_dbref_y_nvar); + derefa_body(d0, pt0, dbref_y_unk, dbref_y_nvar); ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(P_DB_REF_Y_DBREF_Y_UNK); ///#endif @@ -8914,14 +8941,14 @@ S_SREG = RepAppl(d0); ENDD(d0); ENDOp(); - Op(traced_p_primitive_x, xl); + Op(p_primitive_x, xl); ///#ifdef PROFILED_ABSMI EMIT_ENTRY_BLOCK(PREG,P_PRIMITIVE_X_INSTINIT); ///#endif BEGD(d0); d0 = XREG(PREG->y_u.xl.x); - deref_head(d0, traced_primi_x_unk); - traced_primi_x_nvar: + deref_head(d0, primi_x_unk); + primi_x_nvar: /* non variable */ if (IsPrimitiveTerm(d0)) { ///#ifdef PROFILED_ABSMI @@ -8939,7 +8966,7 @@ S_SREG = RepAppl(d0); } BEGP(pt0); - deref_body(d0, pt0, traced_primi_x_unk, traced_primi_x_nvar); + deref_body(d0, pt0, primi_x_unk, primi_x_nvar); ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(P_PRIMITIVE_X_PRIMI_X_UNK); ///#endif @@ -8949,7 +8976,7 @@ S_SREG = RepAppl(d0); ENDD(d0); ENDOp(); - Op(traced_p_primitive_y, yl); + Op(p_primitive_y, yl); ///#ifdef PROFILED_ABSMI EMIT_ENTRY_BLOCK(PREG,P_PRIMITIVE_Y_INSTINIT); ///#endif @@ -8957,8 +8984,8 @@ S_SREG = RepAppl(d0); BEGP(pt0); pt0 = YREG + PREG->y_u.yl.y; d0 = *pt0; - deref_head(d0, traced_primi_y_unk); - traced_primi_y_nvar: + deref_head(d0, primi_y_unk); + primi_y_nvar: /* non variable */ if (IsPrimitiveTerm(d0)) { ///#ifdef PROFILED_ABSMI @@ -8975,7 +9002,7 @@ S_SREG = RepAppl(d0); GONext(); } - derefa_body(d0, pt0, traced_primi_y_unk, traced_primi_y_nvar); + derefa_body(d0, pt0, primi_y_unk, primi_y_nvar); ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(P_PRIMITIVE_Y_PRIMI_Y_UNK); ///#endif @@ -8985,14 +9012,14 @@ S_SREG = RepAppl(d0); ENDD(d0); ENDOp(); - Op(traced_p_compound_x, xl); + Op(p_compound_x, xl); ///#ifdef PROFILED_ABSMI EMIT_ENTRY_BLOCK(PREG,P_COMPOUND_X_INSTINIT); ///#endif BEGD(d0); d0 = XREG(PREG->y_u.xl.x); - deref_head(d0, traced_compound_x_unk); - traced_compound_x_nvar: + deref_head(d0, compound_x_unk); + compound_x_nvar: /* non variable */ if (IsPairTerm(d0)) { ///#ifdef PROFILED_ABSMI @@ -9024,7 +9051,7 @@ S_SREG = RepAppl(d0); } BEGP(pt0); - deref_body(d0, pt0, traced_compound_x_unk, traced_compound_x_nvar); + deref_body(d0, pt0, compound_x_unk, compound_x_nvar); ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(P_COMPOUND_X_COMPOUND_X_UNK); ///#endif @@ -9034,7 +9061,7 @@ S_SREG = RepAppl(d0); ENDD(d0); ENDOp(); - Op(traced_p_compound_y, yl); + Op(p_compound_y, yl); ///#ifdef PROFILED_ABSMI EMIT_ENTRY_BLOCK(PREG,P_COMPOUND_Y_INSTINIT); ///#endif @@ -9042,8 +9069,8 @@ S_SREG = RepAppl(d0); BEGP(pt0); pt0 = YREG + PREG->y_u.yl.y; d0 = *pt0; - deref_head(d0, traced_compound_y_unk); - traced_compound_y_nvar: + deref_head(d0, compound_y_unk); + compound_y_nvar: /* non variable */ if (IsPairTerm(d0)) { ///#ifdef PROFILED_ABSMI @@ -9074,7 +9101,7 @@ S_SREG = RepAppl(d0); GONext(); } - derefa_body(d0, pt0, traced_compound_y_unk, traced_compound_y_nvar); + derefa_body(d0, pt0, compound_y_unk, compound_y_nvar); ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(P_COMPOUND_Y_COMPOUND_Y_UNK); ///#endif @@ -9084,14 +9111,14 @@ S_SREG = RepAppl(d0); ENDD(d0); ENDOp(); - Op(traced_p_float_x, xl); + Op(p_float_x, xl); ///#ifdef PROFILED_ABSMI EMIT_ENTRY_BLOCK(PREG,P_FLOAT_X_INSTINIT); ///#endif BEGD(d0); d0 = XREG(PREG->y_u.xl.x); - deref_head(d0, traced_float_x_unk); - traced_float_x_nvar: + deref_head(d0, float_x_unk); + float_x_nvar: /* non variable */ if (IsFloatTerm(d0)) { ///#ifdef PROFILED_ABSMI @@ -9107,7 +9134,7 @@ S_SREG = RepAppl(d0); GONext(); BEGP(pt0); - deref_body(d0, pt0, traced_float_x_unk, traced_float_x_nvar); + deref_body(d0, pt0, float_x_unk, float_x_nvar); ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(P_FLOAT_X_FLOAT_X_UNK); ///#endif @@ -9117,7 +9144,7 @@ S_SREG = RepAppl(d0); ENDD(d0); ENDOp(); - Op(traced_p_float_y, yl); + Op(p_float_y, yl); ///#ifdef PROFILED_ABSMI EMIT_ENTRY_BLOCK(PREG,P_FLOAT_Y_INSTINIT); ///#endif @@ -9125,8 +9152,8 @@ S_SREG = RepAppl(d0); BEGP(pt0); pt0 = YREG + PREG->y_u.yl.y; d0 = *pt0; - deref_head(d0, traced_float_y_unk); - traced_float_y_nvar: + deref_head(d0, float_y_unk); + float_y_nvar: /* non variable */ if (IsFloatTerm(d0)) { ///#ifdef PROFILED_ABSMI @@ -9141,7 +9168,7 @@ S_SREG = RepAppl(d0); PREG = PREG->y_u.yl.F; GONext(); - derefa_body(d0, pt0, traced_float_y_unk, traced_float_y_nvar); + derefa_body(d0, pt0, float_y_unk, float_y_nvar); ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(P_FLOAT_Y_FLOAT_Y_UNK); ///#endif @@ -9151,19 +9178,19 @@ S_SREG = RepAppl(d0); ENDD(d0); ENDOp(); - Op(traced_p_plus_vv, xxx); + Op(p_plus_vv, xxx); EMIT_ENTRY_BLOCK(PREG,P_PLUS_VV_INSTINIT); BEGD(d0); BEGD(d1); d0 = XREG(PREG->y_u.xxx.x1); /* first check pt1 */ - profiled_deref_head_TEST(d0, traced_plus_vv_unk); - traced_plus_vv_nvar: + profiled_deref_head_TEST(d0, plus_vv_unk); + plus_vv_nvar: EMIT_SIMPLE_BLOCK_TEST(P_PLUS_VV_PLUS_VV_NVAR); d1 = XREG(PREG->y_u.xxx.x2); /* next check A2 */ - profiled_deref_head_TEST(d1, traced_plus_vv_nvar_unk); - traced_plus_vv_nvar_nvar: + profiled_deref_head_TEST(d1, plus_vv_nvar_unk); + plus_vv_nvar_nvar: /* d0 and d1 are where I want them */ if (IsIntTerm(d0) && IsIntTerm(d1)) { EMIT_CONDITIONAL_SUCCESS("IsIntTerm(d0) && IsIntTerm(d1)"); @@ -9180,7 +9207,7 @@ S_SREG = RepAppl(d0); saveregs(); Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); setregs(); - TRACED_FAIL(); + FAIL(); } } XREG(PREG->y_u.xxx.x) = d0; @@ -9188,33 +9215,33 @@ S_SREG = RepAppl(d0); GONext(); BEGP(pt0); - profiled_deref_body(d0, pt0, traced_plus_vv_unk, traced_plus_vv_nvar); + profiled_deref_body(d0, pt0, plus_vv_unk, plus_vv_nvar); EMIT_SIMPLE_BLOCK_TEST(P_PLUS_VV_PLUS_VV_UNK); saveregs(); Yap_NilError(INSTANTIATION_ERROR, "X is _+B"); setregs(); - TRACED_FAIL(); + FAIL(); ENDP(pt0); BEGP(pt0); - profiled_deref_body(d1, pt0, traced_plus_vv_nvar_unk, traced_plus_vv_nvar_nvar); + profiled_deref_body(d1, pt0, plus_vv_nvar_unk, plus_vv_nvar_nvar); EMIT_SIMPLE_BLOCK_TEST(P_PLUS_VV_PLUS_VV_NVAR_UNK); saveregs(); Yap_NilError(INSTANTIATION_ERROR, "X is A+B"); setregs(); - TRACED_FAIL(); + FAIL(); ENDP(pt0); ENDD(d1); ENDD(d0); ENDOp(); - Op(traced_p_plus_vc, xxn); + Op(p_plus_vc, xxn); EMIT_ENTRY_BLOCK(PREG,P_PLUS_VC_INSTINIT); BEGD(d0); d0 = XREG(PREG->y_u.xxn.xi); /* first check pt1 */ - profiled_deref_head_TEST(d0, traced_plus_vc_unk); - traced_plus_vc_nvar: + profiled_deref_head_TEST(d0, plus_vc_unk); + plus_vc_nvar: { Int d1 = PREG->y_u.xxn.c; if (IsIntTerm(d0)) { @@ -9232,7 +9259,7 @@ S_SREG = RepAppl(d0); saveregs(); Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); setregs(); - TRACED_FAIL(); + FAIL(); } } } @@ -9241,29 +9268,29 @@ S_SREG = RepAppl(d0); GONext(); BEGP(pt0); - profiled_deref_body(d0, pt0, traced_plus_vc_unk, traced_plus_vc_nvar); + profiled_deref_body(d0, pt0, plus_vc_unk, plus_vc_nvar); EMIT_SIMPLE_BLOCK_TEST(P_PLUS_VC_PLUS_VC_UNK); saveregs(); Yap_NilError(INSTANTIATION_ERROR, "X is A + " Int_FORMAT, PREG->y_u.xxn.c); setregs(); - TRACED_FAIL(); + FAIL(); ENDP(pt0); ENDD(d0); ENDOp(); - Op(traced_p_plus_y_vv, yxx); + Op(p_plus_y_vv, yxx); EMIT_ENTRY_BLOCK(PREG,P_PLUS_Y_VV_INSTINIT); BEGD(d0); BEGD(d1); d0 = XREG(PREG->y_u.yxx.x1); /* first check pt1 */ - profiled_deref_head_TEST(d0, traced_plus_y_vv_unk); - traced_plus_y_vv_nvar: + profiled_deref_head_TEST(d0, plus_y_vv_unk); + plus_y_vv_nvar: EMIT_SIMPLE_BLOCK_TEST(P_PLUS_Y_VV_PLUS_Y_VV_NVAR); d1 = XREG(PREG->y_u.xxx.x2); /* next check A2 */ - profiled_deref_head_TEST(d1, traced_plus_y_vv_nvar_unk); - traced_plus_y_vv_nvar_nvar: + profiled_deref_head_TEST(d1, plus_y_vv_nvar_unk); + plus_y_vv_nvar_nvar: /* d0 and d1 are where I want them */ if (IsIntTerm(d0) && IsIntTerm(d1)) { EMIT_CONDITIONAL_SUCCESS("IsIntTerm(d0) && IsIntTerm(d1)"); @@ -9280,7 +9307,7 @@ S_SREG = RepAppl(d0); saveregs(); Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); setregs(); - TRACED_FAIL(); + FAIL(); } } BEGP(pt0); @@ -9291,34 +9318,34 @@ S_SREG = RepAppl(d0); GONext(); BEGP(pt0); - profiled_deref_body(d0, pt0, traced_plus_y_vv_unk, traced_plus_y_vv_nvar); + profiled_deref_body(d0, pt0, plus_y_vv_unk, plus_y_vv_nvar); EMIT_SIMPLE_BLOCK_TEST(P_PLUS_Y_VV_PLUS_Y_VV_UNK); saveregs(); Yap_NilError(INSTANTIATION_ERROR, "X is A+B"); setregs(); - TRACED_FAIL(); + FAIL(); ENDP(pt0); BEGP(pt0); - profiled_deref_body(d1, pt0, traced_plus_y_vv_nvar_unk, traced_plus_y_vv_nvar_nvar); + profiled_deref_body(d1, pt0, plus_y_vv_nvar_unk, plus_y_vv_nvar_nvar); EMIT_SIMPLE_BLOCK_TEST(P_PLUS_Y_VV_PLUS_Y_VV_NVAR_UNK); saveregs(); Yap_NilError(INSTANTIATION_ERROR, "X is A+B"); setregs(); - TRACED_FAIL(); + FAIL(); ENDP(pt0); ENDD(d1); ENDD(d0); ENDOp(); - Op(traced_p_plus_y_vc, yxn); + Op(p_plus_y_vc, yxn); BEGD(d0); d0 = XREG(PREG->y_u.yxn.xi); EMIT_ENTRY_BLOCK(PREG,P_PLUS_Y_VC_INSTINIT); /* first check pt1 */ - profiled_deref_head_TEST(d0, traced_plus_y_vc_unk); + profiled_deref_head_TEST(d0, plus_y_vc_unk); - traced_plus_y_vc_nvar: + plus_y_vc_nvar: { Int d1 = PREG->y_u.yxn.c; if (IsIntTerm(d0)) { @@ -9336,7 +9363,7 @@ S_SREG = RepAppl(d0); saveregs(); Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); setregs(); - TRACED_FAIL(); + FAIL(); } } } @@ -9348,29 +9375,29 @@ S_SREG = RepAppl(d0); GONext(); BEGP(pt0); - profiled_deref_body(d0, pt0, traced_plus_y_vc_unk, traced_plus_y_vc_nvar); + profiled_deref_body(d0, pt0, plus_y_vc_unk, plus_y_vc_nvar); EMIT_SIMPLE_BLOCK_TEST(P_PLUS_Y_VC_PLUS_Y_VC_UNK); saveregs(); Yap_NilError(INSTANTIATION_ERROR, "X is A + " Int_FORMAT, PREG->y_u.yxn.c); setregs(); - TRACED_FAIL(); + FAIL(); ENDP(pt0); ENDD(d0); ENDOp(); - Op(traced_p_minus_vv, xxx); + Op(p_minus_vv, xxx); EMIT_ENTRY_BLOCK(PREG,P_MINUS_VV_INSTINIT); BEGD(d0); BEGD(d1); d0 = XREG(PREG->y_u.xxx.x1); /* first check pt1 */ - profiled_deref_head_TEST(d0, traced_minus_vv_unk); - traced_minus_vv_nvar: + profiled_deref_head_TEST(d0, minus_vv_unk); + minus_vv_nvar: EMIT_SIMPLE_BLOCK_TEST(P_MINUS_VV_MINUS_VV_NVAR); d1 = XREG(PREG->y_u.xxx.x2); /* next check A2 */ - profiled_deref_head_TEST(d1, traced_minus_vv_nvar_unk); - traced_minus_vv_nvar_nvar: + profiled_deref_head_TEST(d1, minus_vv_nvar_unk); + minus_vv_nvar_nvar: /* d0 and d1 are where I want them */ if (IsIntTerm(d0) && IsIntTerm(d1)) { EMIT_CONDITIONAL_SUCCESS("IsIntTerm(d0) && IsIntTerm(d1)"); @@ -9387,7 +9414,7 @@ S_SREG = RepAppl(d0); saveregs(); Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); setregs(); - TRACED_FAIL(); + FAIL(); } } XREG(PREG->y_u.xxx.x) = d0; @@ -9395,33 +9422,33 @@ S_SREG = RepAppl(d0); GONext(); BEGP(pt0); - profiled_deref_body(d0, pt0, traced_minus_vv_unk, traced_minus_vv_nvar); + profiled_deref_body(d0, pt0, minus_vv_unk, minus_vv_nvar); EMIT_SIMPLE_BLOCK_TEST(P_MINUS_VV_MINUS_VV_UNK); saveregs(); Yap_NilError(INSTANTIATION_ERROR, "X is A-B"); setregs(); - TRACED_FAIL(); + FAIL(); ENDP(pt0); BEGP(pt0); - profiled_deref_body(d1, pt0, traced_minus_vv_nvar_unk, traced_minus_vv_nvar_nvar); + profiled_deref_body(d1, pt0, minus_vv_nvar_unk, minus_vv_nvar_nvar); EMIT_SIMPLE_BLOCK_TEST(P_MINUS_VV_MINUS_VV_NVAR_UNK); saveregs(); Yap_NilError(INSTANTIATION_ERROR, "X is A-B"); setregs(); - TRACED_FAIL(); + FAIL(); ENDP(pt0); ENDD(d1); ENDD(d0); ENDOp(); - Op(traced_p_minus_cv, xxn); + Op(p_minus_cv, xxn); EMIT_ENTRY_BLOCK(PREG,P_MINUS_CV_INSTINIT); BEGD(d0); d0 = XREG(PREG->y_u.xxn.xi); /* first check pt1 */ - profiled_deref_head_TEST(d0, traced_minus_cv_unk); - traced_minus_cv_nvar: + profiled_deref_head_TEST(d0, minus_cv_unk); + minus_cv_nvar: { Int d1 = PREG->y_u.xxn.c; if (IsIntTerm(d0)) { @@ -9437,7 +9464,7 @@ S_SREG = RepAppl(d0); saveregs(); Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); setregs(); - TRACED_FAIL(); + FAIL(); } } } @@ -9446,17 +9473,17 @@ S_SREG = RepAppl(d0); GONext(); BEGP(pt0); - profiled_deref_body(d0, pt0, traced_minus_cv_unk, traced_minus_cv_nvar); + profiled_deref_body(d0, pt0, minus_cv_unk, minus_cv_nvar); EMIT_SIMPLE_BLOCK_TEST(P_MINUS_CV_MINUS_CV_UNK); saveregs(); Yap_NilError(INSTANTIATION_ERROR, "X is " Int_FORMAT "-A", PREG->y_u.xxn.c); setregs(); - TRACED_FAIL(); + FAIL(); ENDP(pt0); ENDD(d0); ENDOp(); - Op(traced_p_minus_y_vv, yxx); + Op(p_minus_y_vv, yxx); ///#ifdef PROFILED_ABSMI EMIT_ENTRY_BLOCK(PREG,P_MINUS_Y_VV_INSTINIT); ///#endif @@ -9464,15 +9491,15 @@ S_SREG = RepAppl(d0); BEGD(d1); d0 = XREG(PREG->y_u.yxx.x1); /* first check pt1 */ - deref_head(d0, traced_minus_y_vv_unk); - traced_minus_y_vv_nvar: + deref_head(d0, minus_y_vv_unk); + minus_y_vv_nvar: ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(P_MINUS_Y_VV_MINUS_Y_VV_NVAR); ///#endif d1 = XREG(PREG->y_u.xxx.x2); /* next check A2 */ - deref_head(d1, traced_minus_y_vv_nvar_unk); - traced_minus_y_vv_nvar_nvar: + deref_head(d1, minus_y_vv_nvar_unk); + minus_y_vv_nvar_nvar: /* d0 and d1 are where I want them */ if (IsIntTerm(d0) && IsIntTerm(d1)) { ///#ifdef PROFILED_ABSMI @@ -9494,7 +9521,7 @@ S_SREG = RepAppl(d0); saveregs(); Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); setregs(); - TRACED_FAIL(); + FAIL(); } } ///#ifdef PROFILED_ABSMI @@ -9508,39 +9535,39 @@ S_SREG = RepAppl(d0); GONext(); BEGP(pt0); - deref_body(d0, pt0, traced_minus_y_vv_unk, traced_minus_y_vv_nvar); + deref_body(d0, pt0, minus_y_vv_unk, minus_y_vv_nvar); ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(P_MINUS_Y_VV_MINUS_Y_VV_UNK); ///#endif saveregs(); Yap_NilError(INSTANTIATION_ERROR, "X is A-B"); setregs(); - TRACED_FAIL(); + FAIL(); ENDP(pt0); BEGP(pt0); - deref_body(d1, pt0, traced_minus_y_vv_nvar_unk, traced_minus_y_vv_nvar_nvar); + deref_body(d1, pt0, minus_y_vv_nvar_unk, minus_y_vv_nvar_nvar); ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(P_MINUS_Y_VV_MINUS_Y_VV_NVAR_UNK); ///#endif saveregs(); Yap_NilError(INSTANTIATION_ERROR, "X is A-B"); setregs(); - TRACED_FAIL(); + FAIL(); ENDP(pt0); ENDD(d1); ENDD(d0); ENDOp(); - Op(traced_p_minus_y_cv, yxn); + Op(p_minus_y_cv, yxn); ///#ifdef PROFILED_ABSMI EMIT_ENTRY_BLOCK(PREG,P_MINUS_Y_CV_INSTINIT); ///#endif BEGD(d0); d0 = XREG(PREG->y_u.yxn.xi); /* first check pt1 */ - deref_head(d0, traced_minus_y_cv_unk); - traced_minus_y_cv_nvar: + deref_head(d0, minus_y_cv_unk); + minus_y_cv_nvar: { ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(P_MINUS_Y_CV_MINUS_Y_CV_NVAR); @@ -9566,7 +9593,7 @@ S_SREG = RepAppl(d0); saveregs(); Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); setregs(); - TRACED_FAIL(); + FAIL(); } } } @@ -9581,31 +9608,31 @@ S_SREG = RepAppl(d0); GONext(); BEGP(pt0); - deref_body(d0, pt0, traced_minus_y_cv_unk, traced_minus_y_cv_nvar); + deref_body(d0, pt0, minus_y_cv_unk, minus_y_cv_nvar); ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(P_MINUS_Y_CV_MINUS_Y_CV_UNK); ///#endif saveregs(); Yap_NilError(INSTANTIATION_ERROR, "X is " Int_FORMAT "-A", PREG->y_u.yxn.c); setregs(); - TRACED_FAIL(); + FAIL(); ENDP(pt0); ENDD(d0); ENDOp(); - Op(traced_p_times_vv, xxx); + Op(p_times_vv, xxx); EMIT_ENTRY_BLOCK(PREG,P_TIMES_VV_INSTINIT); BEGD(d0); BEGD(d1); d0 = XREG(PREG->y_u.xxx.x1); /* first check pt1 */ - profiled_deref_head_TEST(d0, traced_times_vv_unk); - traced_times_vv_nvar: + profiled_deref_head_TEST(d0, times_vv_unk); + times_vv_nvar: EMIT_SIMPLE_BLOCK_TEST(P_TIMES_VV_TIMES_VV_NVAR); d1 = XREG(PREG->y_u.xxx.x2); /* next check A2 */ - profiled_deref_head_TEST(d1, traced_times_vv_nvar_unk); - traced_times_vv_nvar_nvar: + profiled_deref_head_TEST(d1, times_vv_nvar_unk); + times_vv_nvar_nvar: /* d0 and d1 are where I want them */ if (IsIntTerm(d0) && IsIntTerm(d1)) { EMIT_CONDITIONAL_SUCCESS("IsIntTerm(d0) && IsIntTerm(d1)"); @@ -9622,7 +9649,7 @@ S_SREG = RepAppl(d0); saveregs(); Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); setregs(); - TRACED_FAIL(); + FAIL(); } } XREG(PREG->y_u.xxx.x) = d0; @@ -9630,33 +9657,33 @@ S_SREG = RepAppl(d0); GONext(); BEGP(pt0); - profiled_deref_body(d0, pt0, traced_times_vv_unk, traced_times_vv_nvar); + profiled_deref_body(d0, pt0, times_vv_unk, times_vv_nvar); EMIT_SIMPLE_BLOCK_TEST(P_TIMES_VV_TIMES_VV_UNK); saveregs(); Yap_NilError(INSTANTIATION_ERROR, "X is A*B"); setregs(); - TRACED_FAIL(); + FAIL(); ENDP(pt0); BEGP(pt0); - profiled_deref_body(d1, pt0, traced_times_vv_nvar_unk, traced_times_vv_nvar_nvar); + profiled_deref_body(d1, pt0, times_vv_nvar_unk, times_vv_nvar_nvar); EMIT_SIMPLE_BLOCK_TEST(P_TIMES_VV_TIMES_VV_NVAR_UNK); saveregs(); Yap_NilError(INSTANTIATION_ERROR, "X is A*B"); setregs(); - TRACED_FAIL(); + FAIL(); ENDP(pt0); ENDD(d1); ENDD(d0); ENDOp(); - Op(traced_p_times_vc, xxn); + Op(p_times_vc, xxn); EMIT_ENTRY_BLOCK(PREG,P_TIMES_VC_INSTINIT); BEGD(d0); d0 = XREG(PREG->y_u.xxn.xi); /* first check pt1 */ - profiled_deref_head_TEST(d0, traced_times_vc_unk); - traced_times_vc_nvar: + profiled_deref_head_TEST(d0, times_vc_unk); + times_vc_nvar: { Int d1 = PREG->y_u.xxn.c; if (IsIntTerm(d0)) { @@ -9674,7 +9701,7 @@ S_SREG = RepAppl(d0); saveregs(); Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); setregs(); - TRACED_FAIL(); + FAIL(); } } } @@ -9683,17 +9710,17 @@ S_SREG = RepAppl(d0); GONext(); BEGP(pt0); - profiled_deref_body(d0, pt0, traced_times_vc_unk, traced_times_vc_nvar); + profiled_deref_body(d0, pt0, times_vc_unk, times_vc_nvar); EMIT_SIMPLE_BLOCK_TEST(P_TIMES_VC_TIMES_VC_UNK); saveregs(); Yap_NilError(INSTANTIATION_ERROR, "X is A* " Int_FORMAT, PREG->y_u.xxn.c); setregs(); - TRACED_FAIL(); + FAIL(); ENDP(pt0); ENDD(d0); ENDOp(); - Op(traced_p_times_y_vv, yxx); + Op(p_times_y_vv, yxx); ///#ifdef PROFILED_ABSMI EMIT_ENTRY_BLOCK(PREG,P_TIMES_Y_VV_INSTINIT); ///#endif @@ -9701,15 +9728,15 @@ S_SREG = RepAppl(d0); BEGD(d1); d0 = XREG(PREG->y_u.yxx.x1); /* first check pt1 */ - deref_head(d0, traced_times_y_vv_unk); - traced_times_y_vv_nvar: + deref_head(d0, times_y_vv_unk); + times_y_vv_nvar: ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(P_TIMES_Y_VV_TIMES_Y_VV_NVAR); ///#endif d1 = XREG(PREG->y_u.xxx.x2); /* next check A2 */ - deref_head(d1, traced_times_y_vv_nvar_unk); - traced_times_y_vv_nvar_nvar: + deref_head(d1, times_y_vv_nvar_unk); + times_y_vv_nvar_nvar: /* d0 and d1 are where I want them */ if (IsIntTerm(d0) && IsIntTerm(d1)) { ///#ifdef PROFILED_ABSMI @@ -9731,7 +9758,7 @@ S_SREG = RepAppl(d0); saveregs(); Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); setregs(); - TRACED_FAIL(); + FAIL(); } } ///#ifdef PROFILED_ABSMI @@ -9745,37 +9772,37 @@ S_SREG = RepAppl(d0); GONext(); BEGP(pt0); - deref_body(d0, pt0, traced_times_y_vv_unk, traced_times_y_vv_nvar); + deref_body(d0, pt0, times_y_vv_unk, times_y_vv_nvar); ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(P_TIMES_Y_VV_TIMES_Y_VV_UNK); ///#endif saveregs(); Yap_NilError(INSTANTIATION_ERROR, "X is A*B"); setregs(); - TRACED_FAIL(); + FAIL(); ENDP(pt0); BEGP(pt0); - deref_body(d1, pt0, traced_times_y_vv_nvar_unk, traced_times_y_vv_nvar_nvar); + deref_body(d1, pt0, times_y_vv_nvar_unk, times_y_vv_nvar_nvar); ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(P_TIMES_Y_VV_TIMES_Y_VV_NVAR_UNK); ///#endif saveregs(); Yap_NilError(INSTANTIATION_ERROR, "X is A*B"); setregs(); - TRACED_FAIL(); + FAIL(); ENDP(pt0); ENDD(d1); ENDD(d0); ENDOp(); - Op(traced_p_times_y_vc, yxn); + Op(p_times_y_vc, yxn); EMIT_ENTRY_BLOCK(PREG,P_TIMES_Y_VC_INSTINIT); BEGD(d0); d0 = XREG(PREG->y_u.yxn.xi); /* first check pt1 */ - profiled_deref_head_TEST(d0, traced_times_y_vc_unk); - traced_times_y_vc_nvar: + profiled_deref_head_TEST(d0, times_y_vc_unk); + times_y_vc_nvar: { Int d1 = PREG->y_u.yxn.c; if (IsIntTerm(d0)) { @@ -9791,7 +9818,7 @@ S_SREG = RepAppl(d0); saveregs(); Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); setregs(); - TRACED_FAIL(); + FAIL(); } } } @@ -9803,31 +9830,31 @@ S_SREG = RepAppl(d0); GONext(); BEGP(pt0); - profiled_deref_body(d0, pt0, traced_times_y_vc_unk, traced_times_y_vc_nvar); + profiled_deref_body(d0, pt0, times_y_vc_unk, times_y_vc_nvar); ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK_TEST(P_TIMES_Y_VC_TIMES_Y_VC_UNK); ///#endif saveregs(); Yap_NilError(INSTANTIATION_ERROR, "X is A* " Int_FORMAT, PREG->y_u.yxn.c); setregs(); - TRACED_FAIL(); + FAIL(); ENDP(pt0); ENDD(d0); ENDOp(); - Op(traced_p_div_vv, xxx); + Op(p_div_vv, xxx); EMIT_ENTRY_BLOCK(PREG,P_DIV_VV_INSTINIT); BEGD(d0); BEGD(d1); d0 = XREG(PREG->y_u.xxx.x1); /* first check pt1 */ - profiled_deref_head_TEST(d0, traced_div_vv_unk); - traced_div_vv_nvar: + profiled_deref_head_TEST(d0, div_vv_unk); + div_vv_nvar: EMIT_SIMPLE_BLOCK_TEST(P_DIV_VV_DIV_VV_NVAR); d1 = XREG(PREG->y_u.xxx.x2); /* next check A2 */ - profiled_deref_head_TEST(d1, traced_div_vv_nvar_unk); - traced_div_vv_nvar_nvar: + profiled_deref_head_TEST(d1, div_vv_nvar_unk); + div_vv_nvar_nvar: /* d0 and d1 are where I want them */ if (IsIntTerm(d0) && IsIntTerm(d1)) { EMIT_CONDITIONAL_SUCCESS("IsIntTerm(d0) && IsIntTerm(d1)"); @@ -9837,7 +9864,7 @@ S_SREG = RepAppl(d0); saveregs(); Yap_NilError(EVALUATION_ERROR_ZERO_DIVISOR,"// /2"); setregs(); - TRACED_FAIL(); + FAIL(); } d0 = MkIntTerm(IntOfTerm(d0) / div); } @@ -9851,7 +9878,7 @@ S_SREG = RepAppl(d0); saveregs(); Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); setregs(); - TRACED_FAIL(); + FAIL(); } } XREG(PREG->y_u.xxx.x) = d0; @@ -9859,35 +9886,35 @@ S_SREG = RepAppl(d0); GONext(); BEGP(pt0); - profiled_deref_body(d0, pt0, traced_div_vv_unk, traced_div_vv_nvar); + profiled_deref_body(d0, pt0, div_vv_unk, div_vv_nvar); EMIT_SIMPLE_BLOCK_TEST(P_DIV_VV_DIV_VV_UNK); saveregs(); Yap_NilError(INSTANTIATION_ERROR, "X is A//B"); setregs(); - TRACED_FAIL(); + FAIL(); ENDP(pt0); BEGP(pt0); - profiled_deref_body(d1, pt0, traced_div_vv_nvar_unk, traced_div_vv_nvar_nvar); + profiled_deref_body(d1, pt0, div_vv_nvar_unk, div_vv_nvar_nvar); EMIT_SIMPLE_BLOCK_TEST(P_DIV_VV_DIV_VV_NVAR_UNK); saveregs(); Yap_NilError(INSTANTIATION_ERROR, "X is A//B"); setregs(); - TRACED_FAIL(); + FAIL(); ENDP(pt0); ENDD(d1); ENDD(d0); ENDOp(); - Op(traced_p_div_vc, xxn); + Op(p_div_vc, xxn); ///#ifdef PROFILED_ABSMI EMIT_ENTRY_BLOCK(PREG,P_DIV_VC_INSTINIT); ///#endif BEGD(d0); d0 = XREG(PREG->y_u.xxn.xi); /* first check pt1 */ - deref_head(d0, traced_div_vc_unk); - traced_div_vc_nvar: + deref_head(d0, div_vc_unk); + div_vc_nvar: { ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(P_DIV_VC_DIV_VC_NVAR); @@ -9913,7 +9940,7 @@ S_SREG = RepAppl(d0); saveregs(); Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); setregs(); - TRACED_FAIL(); + FAIL(); } } } @@ -9925,27 +9952,27 @@ S_SREG = RepAppl(d0); GONext(); BEGP(pt0); - deref_body(d0, pt0, traced_div_vc_unk, traced_div_vc_nvar); + deref_body(d0, pt0, div_vc_unk, div_vc_nvar); ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(P_DIV_VC_DIV_VC_UNK); ///#endif saveregs(); Yap_NilError(INSTANTIATION_ERROR, "X is A//B"); setregs(); - TRACED_FAIL(); + FAIL(); ENDP(pt0); ENDD(d0); ENDOp(); - Op(traced_p_div_cv, xxn); + Op(p_div_cv, xxn); ///#ifdef PROFILED_ABSMI EMIT_ENTRY_BLOCK(PREG,P_DIV_CV_INSTINIT); ///#endif BEGD(d0); d0 = XREG(PREG->y_u.xxn.xi); /* first check pt1 */ - deref_head(d0, traced_div_cv_unk); - traced_div_cv_nvar: + deref_head(d0, div_cv_unk); + div_cv_nvar: { ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(P_DIV_CV_DIV_CV_NVAR); @@ -9963,7 +9990,7 @@ S_SREG = RepAppl(d0); saveregs(); Yap_NilError(EVALUATION_ERROR_ZERO_DIVISOR,"// /2"); setregs(); - TRACED_FAIL(); + FAIL(); } ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(P_DIV_CV_INTTERM_END); @@ -9983,7 +10010,7 @@ S_SREG = RepAppl(d0); saveregs(); Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); setregs(); - TRACED_FAIL(); + FAIL(); } } } @@ -9995,19 +10022,19 @@ S_SREG = RepAppl(d0); GONext(); BEGP(pt0); - deref_body(d0, pt0, traced_div_cv_unk, traced_div_cv_nvar); + deref_body(d0, pt0, div_cv_unk, div_cv_nvar); ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(P_DIV_CV_DIV_CV_UNK); ///#endif saveregs(); Yap_NilError(INSTANTIATION_ERROR, "X is " Int_FORMAT "// A", PREG->y_u.xxn.c); setregs(); - TRACED_FAIL(); + FAIL(); ENDP(pt0); ENDD(d0); ENDOp(); - Op(traced_p_div_y_vv, yxx); + Op(p_div_y_vv, yxx); ///#ifdef PROFILED_ABSMI EMIT_ENTRY_BLOCK(PREG,P_DIV_Y_VV_INSTINIT); ///#endif @@ -10015,15 +10042,15 @@ S_SREG = RepAppl(d0); BEGD(d1); d0 = XREG(PREG->y_u.yxx.x1); /* first check pt1 */ - deref_head(d0, traced_div_y_vv_unk); - traced_div_y_vv_nvar: + deref_head(d0, div_y_vv_unk); + div_y_vv_nvar: ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(P_DIV_Y_VV_DIV_Y_VV_NVAR); ///#endif d1 = XREG(PREG->y_u.xxx.x2); /* next check A2 */ - deref_head(d1, traced_div_y_vv_nvar_unk); - traced_div_y_vv_nvar_nvar: + deref_head(d1, div_y_vv_nvar_unk); + div_y_vv_nvar_nvar: /* d0 and d1 are where I want them */ if (IsIntTerm(d0) && IsIntTerm(d1)) { ///#ifdef PROFILED_ABSMI @@ -10037,7 +10064,7 @@ S_SREG = RepAppl(d0); saveregs(); Yap_NilError(EVALUATION_ERROR_ZERO_DIVISOR,"// /2"); setregs(); - TRACED_FAIL(); + FAIL(); } ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(P_DIV_Y_VV_INTTERM_END); @@ -10058,7 +10085,7 @@ S_SREG = RepAppl(d0); saveregs(); Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); setregs(); - TRACED_FAIL(); + FAIL(); } } ///#ifdef PROFILED_ABSMI @@ -10072,39 +10099,39 @@ S_SREG = RepAppl(d0); GONext(); BEGP(pt0); - deref_body(d0, pt0, traced_div_y_vv_unk, traced_div_y_vv_nvar); + deref_body(d0, pt0, div_y_vv_unk, div_y_vv_nvar); ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(P_DIV_Y_VV_DIV_Y_VV_UNK); ///#endif saveregs(); Yap_NilError(INSTANTIATION_ERROR, "X is A//B"); setregs(); - TRACED_FAIL(); + FAIL(); ENDP(pt0); BEGP(pt0); - deref_body(d1, pt0, traced_div_y_vv_nvar_unk, traced_div_y_vv_nvar_nvar); + deref_body(d1, pt0, div_y_vv_nvar_unk, div_y_vv_nvar_nvar); ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(P_DIV_Y_VV_DIV_Y_VV_NVAR_UNK); ///#endif saveregs(); Yap_NilError(INSTANTIATION_ERROR, "X is A//B"); setregs(); - TRACED_FAIL(); + FAIL(); ENDP(pt0); ENDD(d1); ENDD(d0); ENDOp(); - Op(traced_p_div_y_vc, yxn); + Op(p_div_y_vc, yxn); ///#ifdef PROFILED_ABSMI EMIT_ENTRY_BLOCK(PREG,P_DIV_Y_VC_INSTINIT); ///#endif BEGD(d0); d0 = XREG(PREG->y_u.yxn.xi); /* first check pt1 */ - deref_head(d0, traced_div_y_vc_unk); - traced_div_y_vc_nvar: + deref_head(d0, div_y_vc_unk); + div_y_vc_nvar: { ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(P_DIV_Y_VC_DIV_Y_VC_NVAR); @@ -10130,7 +10157,7 @@ S_SREG = RepAppl(d0); saveregs(); Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); setregs(); - TRACED_FAIL(); + FAIL(); } } } @@ -10145,27 +10172,27 @@ S_SREG = RepAppl(d0); GONext(); BEGP(pt0); - deref_body(d0, pt0, traced_div_y_vc_unk, traced_div_y_vc_nvar); + deref_body(d0, pt0, div_y_vc_unk, div_y_vc_nvar); ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(P_DIV_Y_VC_DIV_Y_VC_UNK); ///#endif saveregs(); Yap_NilError(INSTANTIATION_ERROR, "X is A//B"); setregs(); - TRACED_FAIL(); + FAIL(); ENDP(pt0); ENDD(d0); ENDOp(); - Op(traced_p_div_y_cv, yxn); + Op(p_div_y_cv, yxn); ///#ifdef PROFILED_ABSMI EMIT_ENTRY_BLOCK(PREG,P_DIV_Y_CV_INSTINIT); ///#endif BEGD(d0); d0 = XREG(PREG->y_u.yxn.xi); /* first check pt1 */ - deref_head(d0, traced_div_y_cv_unk); - traced_div_y_cv_nvar: + deref_head(d0, div_y_cv_unk); + div_y_cv_nvar: { ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(P_DIV_Y_CV_DIV_Y_CV_NVAR); @@ -10183,7 +10210,7 @@ S_SREG = RepAppl(d0); saveregs(); Yap_NilError(EVALUATION_ERROR_ZERO_DIVISOR,"// /2"); setregs(); - TRACED_FAIL(); + FAIL(); } ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(P_DIV_Y_CV_INTTERM_END); @@ -10204,7 +10231,7 @@ S_SREG = RepAppl(d0); saveregs(); Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); setregs(); - TRACED_FAIL(); + FAIL(); } } } @@ -10219,32 +10246,32 @@ S_SREG = RepAppl(d0); GONext(); BEGP(pt0); - deref_body(d0, pt0, traced_div_y_cv_unk, traced_div_y_cv_nvar); + deref_body(d0, pt0, div_y_cv_unk, div_y_cv_nvar); ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(P_DIV_Y_CV_DIV_Y_CV_UNK); ///#endif saveregs(); Yap_NilError(INSTANTIATION_ERROR, "X is " Int_FORMAT "// A", PREG->y_u.yxn.c); setregs(); - TRACED_FAIL(); + FAIL(); ENDP(pt0); ENDD(d0); ENDOp(); - Op(traced_p_and_vv, xxx); + Op(p_and_vv, xxx); EMIT_ENTRY_BLOCK(PREG,P_AND_VV_INSTINIT); BEGD(d0); BEGD(d1); d0 = XREG(PREG->y_u.xxx.x1); /* first check pt1 */ - profiled_deref_head_TEST(d0, traced_and_vv_unk); - traced_and_vv_nvar: + profiled_deref_head_TEST(d0, and_vv_unk); + and_vv_nvar: EMIT_SIMPLE_BLOCK_TEST(P_AND_VV_AND_VV_NVAR); d1 = XREG(PREG->y_u.xxx.x2); /* next check A2 */ - profiled_deref_head_TEST(d1, traced_and_vv_nvar_unk); - traced_and_vv_nvar_nvar: + profiled_deref_head_TEST(d1, and_vv_nvar_unk); + and_vv_nvar_nvar: /* d0 and d1 are where I want them */ if (IsIntTerm(d0) && IsIntTerm(d1)) { EMIT_CONDITIONAL_SUCCESS("IsIntTerm(d0) && IsIntTerm(d1)"); @@ -10261,7 +10288,7 @@ S_SREG = RepAppl(d0); saveregs(); Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); setregs(); - TRACED_FAIL(); + FAIL(); } } XREG(PREG->y_u.xxx.x) = d0; @@ -10269,33 +10296,33 @@ S_SREG = RepAppl(d0); GONext(); BEGP(pt0); - profiled_deref_body(d0, pt0, traced_and_vv_unk, traced_and_vv_nvar); + profiled_deref_body(d0, pt0, and_vv_unk, and_vv_nvar); EMIT_SIMPLE_BLOCK_TEST(P_AND_VV_AND_VV_UNK); saveregs(); Yap_NilError(INSTANTIATION_ERROR, "X is A/\\B"); setregs(); - TRACED_FAIL(); + FAIL(); ENDP(pt0); BEGP(pt0); - profiled_deref_body(d1, pt0, traced_and_vv_nvar_unk, traced_and_vv_nvar_nvar); + profiled_deref_body(d1, pt0, and_vv_nvar_unk, and_vv_nvar_nvar); EMIT_SIMPLE_BLOCK_TEST(P_AND_VV_AND_VV_NVAR_UNK); saveregs(); Yap_NilError(INSTANTIATION_ERROR, "X is A/\\B"); setregs(); - TRACED_FAIL(); + FAIL(); ENDP(pt0); ENDD(d1); ENDD(d0); ENDOp(); - Op(traced_p_and_vc, xxn); + Op(p_and_vc, xxn); EMIT_ENTRY_BLOCK(PREG,P_AND_VC_INSTINIT); BEGD(d0); d0 = XREG(PREG->y_u.xxn.xi); /* first check pt1 */ - profiled_deref_head_TEST(d0, traced_and_vc_unk); - traced_and_vc_nvar: + profiled_deref_head_TEST(d0, and_vc_unk); + and_vc_nvar: { Int d1 = PREG->y_u.xxn.c; if (IsIntTerm(d0)) { @@ -10313,7 +10340,7 @@ S_SREG = RepAppl(d0); saveregs(); Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); setregs(); - TRACED_FAIL(); + FAIL(); } } } @@ -10322,17 +10349,17 @@ S_SREG = RepAppl(d0); GONext(); BEGP(pt0); - profiled_deref_body(d0, pt0, traced_and_vc_unk, traced_and_vc_nvar); + profiled_deref_body(d0, pt0, and_vc_unk, and_vc_nvar); EMIT_SIMPLE_BLOCK_TEST(P_AND_VC_AND_VC_UNK); saveregs(); Yap_NilError(INSTANTIATION_ERROR, "X is A /\\ " Int_FORMAT , PREG->y_u.xxn.c); setregs(); - TRACED_FAIL(); + FAIL(); ENDP(pt0); ENDD(d0); ENDOp(); - Op(traced_p_and_y_vv, yxx); + Op(p_and_y_vv, yxx); ///#ifdef PROFILED_ABSMI EMIT_ENTRY_BLOCK(PREG,P_AND_Y_VV_INSTINIT); ///#endif @@ -10340,15 +10367,15 @@ S_SREG = RepAppl(d0); BEGD(d1); d0 = XREG(PREG->y_u.yxx.x1); /* first check pt1 */ - deref_head(d0, traced_and_y_vv_unk); - traced_and_y_vv_nvar: + deref_head(d0, and_y_vv_unk); + and_y_vv_nvar: ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(P_AND_Y_VV_AND_Y_VV_NVAR); ///#endif d1 = XREG(PREG->y_u.xxx.x2); /* next check A2 */ - deref_head(d1, traced_and_y_vv_nvar_unk); - traced_and_y_vv_nvar_nvar: + deref_head(d1, and_y_vv_nvar_unk); + and_y_vv_nvar_nvar: /* d0 and d1 are where I want them */ if (IsIntTerm(d0) && IsIntTerm(d1)) { ///#ifdef PROFILED_ABSMI @@ -10370,7 +10397,7 @@ S_SREG = RepAppl(d0); saveregs(); Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); setregs(); - TRACED_FAIL(); + FAIL(); } } ///#ifdef PROFILED_ABSMI @@ -10384,39 +10411,39 @@ S_SREG = RepAppl(d0); GONext(); BEGP(pt0); - deref_body(d0, pt0, traced_and_y_vv_unk, traced_and_y_vv_nvar); + deref_body(d0, pt0, and_y_vv_unk, and_y_vv_nvar); ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(P_AND_Y_VV_AND_Y_VV_UNK); ///#endif saveregs(); Yap_NilError(INSTANTIATION_ERROR, "X is A/\\B"); setregs(); - TRACED_FAIL(); + FAIL(); ENDP(pt0); BEGP(pt0); - deref_body(d1, pt0, traced_and_y_vv_nvar_unk, traced_and_y_vv_nvar_nvar); + deref_body(d1, pt0, and_y_vv_nvar_unk, and_y_vv_nvar_nvar); ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(P_AND_Y_VV_AND_Y_VV_NVAR_UNK); ///#endif saveregs(); Yap_NilError(INSTANTIATION_ERROR, "X is A/\\B"); setregs(); - TRACED_FAIL(); + FAIL(); ENDP(pt0); ENDD(d1); ENDD(d0); ENDOp(); - Op(traced_p_and_y_vc, yxn); + Op(p_and_y_vc, yxn); ///#ifdef PROFILED_ABSMI EMIT_ENTRY_BLOCK(PREG,P_AND_Y_VC_INSTINIT); ///#endif BEGD(d0); d0 = XREG(PREG->y_u.yxn.xi); /* first check pt1 */ - deref_head(d0, traced_and_y_vc_unk); - traced_and_y_vc_nvar: + deref_head(d0, and_y_vc_unk); + and_y_vc_nvar: { ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(P_AND_Y_VC_AND_Y_VC_NVAR); @@ -10442,7 +10469,7 @@ S_SREG = RepAppl(d0); saveregs(); Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); setregs(); - TRACED_FAIL(); + FAIL(); } } } @@ -10457,20 +10484,20 @@ S_SREG = RepAppl(d0); GONext(); BEGP(pt0); - deref_body(d0, pt0, traced_and_y_vc_unk, traced_and_y_vc_nvar); + deref_body(d0, pt0, and_y_vc_unk, and_y_vc_nvar); ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(P_AND_Y_VC_AND_Y_VC_UNK); ///#endif saveregs(); Yap_NilError(INSTANTIATION_ERROR, "X is A /\\ " Int_FORMAT , PREG->y_u.yxn.c); setregs(); - TRACED_FAIL(); + FAIL(); ENDP(pt0); ENDD(d0); ENDOp(); - Op(traced_p_or_vv, xxx); + Op(p_or_vv, xxx); ///#ifdef PROFILED_ABSMI EMIT_ENTRY_BLOCK(PREG,P_OR_VV_INSTINIT); ///#endif @@ -10478,15 +10505,15 @@ S_SREG = RepAppl(d0); BEGD(d1); d0 = XREG(PREG->y_u.xxx.x1); /* first check pt1 */ - deref_head(d0, traced_or_vv_unk); - traced_or_vv_nvar: + deref_head(d0, or_vv_unk); + or_vv_nvar: ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(P_OR_VV_OR_VV_NVAR); ///#endif d1 = XREG(PREG->y_u.xxx.x2); /* next check A2 */ - deref_head(d1, traced_or_vv_nvar_unk); - traced_or_vv_nvar_nvar: + deref_head(d1, or_vv_nvar_unk); + or_vv_nvar_nvar: /* d0 and d1 are where I want them */ if (IsIntTerm(d0) && IsIntTerm(d1)) { ///#ifdef PROFILED_ABSMI @@ -10508,7 +10535,7 @@ S_SREG = RepAppl(d0); saveregs(); Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); setregs(); - TRACED_FAIL(); + FAIL(); } } ///#ifdef PROFILED_ABSMI @@ -10519,39 +10546,39 @@ S_SREG = RepAppl(d0); GONext(); BEGP(pt0); - deref_body(d0, pt0, traced_or_vv_unk, traced_or_vv_nvar); + deref_body(d0, pt0, or_vv_unk, or_vv_nvar); //#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(P_OR_VV_OR_VV_UNK); ///#endif saveregs(); Yap_NilError(INSTANTIATION_ERROR, "X is A\\/B"); setregs(); - TRACED_FAIL(); + FAIL(); ENDP(pt0); BEGP(pt0); - deref_body(d1, pt0, traced_or_vv_nvar_unk, traced_or_vv_nvar_nvar); + deref_body(d1, pt0, or_vv_nvar_unk, or_vv_nvar_nvar); ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(P_OR_VV_OR_VV_NVAR_UNK); ///#endif saveregs(); Yap_NilError(INSTANTIATION_ERROR, "X is A\\/B"); setregs(); - TRACED_FAIL(); + FAIL(); ENDP(pt0); ENDD(d1); ENDD(d0); ENDOp(); - Op(traced_p_or_vc, xxn); + Op(p_or_vc, xxn); ///#ifdef PROFILED_ABSMI EMIT_ENTRY_BLOCK(PREG,P_OR_VC_INSTINIT); ///#endif BEGD(d0); d0 = XREG(PREG->y_u.xxn.xi); /* first check pt1 */ - deref_head(d0, traced_or_vc_unk); - traced_or_vc_nvar: + deref_head(d0, or_vc_unk); + or_vc_nvar: { ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(P_OR_VC_OR_VC_NVAR); @@ -10576,7 +10603,7 @@ S_SREG = RepAppl(d0); saveregs(); Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); setregs(); - TRACED_FAIL(); + FAIL(); } } } @@ -10588,19 +10615,19 @@ S_SREG = RepAppl(d0); GONext(); BEGP(pt0); - deref_body(d0, pt0, traced_or_vc_unk, traced_or_vc_nvar); + deref_body(d0, pt0, or_vc_unk, or_vc_nvar); ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(P_OR_VC_OR_VC_UNK); ///#endif saveregs(); Yap_NilError(INSTANTIATION_ERROR, "X is A \\/ " Int_FORMAT , PREG->y_u.xxn.c); setregs(); - TRACED_FAIL(); + FAIL(); ENDP(pt0); ENDD(d0); ENDOp(); - Op(traced_p_or_y_vv, yxx); + Op(p_or_y_vv, yxx); ///#ifdef PROFILED_ABSMI EMIT_ENTRY_BLOCK(PREG,P_OR_Y_VV_INSTINIT); ///#endif @@ -10608,15 +10635,15 @@ S_SREG = RepAppl(d0); BEGD(d1); d0 = XREG(PREG->y_u.yxx.x1); /* first check pt1 */ - deref_head(d0, traced_or_y_vv_unk); - traced_or_y_vv_nvar: + deref_head(d0, or_y_vv_unk); + or_y_vv_nvar: ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(P_OR_Y_VV_OR_Y_VV_NVAR); ///#endif d1 = XREG(PREG->y_u.xxx.x2); /* next check A2 */ - deref_head(d1, traced_or_y_vv_nvar_unk); - traced_or_y_vv_nvar_nvar: + deref_head(d1, or_y_vv_nvar_unk); + or_y_vv_nvar_nvar: /* d0 and d1 are where I want them */ if (IsIntTerm(d0) && IsIntTerm(d1)) { ///#ifdef PROFILED_ABSMI @@ -10638,7 +10665,7 @@ S_SREG = RepAppl(d0); saveregs(); Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); setregs(); - TRACED_FAIL(); + FAIL(); } } ///#ifdef PROFILED_ABSMI @@ -10652,39 +10679,39 @@ S_SREG = RepAppl(d0); GONext(); BEGP(pt0); - deref_body(d0, pt0, traced_or_y_vv_unk, traced_or_y_vv_nvar); + deref_body(d0, pt0, or_y_vv_unk, or_y_vv_nvar); ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(P_OR_Y_VV_OR_Y_VV_UNK); ///#endif saveregs(); Yap_NilError(INSTANTIATION_ERROR, "X is A\\/B"); setregs(); - TRACED_FAIL(); + FAIL(); ENDP(pt0); BEGP(pt0); - deref_body(d1, pt0, traced_or_y_vv_nvar_unk, traced_or_y_vv_nvar_nvar); + deref_body(d1, pt0, or_y_vv_nvar_unk, or_y_vv_nvar_nvar); ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(P_OR_Y_VV_OR_Y_VV_NVAR_UNK); ///#endif saveregs(); Yap_NilError(INSTANTIATION_ERROR, "X is A\\/B"); setregs(); - TRACED_FAIL(); + FAIL(); ENDP(pt0); ENDD(d1); ENDD(d0); ENDOp(); - Op(traced_p_or_y_vc, yxn); + Op(p_or_y_vc, yxn); ///#ifdef PROFILED_ABSMI EMIT_ENTRY_BLOCK(PREG,P_OR_Y_VC_INSTINIT); ///#endif BEGD(d0); d0 = XREG(PREG->y_u.yxn.xi); /* first check pt1 */ - deref_head(d0, traced_or_y_vc_unk); - traced_or_y_vc_nvar: + deref_head(d0, or_y_vc_unk); + or_y_vc_nvar: { ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(P_OR_Y_VC_OR_Y_VC_NVAR); @@ -10710,7 +10737,7 @@ S_SREG = RepAppl(d0); saveregs(); Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); setregs(); - TRACED_FAIL(); + FAIL(); } } } @@ -10725,19 +10752,19 @@ S_SREG = RepAppl(d0); GONext(); BEGP(pt0); - deref_body(d0, pt0, traced_or_y_vc_unk, traced_or_y_vc_nvar); + deref_body(d0, pt0, or_y_vc_unk, or_y_vc_nvar); ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(P_OR_Y_VC_OR_Y_VC_UNK); ///#endif saveregs(); Yap_NilError(INSTANTIATION_ERROR, "X is A \\/ " Int_FORMAT , PREG->y_u.yxn.c); setregs(); - TRACED_FAIL(); + FAIL(); ENDP(pt0); ENDD(d0); ENDOp(); - Op(traced_p_sll_vv, xxx); + Op(p_sll_vv, xxx); ///#ifdef PROFILED_ABSMI EMIT_ENTRY_BLOCK(PREG,P_SLL_VV_INSTINIT); ///#endif @@ -10745,15 +10772,15 @@ S_SREG = RepAppl(d0); BEGD(d1); d0 = XREG(PREG->y_u.xxx.x1); /* first check pt1 */ - deref_head(d0, traced_sll_vv_unk); - traced_sll_vv_nvar: + deref_head(d0, sll_vv_unk); + sll_vv_nvar: ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(P_SLL_VV_SLL_VV_NVAR); ///#endif d1 = XREG(PREG->y_u.xxx.x2); /* next check A2 */ - deref_head(d1, traced_sll_vv_nvar_unk); - traced_sll_vv_nvar_nvar: + deref_head(d1, sll_vv_nvar_unk); + sll_vv_nvar_nvar: /* d0 and d1 are where I want them */ if (IsIntTerm(d0) && IsIntTerm(d1)) { ///#ifdef PROFILED_ABSMI @@ -10787,7 +10814,7 @@ S_SREG = RepAppl(d0); saveregs(); Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); setregs(); - TRACED_FAIL(); + FAIL(); } ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(P_SLL_VV_NVAR_END); @@ -10797,39 +10824,39 @@ S_SREG = RepAppl(d0); GONext(); BEGP(pt0); - deref_body(d0, pt0, traced_sll_vv_unk, traced_sll_vv_nvar); + deref_body(d0, pt0, sll_vv_unk, sll_vv_nvar); ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(P_SLL_VV_SLL_VV_UNK); ///#endif saveregs(); Yap_NilError(INSTANTIATION_ERROR, "X is A<y_u.xxn.xi); /* first check pt1 */ - deref_head(d0, traced_sll_vc_unk); - traced_sll_vc_nvar: + deref_head(d0, sll_vc_unk); + sll_vc_nvar: { ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(P_SLL_VC_SLL_VC_NVAR); @@ -10857,7 +10884,7 @@ S_SREG = RepAppl(d0); saveregs(); Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); setregs(); - TRACED_FAIL(); + FAIL(); } ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(P_SLL_VC_NVAR_END); @@ -10867,25 +10894,25 @@ S_SREG = RepAppl(d0); GONext(); BEGP(pt0); - deref_body(d0, pt0, traced_sll_vc_unk, traced_sll_vc_nvar); + deref_body(d0, pt0, sll_vc_unk, sll_vc_nvar); ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(P_SLL_VC_SLL_VC_UNK); ///#endif saveregs(); Yap_NilError(INSTANTIATION_ERROR, "X is A<y_u.xxn.xi); /* first check pt1 */ - profiled_deref_head_TEST(d0, traced_sll_cv_unk); - traced_sll_cv_nvar: + profiled_deref_head_TEST(d0, sll_cv_unk); + sll_cv_nvar: { Int d1 = PREG->y_u.xxn.c; if (IsIntTerm(d0)) { @@ -10909,24 +10936,24 @@ S_SREG = RepAppl(d0); saveregs(); Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); setregs(); - TRACED_FAIL(); + FAIL(); } XREG(PREG->y_u.xxn.x) = d0; PREG = NEXTOP(PREG, xxn); GONext(); BEGP(pt0); - profiled_deref_body(d0, pt0, traced_sll_cv_unk, traced_sll_cv_nvar); + profiled_deref_body(d0, pt0, sll_cv_unk, sll_cv_nvar); EMIT_SIMPLE_BLOCK_TEST(P_SLL_CV_SLL_CV_UNK); saveregs(); Yap_NilError(INSTANTIATION_ERROR, "X is A<y_u.yxx.x1); /* first check pt1 */ - deref_head(d0, traced_sll_y_vv_unk); - traced_sll_y_vv_nvar: + deref_head(d0, sll_y_vv_unk); + sll_y_vv_nvar: ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(P_SLL_Y_VV_SLL_Y_VV_NVAR); ///#endif d1 = XREG(PREG->y_u.xxx.x2); /* next check A2 */ - deref_head(d1, traced_sll_y_vv_nvar_unk); - traced_sll_y_vv_nvar_nvar: + deref_head(d1, sll_y_vv_nvar_unk); + sll_y_vv_nvar_nvar: /* d0 and d1 are where I want them */ if (IsIntTerm(d0) && IsIntTerm(d1)) { ///#ifdef PROFILED_ABSMI @@ -10975,7 +11002,7 @@ S_SREG = RepAppl(d0); saveregs(); Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); setregs(); - TRACED_FAIL(); + FAIL(); } ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(P_SLL_Y_VV_NVAR_END); @@ -10988,39 +11015,39 @@ S_SREG = RepAppl(d0); GONext(); BEGP(pt0); - deref_body(d0, pt0, traced_sll_y_vv_unk, traced_sll_y_vv_nvar); + deref_body(d0, pt0, sll_y_vv_unk, sll_y_vv_nvar); ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(P_SLL_Y_VV_SLL_Y_VV_UNK); ///#endif saveregs(); Yap_NilError(INSTANTIATION_ERROR, "X is A<y_u.yxn.xi); /* first check pt1 */ - deref_head(d0, traced_sll_y_vc_unk); - traced_sll_y_vc_nvar: + deref_head(d0, sll_y_vc_unk); + sll_y_vc_nvar: { ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(P_SLL_Y_VC_SLL_Y_VC_NVAR); @@ -11048,7 +11075,7 @@ S_SREG = RepAppl(d0); saveregs(); Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); setregs(); - TRACED_FAIL(); + FAIL(); } ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(P_SLL_Y_VC_NVAR_END); @@ -11061,28 +11088,28 @@ S_SREG = RepAppl(d0); GONext(); BEGP(pt0); - deref_body(d0, pt0, traced_sll_y_vc_unk, traced_sll_y_vc_nvar); + deref_body(d0, pt0, sll_y_vc_unk, sll_y_vc_nvar); ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(P_SLL_Y_VC_SLL_Y_VC_UNK); ///#endif saveregs(); Yap_NilError(INSTANTIATION_ERROR, "X is A<y_u.yxn.xi); /* first check pt1 */ - deref_head(d0, traced_sll_y_cv_unk); - traced_sll_y_cv_nvar: + deref_head(d0, sll_y_cv_unk); + sll_y_cv_nvar: { ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(P_SLL_Y_CV_SLL_Y_CV_NVAR); @@ -11120,7 +11147,7 @@ S_SREG = RepAppl(d0); saveregs(); Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); setregs(); - TRACED_FAIL(); + FAIL(); } ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(P_SLL_Y_CV_NVAR_END); @@ -11133,19 +11160,19 @@ S_SREG = RepAppl(d0); GONext(); BEGP(pt0); - deref_body(d0, pt0, traced_sll_y_cv_unk, traced_sll_y_cv_nvar); + deref_body(d0, pt0, sll_y_cv_unk, sll_y_cv_nvar); ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(P_SLL_Y_CV_SLL_Y_CV_UNK); ///#endif saveregs(); Yap_NilError(INSTANTIATION_ERROR, "X is A<y_u.xxx.x1); /* first check pt1 */ - deref_head(d0, traced_slr_vv_unk); - traced_slr_vv_nvar: + deref_head(d0, slr_vv_unk); + slr_vv_nvar: ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(P_SLR_VV_SLR_VV_NVAR); ///#endif d1 = XREG(PREG->y_u.xxx.x2); /* next check A2 */ - deref_head(d1, traced_slr_vv_nvar_unk); - traced_slr_vv_nvar_nvar: + deref_head(d1, slr_vv_nvar_unk); + slr_vv_nvar_nvar: /* d0 and d1 are where I want them */ if (IsIntTerm(d0) && IsIntTerm(d1)) { ///#ifdef PROFILED_ABSMI @@ -11194,7 +11221,7 @@ S_SREG = RepAppl(d0); saveregs(); Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); setregs(); - TRACED_FAIL(); + FAIL(); } ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(P_SLR_VV_NVAR_END); @@ -11204,37 +11231,37 @@ S_SREG = RepAppl(d0); GONext(); BEGP(pt0); - deref_body(d0, pt0, traced_slr_vv_unk, traced_slr_vv_nvar); + deref_body(d0, pt0, slr_vv_unk, slr_vv_nvar); ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(P_SLR_VV_SRL_VV_UNK); ///#endif saveregs(); Yap_NilError(INSTANTIATION_ERROR, "X is A>>B"); setregs(); - TRACED_FAIL(); + FAIL(); ENDP(pt0); BEGP(pt0); - deref_body(d1, pt0, traced_slr_vv_nvar_unk, traced_slr_vv_nvar_nvar); + deref_body(d1, pt0, slr_vv_nvar_unk, slr_vv_nvar_nvar); ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(P_SLR_VV_SRL_VV_NVAR_UNK); ///#endif saveregs(); Yap_NilError(INSTANTIATION_ERROR, "X is A>>B"); setregs(); - TRACED_FAIL(); + FAIL(); ENDP(pt0); ENDD(d1); ENDD(d0); ENDOp(); - Op(traced_p_slr_vc, xxn); + Op(p_slr_vc, xxn); EMIT_ENTRY_BLOCK(PREG,P_SLR_VC_INSTINIT); BEGD(d0); d0 = XREG(PREG->y_u.xxn.xi); /* first check pt1 */ - profiled_deref_head_TEST(d0, traced_slr_vc_unk); - traced_slr_vc_nvar: + profiled_deref_head_TEST(d0, slr_vc_unk); + slr_vc_nvar: { Int d1 = PREG->y_u.xxn.c; if (IsIntTerm(d0)) { @@ -11252,7 +11279,7 @@ S_SREG = RepAppl(d0); saveregs(); Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); setregs(); - TRACED_FAIL(); + FAIL(); } } } @@ -11261,25 +11288,25 @@ S_SREG = RepAppl(d0); GONext(); BEGP(pt0); - profiled_deref_body(d0, pt0, traced_slr_vc_unk, traced_slr_vc_nvar); + profiled_deref_body(d0, pt0, slr_vc_unk, slr_vc_nvar); EMIT_SIMPLE_BLOCK_TEST(P_SLR_VC_SRL_VC_UNK); saveregs(); Yap_NilError(INSTANTIATION_ERROR, "X is A>>B"); setregs(); - TRACED_FAIL(); + FAIL(); ENDP(pt0); ENDD(d0); ENDOp(); - Op(traced_p_slr_cv, xxn); + Op(p_slr_cv, xxn); ///#ifdef PROFILED_ABSMI EMIT_ENTRY_BLOCK(PREG,P_SLR_CV_INSTINIT); ///#endif BEGD(d0); d0 = XREG(PREG->y_u.xxn.xi); /* first check pt1 */ - deref_head(d0, traced_slr_cv_unk); - traced_slr_cv_nvar: + deref_head(d0, slr_cv_unk); + slr_cv_nvar: { ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(P_SLR_CV_SLR_CV_NVAR); @@ -11317,7 +11344,7 @@ S_SREG = RepAppl(d0); saveregs(); Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); setregs(); - TRACED_FAIL(); + FAIL(); } ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(P_SLR_CV_NVAR_END); @@ -11327,19 +11354,19 @@ S_SREG = RepAppl(d0); GONext(); BEGP(pt0); - deref_body(d0, pt0, traced_slr_cv_unk, traced_slr_cv_nvar); + deref_body(d0, pt0, slr_cv_unk, slr_cv_nvar); ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(P_SLR_CV_SLR_CV_UNK); ///#endif saveregs(); Yap_NilError(INSTANTIATION_ERROR, "X is A>>B"); setregs(); - TRACED_FAIL(); + FAIL(); ENDP(pt0); ENDD(d0); ENDOp(); - Op(traced_p_slr_y_vv, yxx); + Op(p_slr_y_vv, yxx); ///#ifdef PROFILED_ABSMI EMIT_ENTRY_BLOCK(PREG,P_SLR_Y_VV_INSTINIT); ///#endif @@ -11347,15 +11374,15 @@ S_SREG = RepAppl(d0); BEGD(d1); d0 = XREG(PREG->y_u.yxx.x1); /* first check pt1 */ - deref_head(d0, traced_slr_y_vv_unk); - traced_slr_y_vv_nvar: + deref_head(d0, slr_y_vv_unk); + slr_y_vv_nvar: ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(P_SLR_Y_VV_SLR_Y_VV_NVAR); ///#endif d1 = XREG(PREG->y_u.xxx.x2); /* next check A2 */ - deref_head(d1, traced_slr_y_vv_nvar_unk); - traced_slr_y_vv_nvar_nvar: + deref_head(d1, slr_y_vv_nvar_unk); + slr_y_vv_nvar_nvar: /* d0 and d1 are where I want them */ if (IsIntTerm(d0) && IsIntTerm(d1)) { ///#ifdef PROFILED_ABSMI @@ -11389,7 +11416,7 @@ S_SREG = RepAppl(d0); saveregs(); Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); setregs(); - TRACED_FAIL(); + FAIL(); } ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(P_SLR_Y_VV_NVAR_END); @@ -11401,39 +11428,39 @@ S_SREG = RepAppl(d0); GONext(); BEGP(pt0); - deref_body(d0, pt0, traced_slr_y_vv_unk, traced_slr_y_vv_nvar); + deref_body(d0, pt0, slr_y_vv_unk, slr_y_vv_nvar); ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(P_SLR_Y_VV_SLR_Y_VV_UNK); ///#endif saveregs(); Yap_NilError(INSTANTIATION_ERROR, "X is A>>B"); setregs(); - TRACED_FAIL(); + FAIL(); ENDP(pt0); BEGP(pt0); - deref_body(d1, pt0, traced_slr_y_vv_nvar_unk, traced_slr_y_vv_nvar_nvar); + deref_body(d1, pt0, slr_y_vv_nvar_unk, slr_y_vv_nvar_nvar); ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(P_SLR_Y_VV_SLR_Y_VV_NVAR_UNK); ///#endif saveregs(); Yap_NilError(INSTANTIATION_ERROR, "X is A>>B"); setregs(); - TRACED_FAIL(); + FAIL(); ENDP(pt0); ENDD(d1); ENDD(d0); ENDOp(); - Op(traced_p_slr_y_vc, yxn); + Op(p_slr_y_vc, yxn); ///#ifdef PROFILED_ABSMI EMIT_ENTRY_BLOCK(PREG,P_SLR_Y_VC_INSTINIT); ///#endif BEGD(d0); d0 = XREG(PREG->y_u.yxn.xi); /* first check pt1 */ - deref_head(d0, traced_slr_y_vc_unk); - traced_slr_y_vc_nvar: + deref_head(d0, slr_y_vc_unk); + slr_y_vc_nvar: { ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(P_SLR_Y_VC_SLR_Y_VC_NVAR); @@ -11459,7 +11486,7 @@ S_SREG = RepAppl(d0); saveregs(); Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); setregs(); - TRACED_FAIL(); + FAIL(); } } } @@ -11474,7 +11501,7 @@ S_SREG = RepAppl(d0); GONext(); BEGP(pt0); - deref_body(d0, pt0, traced_slr_y_vc_unk, traced_slr_y_vc_nvar); + deref_body(d0, pt0, slr_y_vc_unk, slr_y_vc_nvar); ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(P_SLR_Y_VC_SLR_Y_VC_UNK); ///#endif @@ -11485,15 +11512,15 @@ S_SREG = RepAppl(d0); ENDD(d0); ENDOp(); - Op(traced_p_slr_y_cv, yxn); + Op(p_slr_y_cv, yxn); ///#ifdef PROFILED_ABSMI EMIT_ENTRY_BLOCK(PREG,P_SLR_Y_CV_INSTINIT); ///#endif BEGD(d0); d0 = XREG(PREG->y_u.yxn.xi); /* first check pt1 */ - deref_head(d0, traced_slr_y_cv_unk); - traced_slr_y_cv_nvar: + deref_head(d0, slr_y_cv_unk); + slr_y_cv_nvar: { ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(P_SLR_Y_CV_SLR_Y_CV_NVAR); @@ -11531,7 +11558,7 @@ S_SREG = RepAppl(d0); saveregs(); Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); setregs(); - TRACED_FAIL(); + FAIL(); } ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(P_SLR_Y_CV_NVAR_END); @@ -11544,29 +11571,29 @@ S_SREG = RepAppl(d0); GONext(); BEGP(pt0); - deref_body(d0, pt0, traced_slr_y_cv_unk, traced_slr_y_cv_nvar); + deref_body(d0, pt0, slr_y_cv_unk, slr_y_cv_nvar); ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(P_SLR_Y_CV_SLR_Y_CV_UNK); ///#endif saveregs(); Yap_NilError(INSTANTIATION_ERROR, "X is A>>B"); setregs(); - TRACED_FAIL(); + FAIL(); ENDP(pt0); ENDD(d0); ENDOp(); - BOp(traced_call_bfunc_xx, plxxs); + BOp(call_bfunc_xx, plxxs); EMIT_ENTRY_BLOCK(PREG,CALL_BFUNC_XX_INSTINIT); BEGD(d0); BEGD(d1); d0 = XREG(PREG->y_u.plxxs.x1); - traced_call_bfunc_xx_nvar: + call_bfunc_xx_nvar: EMIT_SIMPLE_BLOCK_TEST(CALL_BFUNC_XX_CALL_BFUNC_XX_NVAR); d1 = XREG(PREG->y_u.plxxs.x2); - traced_call_bfunc_xx2_nvar: - profiled_deref_head_TEST(d0, traced_call_bfunc_xx_unk); - profiled_deref_head_TEST(d1, traced_call_bfunc_xx2_unk); + call_bfunc_xx2_nvar: + profiled_deref_head_TEST(d0, call_bfunc_xx_unk); + profiled_deref_head_TEST(d1, call_bfunc_xx2_unk); if (IsIntTerm(d0) && IsIntTerm(d1)) { EMIT_CONDITIONAL_SUCCESS("IsIntTerm(d0) && IsIntTerm(d1)"); EMIT_MULTIPLE_DESTINY_BLOCK_TEST(CALL_BFUNC_XX_CALL_BFUNC_XX2_NVAR_INT); @@ -11623,7 +11650,7 @@ S_SREG = RepAppl(d0); } } } - traced_exec_bin_cmp_xx: + exec_bin_cmp_xx: EMIT_CONDITIONAL_FAIL("IsIntTerm(d0) && IsIntTerm(d1)"); EMIT_MULTIPLE_DESTINY_BLOCK_TEST(CALL_BFUNC_XX_CALL_BFUNC_XX2_NVAR_NOINT); { @@ -11643,22 +11670,22 @@ S_SREG = RepAppl(d0); JMPNext(); BEGP(pt0); - profiled_deref_body(d0, pt0, traced_call_bfunc_xx_unk, traced_call_bfunc_xx_nvar); + profiled_deref_body(d0, pt0, call_bfunc_xx_unk, call_bfunc_xx_nvar); EMIT_SIMPLE_BLOCK_TEST(CALL_BFUNC_XX_CALL_BFUNC_XX_UNK); d1 = Deref(d1); - goto traced_exec_bin_cmp_xx; + goto exec_bin_cmp_xx; ENDP(pt0); BEGP(pt0); - profiled_deref_body(d1, pt0, traced_call_bfunc_xx2_unk, traced_call_bfunc_xx2_nvar); - goto traced_exec_bin_cmp_xx; + profiled_deref_body(d1, pt0, call_bfunc_xx2_unk, call_bfunc_xx2_nvar); + goto exec_bin_cmp_xx; ENDP(pt0); ENDD(d1); ENDD(d0); ENDBOp(); - BOp(traced_call_bfunc_yx, plxys); + BOp(call_bfunc_yx, plxys); EMIT_ENTRY_BLOCK(PREG,CALL_BFUNC_YX_INSTINIT); BEGD(d0); BEGD(d1); @@ -11667,10 +11694,10 @@ S_SREG = RepAppl(d0); d1 = XREG(PREG->y_u.plxys.x); d0 = *pt0; ENDP(pt0); - profiled_deref_head_TEST(d0, traced_call_bfunc_yx_unk); - traced_call_bfunc_yx_nvar: - profiled_deref_head_TEST(d1, traced_call_bfunc_yx2_unk); - traced_call_bfunc_yx2_nvar: + profiled_deref_head_TEST(d0, call_bfunc_yx_unk); + call_bfunc_yx_nvar: + profiled_deref_head_TEST(d1, call_bfunc_yx2_unk); + call_bfunc_yx2_nvar: if (IsIntTerm(d0) && IsIntTerm(d1)) { EMIT_CONDITIONAL_SUCCESS("IsIntTerm(d0) && IsIntTerm(d1)"); EMIT_MULTIPLE_DESTINY_BLOCK_TEST(CALL_BFUNC_YX_CALL_BFUNC_YX2_NVAR_INT); @@ -11704,7 +11731,7 @@ S_SREG = RepAppl(d0); } } } - traced_exec_bin_cmp_yx: + exec_bin_cmp_yx: EMIT_CONDITIONAL_FAIL("IsIntTerm(d0) && IsIntTerm(d1)"); EMIT_MULTIPLE_DESTINY_BLOCK_TEST(CALL_BFUNC_YX_CALL_BFUNC_YX2_NVAR_NOINT); { @@ -11723,22 +11750,22 @@ S_SREG = RepAppl(d0); JMPNext(); BEGP(pt0); - profiled_deref_body(d0, pt0, traced_call_bfunc_yx_unk, traced_call_bfunc_yx_nvar); + profiled_deref_body(d0, pt0, call_bfunc_yx_unk, call_bfunc_yx_nvar); EMIT_SIMPLE_BLOCK_TEST(CALL_BFUNC_YX_CALL_BFUNC_YX_UNK); d1 = Deref(d1); - goto traced_exec_bin_cmp_yx; + goto exec_bin_cmp_yx; ENDP(pt0); BEGP(pt0); - profiled_deref_body(d1, pt0, traced_call_bfunc_yx2_unk, traced_call_bfunc_yx2_nvar); - goto traced_exec_bin_cmp_yx; + profiled_deref_body(d1, pt0, call_bfunc_yx2_unk, call_bfunc_yx2_nvar); + goto exec_bin_cmp_yx; ENDP(pt0); ENDD(d1); ENDD(d0); ENDBOp(); - BOp(traced_call_bfunc_xy, plxys); + BOp(call_bfunc_xy, plxys); EMIT_ENTRY_BLOCK(PREG,CALL_BFUNC_XY_INSTINIT); BEGD(d0); BEGD(d1); @@ -11747,10 +11774,10 @@ S_SREG = RepAppl(d0); d0 = XREG(PREG->y_u.plxys.x); d1 = *pt0; ENDP(pt0); - profiled_deref_head_TEST(d0, traced_call_bfunc_xy_unk); - traced_call_bfunc_xy_nvar: - profiled_deref_head_TEST(d1, traced_call_bfunc_xy2_unk); - traced_call_bfunc_xy2_nvar: + profiled_deref_head_TEST(d0, call_bfunc_xy_unk); + call_bfunc_xy_nvar: + profiled_deref_head_TEST(d1, call_bfunc_xy2_unk); + call_bfunc_xy2_nvar: if (IsIntTerm(d0) && IsIntTerm(d1)) { EMIT_CONDITIONAL_SUCCESS("IsIntTerm(d0) && IsIntTerm(d1)"); EMIT_MULTIPLE_DESTINY_BLOCK_TEST(CALL_BFUNC_XY_CALL_BFUNC_XY2_NVAR_INT); @@ -11784,7 +11811,7 @@ S_SREG = RepAppl(d0); } } } - traced_exec_bin_cmp_xy: + exec_bin_cmp_xy: EMIT_CONDITIONAL_FAIL("IsIntTerm(d0) && IsIntTerm(d1)"); EMIT_MULTIPLE_DESTINY_BLOCK_TEST(CALL_BFUNC_XY_CALL_BFUNC_XY2_NVAR_NOINT); { @@ -11803,22 +11830,22 @@ S_SREG = RepAppl(d0); JMPNext(); BEGP(pt0); - profiled_deref_body(d0, pt0, traced_call_bfunc_xy_unk, traced_call_bfunc_xy_nvar); + profiled_deref_body(d0, pt0, call_bfunc_xy_unk, call_bfunc_xy_nvar); EMIT_SIMPLE_BLOCK_TEST(CALL_BFUNC_XY_CALL_BFUNC_XY_UNK); d1 = Deref(d1); - goto traced_exec_bin_cmp_xy; + goto exec_bin_cmp_xy; ENDP(pt0); BEGP(pt0); - profiled_deref_body(d1, pt0, traced_call_bfunc_xy2_unk, traced_call_bfunc_xy2_nvar); - goto traced_exec_bin_cmp_xy; + profiled_deref_body(d1, pt0, call_bfunc_xy2_unk, call_bfunc_xy2_nvar); + goto exec_bin_cmp_xy; ENDP(pt0); ENDD(d1); ENDD(d0); ENDBOp(); - BOp(traced_call_bfunc_yy, plyys); + BOp(call_bfunc_yy, plyys); EMIT_ENTRY_BLOCK(PREG,CALL_BFUNC_YY_INSTINIT); BEGD(d0); BEGD(d1); @@ -11830,10 +11857,10 @@ S_SREG = RepAppl(d0); d1 = *pt1; ENDP(pt1); ENDP(pt0); - profiled_deref_head_TEST(d0, traced_call_bfunc_yy_unk); - traced_call_bfunc_yy_nvar: - profiled_deref_head_TEST(d1, traced_call_bfunc_yy2_unk); - traced_call_bfunc_yy2_nvar: + profiled_deref_head_TEST(d0, call_bfunc_yy_unk); + call_bfunc_yy_nvar: + profiled_deref_head_TEST(d1, call_bfunc_yy2_unk); + call_bfunc_yy2_nvar: if (IsIntTerm(d0) && IsIntTerm(d1)) { EMIT_CONDITIONAL_SUCCESS("IsIntTerm(d0) && IsIntTerm(d1)"); EMIT_MULTIPLE_DESTINY_BLOCK_TEST(CALL_BFUNC_YY_CALL_BFUNC_YY2_NVAR_INT); @@ -11867,7 +11894,7 @@ S_SREG = RepAppl(d0); } } } - traced_exec_bin_cmp_yy: + exec_bin_cmp_yy: EMIT_CONDITIONAL_FAIL("IsIntTerm(d0) && IsIntTerm(d1)"); EMIT_MULTIPLE_DESTINY_BLOCK_TEST(CALL_BFUNC_YY_CALL_BFUNC_YY2_NVAR_NOINT); { @@ -11886,33 +11913,33 @@ S_SREG = RepAppl(d0); JMPNext(); BEGP(pt0); - profiled_deref_body(d0, pt0, traced_call_bfunc_yy_unk, traced_call_bfunc_yy_nvar); + profiled_deref_body(d0, pt0, call_bfunc_yy_unk, call_bfunc_yy_nvar); EMIT_SIMPLE_BLOCK_TEST(CALL_BFUNC_YY_CALL_BFUNC_YY_UNK); d1 = Deref(d1); - goto traced_exec_bin_cmp_yy; + goto exec_bin_cmp_yy; ENDP(pt0); BEGP(pt0); - profiled_deref_body(d1, pt0, traced_call_bfunc_yy2_unk, traced_call_bfunc_yy2_nvar); - goto traced_exec_bin_cmp_yy; + profiled_deref_body(d1, pt0, call_bfunc_yy2_unk, call_bfunc_yy2_nvar); + goto exec_bin_cmp_yy; ENDP(pt0); ENDD(d1); ENDD(d0); ENDBOp(); - Op(traced_p_equal, e); + Op(p_equal, e); EMIT_ENTRY_BLOCK(PREG,P_EQUAL_INSTINIT); save_hb(); if (Yap_IUnify(ARG1, ARG2) == FALSE) { - TRACED_FAIL(); + FAIL(); } EMIT_SIMPLE_BLOCK(P_EQUAL_END); PREG = NEXTOP(PREG, e); GONext(); ENDOp(); - Op(traced_p_dif, l); + Op(p_dif, l); EMIT_ENTRY_BLOCK(PREG,P_DIF_INSTINIT); #ifdef LOW_LEVEL_TRACER if (Yap_do_low_level_trace) { @@ -11924,13 +11951,13 @@ S_SREG = RepAppl(d0); BEGD(d0); BEGD(d1); d0 = ARG1; - profiled_deref_head_TEST(d0, traced_dif_unk1); - traced_dif_nvar1: + profiled_deref_head_TEST(d0, dif_unk1); + dif_nvar1: /* first argument is bound */ EMIT_SIMPLE_BLOCK_TEST(P_DIF_DIF_NVAR1); d1 = ARG2; - profiled_deref_head_TEST(d1, traced_dif_nvar1_unk2); - traced_dif_nvar1_nvar2: + profiled_deref_head_TEST(d1, dif_nvar1_unk2); + dif_nvar1_nvar2: /* both arguments are bound */ EMIT_MULTIPLE_DESTINY_BLOCK_TEST(P_DIF_DIF_NVAR1_NVAR2); if (d0 == d1) { @@ -12026,7 +12053,7 @@ S_SREG = RepAppl(d0); GONext(); BEGP(pt0); - profiled_deref_body(d0, pt0, traced_dif_unk1, traced_dif_nvar1); + profiled_deref_body(d0, pt0, dif_unk1, dif_nvar1); EMIT_SIMPLE_BLOCK_TEST(P_DIF_DIF_UNK1); ENDP(pt0); /* first argument is unbound */ @@ -12034,7 +12061,7 @@ S_SREG = RepAppl(d0); GONext(); BEGP(pt0); - profiled_deref_body(d1, pt0, traced_dif_nvar1_unk2, traced_dif_nvar1_nvar2); + profiled_deref_body(d1, pt0, dif_nvar1_unk2, dif_nvar1_nvar2); EMIT_SIMPLE_BLOCK_TEST(P_DIF_DIF_NVAR1_UNK2); ENDP(pt0); /* second argument is unbound */ @@ -12044,7 +12071,7 @@ S_SREG = RepAppl(d0); ENDD(d0); ENDOp(); - Op(traced_p_eq, l); + Op(p_eq, l); EMIT_ENTRY_BLOCK(PREG,P_EQ_INSTINIT); #ifdef LOW_LEVEL_TRACER if (Yap_do_low_level_trace) { @@ -12056,13 +12083,13 @@ S_SREG = RepAppl(d0); BEGD(d0); BEGD(d1); d0 = ARG1; - profiled_deref_head_TEST(d0, traced_p_eq_unk1); - traced_p_eq_nvar1: + profiled_deref_head_TEST(d0, p_eq_unk1); + p_eq_nvar1: /* first argument is bound */ EMIT_SIMPLE_BLOCK_TEST(P_EQ_P_EQ_NVAR1); d1 = ARG2; - profiled_deref_head_TEST(d1, traced_p_eq_nvar1_unk2); - traced_p_eq_nvar1_nvar2: + profiled_deref_head_TEST(d1, p_eq_nvar1_unk2); + p_eq_nvar1_nvar2: /* both arguments are bound */ EMIT_MULTIPLE_DESTINY_BLOCK_TEST(P_EQ_P_EQ_NVAR1_NVAR2); if (d0 == d1) { @@ -12166,7 +12193,7 @@ S_SREG = RepAppl(d0); GONext(); BEGP(pt0); - profiled_deref_body(d1, pt0, traced_p_eq_nvar1_unk2, traced_p_eq_nvar1_nvar2); + profiled_deref_body(d1, pt0, p_eq_nvar1_unk2, p_eq_nvar1_nvar2); EMIT_SIMPLE_BLOCK_TEST(P_EQ_P_EQ_NVAR1_UNK2); ENDP(pt0); /* first argument is bound */ @@ -12178,12 +12205,12 @@ S_SREG = RepAppl(d0); ENDD(d1); BEGP(pt0); - profiled_deref_body(d0, pt0, traced_p_eq_unk1, traced_p_eq_nvar1); + profiled_deref_body(d0, pt0, p_eq_unk1, p_eq_nvar1); EMIT_SIMPLE_BLOCK_TEST(P_EQ_P_EQ_UNK1); BEGD(d1); d1 = ARG2; - profiled_deref_head_TEST(d1, traced_p_eq_var1_unk2); - traced_p_eq_var1_nvar2: + profiled_deref_head_TEST(d1, p_eq_var1_unk2); + p_eq_var1_nvar2: /* I don't need to worry about co-routining because an unbound variable may never be == to a constrained variable!! */ EMIT_SIMPLE_BLOCK_TEST(P_EQ_P_EQ_VAR1_NVAR2); @@ -12191,7 +12218,7 @@ S_SREG = RepAppl(d0); GONext(); BEGP(pt1); - profiled_deref_body(d1, pt1, traced_p_eq_var1_unk2, traced_p_eq_var1_nvar2); + profiled_deref_body(d1, pt1, p_eq_var1_unk2, p_eq_var1_nvar2); /* first argument is unbound */ /* second argument is unbound */ EMIT_MULTIPLE_DESTINY_BLOCK_TEST(P_EQ_P_EQ_VAR1_UNK2_END); @@ -12208,7 +12235,7 @@ S_SREG = RepAppl(d0); ENDD(d0); ENDOp(); - Op(traced_p_arg_vv, xxx); + Op(p_arg_vv, xxx); EMIT_ENTRY_BLOCK(PREG,P_ARG_VV_INSTINIT); #ifdef LOW_LEVEL_TRACER if (Yap_do_low_level_trace) { @@ -12222,8 +12249,8 @@ S_SREG = RepAppl(d0); EMIT_SIMPLE_BLOCK_TEST(P_ARG_VV_TEST_D0); BEGD(d0); d0 = XREG(PREG->y_u.xxx.x1); - profiled_deref_head_TEST(d0, traced_arg_arg1_unk); - traced_arg_arg1_nvar: + profiled_deref_head_TEST(d0, arg_arg1_unk); + arg_arg1_nvar: /* ARG1 is ok! */ EMIT_SIMPLE_BLOCK_TEST(P_ARG_VV_ARG_ARG1_NVAR); if (IsIntTerm(d0)) { @@ -12234,15 +12261,15 @@ S_SREG = RepAppl(d0); saveregs(); Yap_Error(TYPE_ERROR_INTEGER,d0,"arg 1 of arg/3"); setregs(); - TRACED_FAIL(); + FAIL(); } /* d0 now got the argument we want */ EMIT_SIMPLE_BLOCK_TEST(P_ARG_VV_TEST_D1); BEGD(d1); d1 = XREG(PREG->y_u.xxx.x2); - profiled_deref_head_TEST(d1, traced_arg_arg2_unk); - traced_arg_arg2_nvar: + profiled_deref_head_TEST(d1, arg_arg2_unk); + arg_arg2_nvar: /* d1 now got the structure we want to fetch the argument * from */ EMIT_MULTIPLE_DESTINY_BLOCK_TEST(P_ARG_VV_ARG_ARG2_NVAR); @@ -12251,7 +12278,7 @@ S_SREG = RepAppl(d0); pt0 = RepAppl(d1); d1 = *pt0; if (IsExtensionFunctor((Functor) d1)) { - TRACED_FAIL(); + FAIL(); } if ((Int)d0 <= 0 || (Int)d0 > ArityOfFunctor((Functor) d1)) { @@ -12263,7 +12290,7 @@ S_SREG = RepAppl(d0); setregs(); } */ - TRACED_FAIL(); + FAIL(); } XREG(PREG->y_u.xxx.x) = pt0[d0]; PREG = NEXTOP(PREG, xxx); @@ -12280,7 +12307,7 @@ S_SREG = RepAppl(d0); MkIntegerTerm(d0),"arg 1 of arg/3"); setregs(); } - TRACED_FAIL(); + FAIL(); } XREG(PREG->y_u.xxx.x) = pt0[d0-1]; PREG = NEXTOP(PREG, xxx); @@ -12294,31 +12321,31 @@ S_SREG = RepAppl(d0); Yap_Error(TYPE_ERROR_COMPOUND, d1, "arg 2 of arg/3"); setregs(); */ - TRACED_FAIL(); + FAIL(); } BEGP(pt0); - profiled_deref_body(d1, pt0, traced_arg_arg2_unk, traced_arg_arg2_nvar); + profiled_deref_body(d1, pt0, arg_arg2_unk, arg_arg2_nvar); EMIT_SIMPLE_BLOCK_TEST(P_ARG_VV_ARG_ARG2_UNK); saveregs(); Yap_Error(INSTANTIATION_ERROR, d1,"arg 2 of arg/3");; setregs(); ENDP(pt0); - TRACED_FAIL(); + FAIL(); ENDD(d1); BEGP(pt0); - profiled_deref_body(d0, pt0, traced_arg_arg1_unk, traced_arg_arg1_nvar); + profiled_deref_body(d0, pt0, arg_arg1_unk, arg_arg1_nvar); EMIT_SIMPLE_BLOCK_TEST(P_ARG_VV_ARG_ARG1_UNK); saveregs(); Yap_Error(INSTANTIATION_ERROR, d0, "arg 1 of arg/3");; setregs(); ENDP(pt0); - TRACED_FAIL(); + FAIL(); ENDD(d0); ENDOp(); - Op(traced_p_arg_cv, xxn); + Op(p_arg_cv, xxn); EMIT_ENTRY_BLOCK(PREG,P_ARG_CV_INSTINIT); #ifdef LOW_LEVEL_TRACER if (Yap_do_low_level_trace) { @@ -12338,8 +12365,8 @@ S_SREG = RepAppl(d0); /* d0 now got the argument we want */ BEGD(d1); d1 = XREG(PREG->y_u.xxn.xi); - profiled_deref_head_TEST(d1, traced_arg_arg2_vc_unk); - traced_arg_arg2_vc_nvar: + profiled_deref_head_TEST(d1, arg_arg2_vc_unk); + arg_arg2_vc_nvar: EMIT_MULTIPLE_DESTINY_BLOCK_TEST(P_ARG_CV_ARG_ARG2_VC_NVAR); /* d1 now got the structure we want to fetch the argument * from */ @@ -12348,7 +12375,7 @@ S_SREG = RepAppl(d0); pt0 = RepAppl(d1); d1 = *pt0; if (IsExtensionFunctor((Functor) d1)) { - TRACED_FAIL(); + FAIL(); } if ((Int)d0 <= 0 || (Int)d0 > ArityOfFunctor((Functor) d1)) { @@ -12360,7 +12387,7 @@ S_SREG = RepAppl(d0); setregs(); } */ - TRACED_FAIL(); + FAIL(); } XREG(PREG->y_u.xxn.x) = pt0[d0]; PREG = NEXTOP(PREG, xxn); @@ -12377,7 +12404,7 @@ S_SREG = RepAppl(d0); MkIntegerTerm(d0),"arg 1 of arg/3"); setregs(); } - TRACED_FAIL(); + FAIL(); } XREG(PREG->y_u.xxn.x) = pt0[d0-1]; PREG = NEXTOP(PREG, xxn); @@ -12391,23 +12418,23 @@ S_SREG = RepAppl(d0); Yap_Error(TYPE_ERROR_COMPOUND, d1, "arg 2 of arg/3"); setregs(); */ - TRACED_FAIL(); + FAIL(); } BEGP(pt0); - profiled_deref_body(d1, pt0, traced_arg_arg2_vc_unk, traced_arg_arg2_vc_nvar); + profiled_deref_body(d1, pt0, arg_arg2_vc_unk, arg_arg2_vc_nvar); EMIT_SIMPLE_BLOCK_TEST(P_ARG_CV_ARG_ARG2_VC_UNK); saveregs(); Yap_Error(INSTANTIATION_ERROR, d1,"arg 2 of arg/3");; setregs(); ENDP(pt0); - TRACED_FAIL(); + FAIL(); ENDD(d1); ENDD(d0); ENDOp(); - Op(traced_p_arg_y_vv, yxx); + Op(p_arg_y_vv, yxx); EMIT_ENTRY_BLOCK(PREG,P_ARG_Y_VV_INSTINIT); #ifdef LOW_LEVEL_TRACER if (Yap_do_low_level_trace) { @@ -12422,8 +12449,8 @@ S_SREG = RepAppl(d0); EMIT_SIMPLE_BLOCK_TEST(P_ARG_Y_VV_TEST_D0); BEGD(d0); d0 = XREG(PREG->y_u.yxx.x1); - profiled_deref_head_TEST(d0, traced_arg_y_arg1_unk); - traced_arg_y_arg1_nvar: + profiled_deref_head_TEST(d0, arg_y_arg1_unk); + arg_y_arg1_nvar: EMIT_SIMPLE_BLOCK_TEST(P_ARG_Y_VV_ARG_Y_ARG1_NVAR); /* ARG1 is ok! */ if (IsIntTerm(d0)) { @@ -12434,15 +12461,15 @@ S_SREG = RepAppl(d0); saveregs(); Yap_Error(TYPE_ERROR_INTEGER,d0,"arg 1 of arg/3"); setregs(); - TRACED_FAIL(); + FAIL(); } /* d0 now got the argument we want */ EMIT_SIMPLE_BLOCK_TEST(P_ARG_Y_VV_TEST_D1); BEGD(d1); d1 = XREG(PREG->y_u.yxx.x2); - profiled_deref_head_TEST(d1, traced_arg_y_arg2_unk); - traced_arg_y_arg2_nvar: + profiled_deref_head_TEST(d1, arg_y_arg2_unk); + arg_y_arg2_nvar: /* d1 now got the structure we want to fetch the argument * from */ EMIT_MULTIPLE_DESTINY_BLOCK_TEST(P_ARG_Y_VV_ARG_Y_ARG2_NVAR); @@ -12451,7 +12478,7 @@ S_SREG = RepAppl(d0); pt0 = RepAppl(d1); d1 = *pt0; if (IsExtensionFunctor((Functor) d1)) { - TRACED_FAIL(); + FAIL(); } if ((Int)d0 <= 0 || (Int)d0 > ArityOfFunctor((Functor) d1)) { @@ -12463,7 +12490,7 @@ S_SREG = RepAppl(d0); saveregs(); } */ - TRACED_FAIL(); + FAIL(); } BEGP(pt1); pt1 = YREG + PREG->y_u.yxx.y; @@ -12483,7 +12510,7 @@ S_SREG = RepAppl(d0); MkIntegerTerm(d0),"arg 1 of arg/3"); setregs(); } - TRACED_FAIL(); + FAIL(); } BEGP(pt1); pt1 = YREG + PREG->y_u.yxx.y; @@ -12500,31 +12527,31 @@ S_SREG = RepAppl(d0); Yap_Error(TYPE_ERROR_COMPOUND, d1, "arg 2 of arg/3"); setregs(); */ - TRACED_FAIL(); + FAIL(); } BEGP(pt0); - profiled_deref_body(d1, pt0, traced_arg_y_arg2_unk, traced_arg_y_arg2_nvar); + profiled_deref_body(d1, pt0, arg_y_arg2_unk, arg_y_arg2_nvar); EMIT_SIMPLE_BLOCK_TEST(P_ARG_Y_VV_ARG_Y_ARG2_UNK); saveregs(); Yap_Error(INSTANTIATION_ERROR, d1,"arg 2 of arg/3");; setregs(); ENDP(pt0); - TRACED_FAIL(); + FAIL(); ENDD(d1); BEGP(pt0); - profiled_deref_body(d0, pt0, traced_arg_y_arg1_unk, traced_arg_y_arg1_nvar); + profiled_deref_body(d0, pt0, arg_y_arg1_unk, arg_y_arg1_nvar); EMIT_SIMPLE_BLOCK_TEST(P_ARG_Y_VV_ARG_Y_ARG1_UNK); saveregs(); Yap_Error(INSTANTIATION_ERROR, d0, "arg 1 of arg/3"); setregs(); ENDP(pt0); - TRACED_FAIL(); + FAIL(); ENDD(d0); ENDOp(); - Op(traced_p_arg_y_cv, yxn); + Op(p_arg_y_cv, yxn); ///#ifdef PROFILED_ABSMI EMIT_ENTRY_BLOCK(PREG,P_ARG_Y_CV_INSTINIT); ///#endif @@ -12551,8 +12578,8 @@ S_SREG = RepAppl(d0); /* d0 now got the argument we want */ BEGD(d1); d1 = XREG(PREG->y_u.yxn.xi); - deref_head(d1, traced_arg_y_arg2_vc_unk); - traced_arg_y_arg2_vc_nvar: + deref_head(d1, arg_y_arg2_vc_unk); + arg_y_arg2_vc_nvar: /* d1 now got the structure we want to fetch the argument * from */ if (IsApplTerm(d1)) { @@ -12563,7 +12590,7 @@ S_SREG = RepAppl(d0); pt0 = RepAppl(d1); d1 = *pt0; if (IsExtensionFunctor((Functor) d1)) { - TRACED_FAIL(); + FAIL(); } if ((Int)d0 <= 0 || (Int)d0 > ArityOfFunctor((Functor) d1)) { @@ -12575,7 +12602,7 @@ S_SREG = RepAppl(d0); setregs(); } */ - TRACED_FAIL(); + FAIL(); } ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(P_ARG_Y_CV_D1APPL_END); @@ -12604,7 +12631,7 @@ S_SREG = RepAppl(d0); MkIntegerTerm(d0),"arg 1 of arg/3"); setregs(); } - TRACED_FAIL(); + FAIL(); } ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(P_ARG_Y_CV_D1PAIR_END); @@ -12624,11 +12651,11 @@ S_SREG = RepAppl(d0); Yap_Error(TYPE_ERROR_COMPOUND, d1, "arg 2 of arg/3"); setregs(); */ - TRACED_FAIL(); + FAIL(); } BEGP(pt0); - deref_body(d1, pt0, traced_arg_y_arg2_vc_unk, traced_arg_y_arg2_vc_nvar); + deref_body(d1, pt0, arg_y_arg2_vc_unk, arg_y_arg2_vc_nvar); ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(P_ARG_Y_CV_ARG_Y_ARG2_VC_UNK); ///#endif @@ -12636,18 +12663,18 @@ S_SREG = RepAppl(d0); Yap_Error(INSTANTIATION_ERROR, d1,"arg 2 of arg/3");; setregs(); ENDP(pt0); - TRACED_FAIL(); + FAIL(); ENDD(d1); ENDD(d0); ENDOp(); - Op(traced_p_func2s_vv, xxx); + Op(p_func2s_vv, xxx); /* A1 is a variable */ ///#ifdef PROFILED_ABSMI EMIT_ENTRY_BLOCK(PREG,P_FUNC2S_VV_INSTINIT); ///#endif - traced_restart_func2s: + restart_func2s: #ifdef LOW_LEVEL_TRACER if (Yap_do_low_level_trace) { ///#ifdef PROFILED_ABSMI @@ -12665,16 +12692,16 @@ S_SREG = RepAppl(d0); ///#endif BEGD(d0); d0 = XREG(PREG->y_u.xxx.x1); - deref_head(d0, traced_func2s_unk); - traced_func2s_nvar: + deref_head(d0, func2s_unk); + func2s_nvar: /* we do, let's get the third argument */ ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(P_FUNC2S_VV_TEST_D1); ///#endif BEGD(d1); d1 = XREG(PREG->y_u.xxx.x2); - deref_head(d1, traced_func2s_unk2); - traced_func2s_nvar2: + deref_head(d1, func2s_unk2); + func2s_nvar2: /* Uuuff, the second and third argument are bound */ if (IsIntegerTerm(d1)) { ///#ifdef PROFILED_ABSMI @@ -12701,7 +12728,7 @@ S_SREG = RepAppl(d0); EMIT_SIMPLE_BLOCK(P_FUNC2S_VV_D1NOTINT_END); ///#endif setregs(); - TRACED_FAIL(); + FAIL(); } if (!IsAtomicTerm(d0)) { ///#ifdef PROFILED_ABSMI @@ -12710,7 +12737,7 @@ S_SREG = RepAppl(d0); saveregs(); Yap_Error(TYPE_ERROR_ATOM,d0,"functor/3"); setregs(); - TRACED_FAIL(); + FAIL(); } /* We made it!!!!! we got in d0 the name, in d1 the arity and * in pt0 the variable to bind it to. */ @@ -12737,11 +12764,11 @@ S_SREG = RepAppl(d0); saveregs(); Yap_Error(TYPE_ERROR_ATOM,d0,"functor/3"); setregs(); - TRACED_FAIL(); + FAIL(); } BEGP(pt1); if (!IsAtomTerm(d0)) { - TRACED_FAIL(); + FAIL(); } else { ///#ifdef PROFILED_ABSMI @@ -12774,7 +12801,7 @@ S_SREG = RepAppl(d0); ///#endif setregs(); } - goto traced_restart_func2s; + goto restart_func2s; } while ((Int)d1--) { ///#ifdef PROFILED_ABSMI @@ -12808,11 +12835,11 @@ S_SREG = RepAppl(d0); saveregs(); Yap_Error(DOMAIN_ERROR_NOT_LESS_THAN_ZERO,MkIntegerTerm(d1),"functor/3"); setregs(); - TRACED_FAIL(); + FAIL(); } BEGP(pt1); - deref_body(d1, pt1, traced_func2s_unk2, traced_func2s_nvar2); + deref_body(d1, pt1, func2s_unk2, func2s_nvar2); ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(P_FUNC2S_VV_FUNC2S_UNK2); ///#endif @@ -12821,11 +12848,11 @@ S_SREG = RepAppl(d0); setregs(); ENDP(pt1); /* Oops, third argument was unbound */ - TRACED_FAIL(); + FAIL(); ENDD(d1); BEGP(pt1); - deref_body(d0, pt1, traced_func2s_unk, traced_func2s_nvar); + deref_body(d0, pt1, func2s_unk, func2s_nvar); ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(P_FUNC2S_VV_FUNC2S_UNK); ///#endif @@ -12834,16 +12861,16 @@ S_SREG = RepAppl(d0); setregs(); ENDP(pt1); /* Oops, second argument was unbound too */ - TRACED_FAIL(); + FAIL(); ENDD(d0); ENDOp(); - Op(traced_p_func2s_cv, xxc); + Op(p_func2s_cv, xxc); /* A1 is a variable */ ///#ifdef PROFILED_ABSMI EMIT_ENTRY_BLOCK(PREG,P_FUNC2S_CV_INSTINIT); ///#endif - traced_restart_func2s_cv: + restart_func2s_cv: #ifdef LOW_LEVEL_TRACER if (Yap_do_low_level_trace) { ///#ifdef PROFILED_ABSMI @@ -12864,8 +12891,8 @@ S_SREG = RepAppl(d0); /* we do, let's get the third argument */ BEGD(d1); d1 = XREG(PREG->y_u.xxc.xi); - deref_head(d1, traced_func2s_unk2_cv); - traced_func2s_nvar2_cv: + deref_head(d1, func2s_unk2_cv); + func2s_nvar2_cv: /* Uuuff, the second and third argument are bound */ if (IsIntegerTerm(d1)) { ///#ifdef PROFILED_ABSMI @@ -12892,7 +12919,7 @@ S_SREG = RepAppl(d0); EMIT_SIMPLE_BLOCK(P_FUNC2S_CV_POST_IF); ///#endif setregs(); - TRACED_FAIL(); + FAIL(); } /* We made it!!!!! we got in d0 the name, in d1 the arity and * in pt0 the variable to bind it to. */ @@ -12918,11 +12945,11 @@ S_SREG = RepAppl(d0); saveregs(); Yap_Error(TYPE_ERROR_ATOM,d0,"functor/3"); setregs(); - TRACED_FAIL(); + FAIL(); } BEGP(pt1); if (!IsAtomTerm(d0)) { - TRACED_FAIL(); + FAIL(); } else { ///#ifdef PROFILED_ABSMI @@ -12955,7 +12982,7 @@ S_SREG = RepAppl(d0); ///#endif setregs(); } - goto traced_restart_func2s_cv; + goto restart_func2s_cv; } while ((Int)d1--) { ///#ifdef PROFILED_ABSMI @@ -12989,11 +13016,11 @@ S_SREG = RepAppl(d0); saveregs(); Yap_Error(DOMAIN_ERROR_NOT_LESS_THAN_ZERO,MkIntegerTerm(d1),"functor/3"); setregs(); - TRACED_FAIL(); + FAIL(); } BEGP(pt1); - deref_body(d1, pt1, traced_func2s_unk2_cv, traced_func2s_nvar2_cv); + deref_body(d1, pt1, func2s_unk2_cv, func2s_nvar2_cv); ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(P_FUNC2S_CV_END); ///#endif @@ -13002,17 +13029,17 @@ S_SREG = RepAppl(d0); setregs(); ENDP(pt1); /* Oops, third argument was unbound */ - TRACED_FAIL(); + FAIL(); ENDD(d1); ENDD(d0); ENDOp(); - Op(traced_p_func2s_vc, xxn); + Op(p_func2s_vc, xxn); /* A1 is a variable */ ///#ifdef PROFILED_ABSMI EMIT_ENTRY_BLOCK(PREG,P_FUNC2S_VC_INSTINIT); ///#endif - traced_restart_func2s_vc: + restart_func2s_vc: #ifdef LOW_LEVEL_TRACER if (Yap_do_low_level_trace) { ///#ifdef PROFILED_ABSMI @@ -13035,8 +13062,8 @@ S_SREG = RepAppl(d0); ///#endif BEGD(d0); d0 = XREG(PREG->y_u.xxn.xi); - deref_head(d0, traced_func2s_unk_vc); - traced_func2s_nvar_vc: + deref_head(d0, func2s_unk_vc); + func2s_nvar_vc: ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(P_FUNC2S_VC_FUNC2S_NVAR_VC); ///#endif @@ -13049,7 +13076,7 @@ S_SREG = RepAppl(d0); saveregs(); Yap_Error(TYPE_ERROR_ATOM,d0,"functor/3"); setregs(); - TRACED_FAIL(); + FAIL(); } /* We made it!!!!! we got in d0 the name, in d1 the arity and * in pt0 the variable to bind it to. */ @@ -13083,11 +13110,11 @@ S_SREG = RepAppl(d0); saveregs(); Yap_Error(TYPE_ERROR_ATOM,d0,"functor/3"); setregs(); - TRACED_FAIL(); + FAIL(); } BEGP(pt1); if (!IsAtomTerm(d0)) { - TRACED_FAIL(); + FAIL(); } else { ///#ifdef PROFILED_ABSMI @@ -13120,7 +13147,7 @@ S_SREG = RepAppl(d0); ///#endif setregs(); } - goto traced_restart_func2s_vc; + goto restart_func2s_vc; } while ((Int)d1--) { ///#ifdef PROFILED_ABSMI @@ -13143,7 +13170,7 @@ S_SREG = RepAppl(d0); GONext(); BEGP(pt1); - deref_body(d0, pt1, traced_func2s_unk_vc, traced_func2s_nvar_vc); + deref_body(d0, pt1, func2s_unk_vc, func2s_nvar_vc); ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(P_FUNC2S_VC_END2); ///#endif @@ -13152,16 +13179,16 @@ S_SREG = RepAppl(d0); setregs(); ENDP(pt1); /* Oops, second argument was unbound too */ - TRACED_FAIL(); + FAIL(); ENDD(d0); ENDOp(); - Op(traced_p_func2s_y_vv, yxx); + Op(p_func2s_y_vv, yxx); /* A1 is a variable */ ///#ifdef PROFILED_ABSMI EMIT_ENTRY_BLOCK(PREG,P_FUNC2S_Y_VV_INSTINIT); ///#endif - traced_restart_func2s_y: + restart_func2s_y: #ifdef LOW_LEVEL_TRACER if (Yap_do_low_level_trace) { ///#ifdef PROFILED_ABSMI @@ -13179,16 +13206,16 @@ S_SREG = RepAppl(d0); ///#endif BEGD(d0); d0 = XREG(PREG->y_u.yxx.x1); - deref_head(d0, traced_func2s_y_unk); - traced_func2s_y_nvar: + deref_head(d0, func2s_y_unk); + func2s_y_nvar: /* we do, let's get the third argument */ ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(P_FUNC2S_Y_VV_TEST_D1); ///#endif BEGD(d1); d1 = XREG(PREG->y_u.yxx.x2); - deref_head(d1, traced_func2s_y_unk2); - traced_func2s_y_nvar2: + deref_head(d1, func2s_y_unk2); + func2s_y_nvar2: /* Uuuff, the second and third argument are bound */ if (IsIntegerTerm(d1)) { ///#ifdef PROFILED_ABSMI @@ -13215,7 +13242,7 @@ S_SREG = RepAppl(d0); EMIT_SIMPLE_BLOCK(P_FUNC2S_Y_VV_POST_IF); ///#endif setregs(); - TRACED_FAIL(); + FAIL(); } if (!IsAtomicTerm(d0)) { ///#ifdef PROFILED_ABSMI @@ -13224,7 +13251,7 @@ S_SREG = RepAppl(d0); saveregs(); Yap_Error(TYPE_ERROR_ATOM,d0,"functor/3"); setregs(); - TRACED_FAIL(); + FAIL(); } /* We made it!!!!! we got in d0 the name, in d1 the arity and * in pt0 the variable to bind it to. */ @@ -13251,11 +13278,11 @@ S_SREG = RepAppl(d0); saveregs(); Yap_Error(TYPE_ERROR_ATOM,d0,"functor/3"); setregs(); - TRACED_FAIL(); + FAIL(); } BEGP(pt1); if (!IsAtomTerm(d0)) { - TRACED_FAIL(); + FAIL(); } else { ///#ifdef PROFILED_ABSMI @@ -13288,7 +13315,7 @@ S_SREG = RepAppl(d0); ///#endif setregs(); } - goto traced_restart_func2s_y; + goto restart_func2s_y; } while ((Int)d1--) { ///#ifdef PROFILED_ABSMI @@ -13328,11 +13355,11 @@ S_SREG = RepAppl(d0); saveregs(); Yap_Error(DOMAIN_ERROR_NOT_LESS_THAN_ZERO,MkIntegerTerm(d1),"functor/3"); setregs(); - TRACED_FAIL(); + FAIL(); } BEGP(pt1); - deref_body(d1, pt1, traced_func2s_y_unk2, traced_func2s_y_nvar2); + deref_body(d1, pt1, func2s_y_unk2, func2s_y_nvar2); ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(P_FUNC2S_Y_VV_END1); ///#endif @@ -13341,11 +13368,11 @@ S_SREG = RepAppl(d0); setregs(); ENDP(pt1); /* Oops, third argument was unbound */ - TRACED_FAIL(); + FAIL(); ENDD(d1); BEGP(pt1); - deref_body(d0, pt1, traced_func2s_y_unk, traced_func2s_y_nvar); + deref_body(d0, pt1, func2s_y_unk, func2s_y_nvar); ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(P_FUNC2S_Y_VV_END2); ///#endif @@ -13354,16 +13381,16 @@ S_SREG = RepAppl(d0); setregs(); ENDP(pt1); /* Oops, second argument was unbound too */ - TRACED_FAIL(); + FAIL(); ENDD(d0); ENDOp(); - Op(traced_p_func2s_y_cv, yxn); + Op(p_func2s_y_cv, yxn); /* A1 is a variable */ ///#ifdef PROFILED_ABSMI EMIT_ENTRY_BLOCK(PREG,P_FUNC2S_Y_CV_INSTINIT); ///#endif - traced_restart_func2s_y_cv: + restart_func2s_y_cv: #ifdef LOW_LEVEL_TRACER if (Yap_do_low_level_trace) { ///#ifdef PROFILED_ABSMI @@ -13384,8 +13411,8 @@ S_SREG = RepAppl(d0); /* we do, let's get the third argument */ BEGD(d1); d1 = XREG(PREG->y_u.yxn.xi); - deref_head(d1, traced_func2s_y_unk_cv); - traced_func2s_y_nvar_cv: + deref_head(d1, func2s_y_unk_cv); + func2s_y_nvar_cv: /* Uuuff, the second and third argument are bound */ if (IsIntegerTerm(d1)) { ///#ifdef PROFILED_ABSMI @@ -13412,7 +13439,7 @@ S_SREG = RepAppl(d0); EMIT_SIMPLE_BLOCK(P_FUNC2S_Y_CV_POST_IF); ///#endif setregs(); - TRACED_FAIL(); + FAIL(); } /* We made it!!!!! we got in d0 the name, in d1 the arity and * in pt0 the variable to bind it to. */ @@ -13442,10 +13469,10 @@ S_SREG = RepAppl(d0); saveregs(); Yap_Error(TYPE_ERROR_ATOM,d0,"functor/3"); setregs(); - TRACED_FAIL(); + FAIL(); } if (!IsAtomTerm(d0)) { - TRACED_FAIL(); + FAIL(); } else { ///#ifdef PROFILED_ABSMI @@ -13479,7 +13506,7 @@ S_SREG = RepAppl(d0); ///#endif setregs(); } - goto traced_restart_func2s_y_cv; + goto restart_func2s_y_cv; } while ((Int)d1--) { ///#ifdef PROFILED_ABSMI @@ -13519,11 +13546,11 @@ S_SREG = RepAppl(d0); saveregs(); Yap_Error(DOMAIN_ERROR_NOT_LESS_THAN_ZERO,MkIntegerTerm(d1),"functor/3"); setregs(); - TRACED_FAIL(); + FAIL(); } BEGP(pt1); - deref_body(d1, pt1, traced_func2s_y_unk_cv, traced_func2s_y_nvar_cv); + deref_body(d1, pt1, func2s_y_unk_cv, func2s_y_nvar_cv); ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(P_FUNC2S_Y_CV_END); ///#endif @@ -13532,17 +13559,17 @@ S_SREG = RepAppl(d0); setregs(); ENDP(pt1); /* Oops, third argument was unbound */ - TRACED_FAIL(); + FAIL(); ENDD(d1); ENDD(d0); ENDOp(); - Op(traced_p_func2s_y_vc, yxn); + Op(p_func2s_y_vc, yxn); /* A1 is a variable */ ///#ifdef PROFILED_ABSMI EMIT_ENTRY_BLOCK(PREG,P_FUNC2S_Y_VC_INSTINIT); ///#endif - traced_restart_func2s_y_vc: + restart_func2s_y_vc: #ifdef LOW_LEVEL_TRACER if (Yap_do_low_level_trace) { ///#ifdef PROFILED_ABSMI @@ -13565,8 +13592,8 @@ S_SREG = RepAppl(d0); ///#endif BEGD(d0); d0 = XREG(PREG->y_u.yxn.xi); - deref_head(d0, traced_func2s_y_unk_vc); - traced_func2s_y_nvar_vc: + deref_head(d0, func2s_y_unk_vc); + func2s_y_nvar_vc: ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(P_FUNC2S_Y_VC_FUNC2S_Y_NVAR_VC); ///#endif @@ -13579,7 +13606,7 @@ S_SREG = RepAppl(d0); saveregs(); Yap_Error(TYPE_ERROR_ATOM,d0,"functor/3"); setregs(); - TRACED_FAIL(); + FAIL(); } /* We made it!!!!! we got in d0 the name, in d1 the arity and * in pt0 the variable to bind it to. */ @@ -13618,7 +13645,7 @@ S_SREG = RepAppl(d0); saveregs(); Yap_Error(TYPE_ERROR_ATOM,d0,"functor/3"); setregs(); - TRACED_FAIL(); + FAIL(); } /* now let's build a compound term */ if (!IsAtomTerm(d0)) { @@ -13628,11 +13655,11 @@ S_SREG = RepAppl(d0); saveregs(); Yap_Error(TYPE_ERROR_ATOM,d0,"functor/3"); setregs(); - TRACED_FAIL(); + FAIL(); } BEGP(pt1); if (!IsAtomTerm(d0)) { - TRACED_FAIL(); + FAIL(); } else { ///#ifdef PROFILED_ABSMI @@ -13665,7 +13692,7 @@ S_SREG = RepAppl(d0); ///#endif setregs(); } - goto traced_restart_func2s_y_vc; + goto restart_func2s_y_vc; } while ((Int)d1--) { ///#ifdef PROFILED_ABSMI @@ -13691,7 +13718,7 @@ S_SREG = RepAppl(d0); GONext(); BEGP(pt1); - deref_body(d0, pt1, traced_func2s_y_unk_vc, traced_func2s_y_nvar_vc); + deref_body(d0, pt1, func2s_y_unk_vc, func2s_y_nvar_vc); ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(P_FUNC2S_Y_VC_END2); ///#endif @@ -13700,11 +13727,11 @@ S_SREG = RepAppl(d0); setregs(); ENDP(pt1); /* Oops, second argument was unbound too */ - TRACED_FAIL(); + FAIL(); ENDD(d0); ENDOp(); - Op(traced_p_func2f_xx, xxx); + Op(p_func2f_xx, xxx); ///#ifdef PROFILED_ABSMI EMIT_ENTRY_BLOCK(PREG,P_FUNC2F_XX_INSTINIT); ///#endif @@ -13724,8 +13751,8 @@ S_SREG = RepAppl(d0); ///#endif BEGD(d0); d0 = XREG(PREG->y_u.xxx.x); - deref_head(d0, traced_func2f_xx_unk); - traced_func2f_xx_nvar: + deref_head(d0, func2f_xx_unk); + func2f_xx_nvar: if (IsApplTerm(d0)) { ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(P_FUNC2F_XX_D0APPL); @@ -13766,7 +13793,7 @@ S_SREG = RepAppl(d0); } BEGP(pt1); - deref_body(d0, pt1, traced_func2f_xx_unk, traced_func2f_xx_nvar); + deref_body(d0, pt1, func2f_xx_unk, func2f_xx_nvar); ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(P_FUNC2F_XX_END); ///#endif @@ -13775,11 +13802,11 @@ S_SREG = RepAppl(d0); setregs(); ENDP(pt1); /* Oops, second argument was unbound too */ - TRACED_FAIL(); + FAIL(); ENDD(d0); ENDOp(); - Op(traced_p_func2f_xy, xxy); + Op(p_func2f_xy, xxy); ///#ifdef PROFILED_ABSMI EMIT_ENTRY_BLOCK(PREG,P_FUNC2F_XY_INSTINIT); ///#endif @@ -13799,8 +13826,8 @@ S_SREG = RepAppl(d0); ///#endif BEGD(d0); d0 = XREG(PREG->y_u.xxy.x); - deref_head(d0, traced_func2f_xy_unk); - traced_func2f_xy_nvar: + deref_head(d0, func2f_xy_unk); + func2f_xy_nvar: if (IsApplTerm(d0)) { ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(P_FUNC2F_XY_D0APPL); @@ -13844,7 +13871,7 @@ S_SREG = RepAppl(d0); } BEGP(pt1); - deref_body(d0, pt1, traced_func2f_xy_unk, traced_func2f_xy_nvar); + deref_body(d0, pt1, func2f_xy_unk, func2f_xy_nvar); ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(P_FUNC2F_XY_END); ///#endif @@ -13853,11 +13880,11 @@ S_SREG = RepAppl(d0); setregs(); ENDP(pt1); /* Oops, second argument was unbound too */ - TRACED_FAIL(); + FAIL(); ENDD(d0); ENDOp(); - Op(traced_p_func2f_yx, yxx); + Op(p_func2f_yx, yxx); ///#ifdef PROFILED_ABSMI EMIT_ENTRY_BLOCK(PREG,P_FUNC2F_YX_INSTINIT); ///#endif @@ -13877,8 +13904,8 @@ S_SREG = RepAppl(d0); ///#endif BEGD(d0); d0 = XREG(PREG->y_u.yxx.x2); - deref_head(d0, traced_func2f_yx_unk); - traced_func2f_yx_nvar: + deref_head(d0, func2f_yx_unk); + func2f_yx_nvar: if (IsApplTerm(d0)) { ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(P_FUNC2F_YX_D0APPL); @@ -13922,7 +13949,7 @@ S_SREG = RepAppl(d0); } BEGP(pt1); - deref_body(d0, pt1, traced_func2f_yx_unk, traced_func2f_yx_nvar); + deref_body(d0, pt1, func2f_yx_unk, func2f_yx_nvar); ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(P_FUNC2F_YX_END); ///#endif @@ -13931,11 +13958,11 @@ S_SREG = RepAppl(d0); setregs(); ENDP(pt1); /* Oops, second argument was unbound too */ - TRACED_FAIL(); + FAIL(); ENDD(d0); ENDOp(); - Op(traced_p_func2f_yy, yyx); + Op(p_func2f_yy, yyx); ///#ifdef PROFILED_ABSMI EMIT_ENTRY_BLOCK(PREG,P_FUNC2F_YY_INSTINIT); ///#endif @@ -13955,8 +13982,8 @@ S_SREG = RepAppl(d0); ///#endif BEGD(d0); d0 = XREG(PREG->y_u.yyx.x); - deref_head(d0, traced_func2f_yy_unk); - traced_func2f_yy_nvar: + deref_head(d0, func2f_yy_unk); + func2f_yy_nvar: if (IsApplTerm(d0)) { ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(P_FUNC2F_YY_D0APPL); @@ -14003,7 +14030,7 @@ S_SREG = RepAppl(d0); } BEGP(pt1); - deref_body(d0, pt1, traced_func2f_yy_unk, traced_func2f_yy_nvar); + deref_body(d0, pt1, func2f_yy_unk, func2f_yy_nvar); ///#ifdef PROFILED_ABSMI EMIT_SIMPLE_BLOCK(P_FUNC2F_YY_END); ///#endif @@ -14012,22 +14039,22 @@ S_SREG = RepAppl(d0); setregs(); ENDP(pt1); /* Oops, second argument was unbound too */ - TRACED_FAIL(); + FAIL(); ENDD(d0); ENDOp(); - Op(traced_p_functor, e); + Op(p_functor, e); EMIT_ENTRY_BLOCK(PREG,P_FUNCTOR_INSTINIT); EMIT_MULTIPLE_DESTINY_BLOCK_TEST(P_FUNCTOR_END); #ifdef LOW_LEVEL_TRACER if (Yap_do_low_level_trace) low_level_trace(enter_pred,RepPredProp(Yap_GetPredPropByFunc(FunctorFunctor,0)),XREGS+1); #endif /* LOW_LEVEL_TRACE */ - traced_restart_functor: + restart_functor: BEGD(d0); d0 = ARG1; - deref_head(d0, traced_func_unk); - traced_func_nvar: + deref_head(d0, func_unk); + func_nvar: /* A1 is bound */ BEGD(d1); if (IsApplTerm(d0)) { @@ -14036,7 +14063,7 @@ S_SREG = RepAppl(d0); if (d1 <= (CELL)FunctorDouble && d1 >= (CELL)FunctorLongInt ) { d1 = MkIntTerm(0); } else - TRACED_FAIL(); + FAIL(); } else { d0 = MkAtomTerm(NameOfFunctor((Functor) d1)); d1 = MkIntTerm(ArityOfFunctor((Functor) d1)); @@ -14055,38 +14082,38 @@ S_SREG = RepAppl(d0); register CELL arity = d1; d1 = ARG2; - deref_head(d1, traced_func_nvar_unk); - traced_func_nvar_nvar: + deref_head(d1, func_nvar_unk); + func_nvar_nvar: /* A2 was bound */ if (d0 != d1) { - TRACED_FAIL(); + FAIL(); } /* I have to this here so that I don't have a jump to a closing bracket */ d0 = arity; - goto traced_func_bind_x3; + goto func_bind_x3; BEGP(pt0); - deref_body(d1, pt0, traced_func_nvar_unk, traced_func_nvar_nvar); + deref_body(d1, pt0, func_nvar_unk, func_nvar_nvar); /* A2 is a variable, go and bind it */ Bind(pt0, d0); /* I have to this here so that I don't have a jump to a closing bracket */ d0 = arity; ENDP(pt0); - traced_func_bind_x3: + func_bind_x3: /* now let's process A3 */ d1 = ARG3; - deref_head(d1, traced_func_nvar3_unk); - traced_func_nvar3_nvar: + deref_head(d1, func_nvar3_unk); + func_nvar3_nvar: /* A3 was bound */ if (d0 != d1) { - TRACED_FAIL(); + FAIL(); } /* Done */ PREG = NEXTOP(NEXTOP(NEXTOP(PREG, e),Osbmp),l); GONext(); BEGP(pt0); - deref_body(d1, pt0, traced_func_nvar3_unk, traced_func_nvar3_nvar); + deref_body(d1, pt0, func_nvar3_unk, func_nvar3_nvar); /* A3 is a variable, go and bind it */ PREG = NEXTOP(NEXTOP(NEXTOP(PREG, e),Osbmp),l); Bind(pt0, d0); @@ -14100,17 +14127,17 @@ S_SREG = RepAppl(d0); ENDD(d1); BEGP(pt0); - deref_body(d0, pt0, traced_func_unk, traced_func_nvar); + deref_body(d0, pt0, func_unk, func_nvar); /* A1 is a variable */ /* We have to build the structure */ d0 = ARG2; - deref_head(d0, traced_func_var_2unk); - traced_func_var_2nvar: + deref_head(d0, func_var_2unk); + func_var_2nvar: /* we do, let's get the third argument */ BEGD(d1); d1 = ARG3; - deref_head(d1, traced_func_var_3unk); - traced_func_var_3nvar: + deref_head(d1, func_var_3unk); + func_var_3nvar: /* Uuuff, the second and third argument are bound */ if (IsIntTerm(d1)) d1 = IntOfTerm(d1); @@ -14118,13 +14145,13 @@ S_SREG = RepAppl(d0); saveregs(); Yap_Error(TYPE_ERROR_INTEGER,ARG3,"functor/3"); setregs(); - TRACED_FAIL(); + FAIL(); } if (!IsAtomicTerm(d0)) { saveregs(); Yap_Error(TYPE_ERROR_ATOM,d0,"functor/3"); setregs(); - TRACED_FAIL(); + FAIL(); } /* We made it!!!!! we got in d0 the name, in d1 the arity and * in pt0 the variable to bind it to. */ if (d0 == TermDot && d1 == 2) { @@ -14139,11 +14166,11 @@ S_SREG = RepAppl(d0); saveregs(); Yap_Error(TYPE_ERROR_ATOM,d0,"functor/3"); setregs(); - TRACED_FAIL(); + FAIL(); } BEGP(pt1); if (!IsAtomTerm(d0)) { - TRACED_FAIL(); + FAIL(); } else d0 = (CELL) Yap_MkFunctor(AtomOfTerm(d0), (Int) d1); @@ -14160,7 +14187,7 @@ S_SREG = RepAppl(d0); } else { setregs(); } - goto traced_restart_functor; /* */ + goto restart_functor; /* */ } while ((Int)d1--) { RESET_VARIABLE(pt1); @@ -14173,7 +14200,7 @@ S_SREG = RepAppl(d0); saveregs(); Yap_Error(DOMAIN_ERROR_NOT_LESS_THAN_ZERO,MkIntegerTerm(d1),"functor/3"); setregs(); - TRACED_FAIL(); + FAIL(); } /* else if arity is 0 just pass d0 through */ /* Ding, ding, we made it */ @@ -14183,23 +14210,23 @@ S_SREG = RepAppl(d0); BEGP(pt1); - deref_body(d1, pt1, traced_func_var_3unk, traced_func_var_3nvar); + deref_body(d1, pt1, func_var_3unk, func_var_3nvar); saveregs(); Yap_Error(INSTANTIATION_ERROR, d1, "functor/3"); setregs(); ENDP(pt1); /* Oops, third argument was unbound */ - TRACED_FAIL(); + FAIL(); ENDD(d1); BEGP(pt1); - deref_body(d0, pt1, traced_func_var_2unk, traced_func_var_2nvar); + deref_body(d0, pt1, func_var_2unk, func_var_2nvar); saveregs(); Yap_Error(INSTANTIATION_ERROR, d0, "functor/3"); setregs(); ENDP(pt1); /* Oops, second argument was unbound too */ - TRACED_FAIL(); + FAIL(); ENDP(pt0); ENDD(d0); ENDOp(); @@ -14215,7 +14242,7 @@ S_SREG = RepAppl(d0); Functor f; /* we are doing the rhs of a , */ - BOp(traced_p_execute_tail, Osbmp); + BOp(p_execute_tail, Osbmp); FETCH_Y_FROM_ENV(YREG); /* place to cut to */ @@ -14254,26 +14281,26 @@ S_SREG = RepAppl(d0); ENV = (CELL *)ENV[E_E]; } */ - goto traced_execute_pred_f; + goto execute_pred_f; } else - goto traced_execute_pred_a; + goto execute_pred_a; ENDBOp(); /* fetch the module from ARG2 */ - BOp(traced_p_execute2, Osbpp); + BOp(p_execute2, Osbpp); mod = ARG2; - deref_head(mod, traced_execute2_unk0); - traced_execute2_nvar0: + deref_head(mod, execute2_unk0); + execute2_nvar0: if (!IsAtomTerm(mod)) { saveregs(); Yap_Error(TYPE_ERROR_ATOM, mod, "call/2"); setregs(); } - goto start_traced_execute; + goto start_execute; BEGP(pt1); - deref_body(mod, pt1, traced_execute2_unk0, traced_execute2_nvar0); + deref_body(mod, pt1, execute2_unk0, execute2_nvar0); saveregs(); Yap_Error(INSTANTIATION_ERROR, mod, "call/2"); setregs(); @@ -14282,10 +14309,10 @@ S_SREG = RepAppl(d0); FAIL(); ENDBOp(); - BOp(traced_p_execute, Osbmp); + BOp(p_execute, Osbmp); /* fetch the module from PREG */ mod = PREG->y_u.Osbmp.mod; - start_traced_execute: + start_execute: /* place to cut to */ b_ptr = B; /* we have mod, and ARG1 has the goal, let us roll */ @@ -14307,18 +14334,18 @@ S_SREG = RepAppl(d0); #endif /* FROZEN_STACKS */ d0 = ARG1; if (PRED_GOAL_EXPANSION_ALL) { - goto traced_execute_metacall; + goto execute_metacall; } - restart_traced_execute: - deref_head(d0, traced_execute_unk); - traced_execute_nvar: + restart_execute: + deref_head(d0, execute_unk); + execute_nvar: if (IsApplTerm(d0)) { f = FunctorOfTerm(d0); if (IsExtensionFunctor(f)) { - goto traced_execute_metacall; + goto execute_metacall; } pen = RepPredProp(PredPropByFunc(f, mod)); - traced_execute_pred_f: + execute_pred_f: if (pen->PredFlags & (MetaPredFlag|GoalExPredFlag)) { /* just strip all of M:G */ if (f == FunctorModule) { @@ -14327,9 +14354,9 @@ S_SREG = RepAppl(d0); if (!IsVarTerm(tmod) && IsAtomTerm(tmod)) { d0 = ArgOfTerm(2,d0); mod = tmod; - goto traced_execute_nvar; + goto execute_nvar; } - goto traced_execute_metacall; + goto execute_metacall; } if (f == FunctorComma) { Term nmod = mod; @@ -14338,16 +14365,16 @@ S_SREG = RepAppl(d0); SREG = RepAppl(d0); BEGD(d1); d1 = SREG[2]; - /* create an environment to traced_execute the call */ - deref_head(d1, traced_execute_comma_unk); - traced_execute_comma_nvar: + /* create an environment to execute the call */ + deref_head(d1, execute_comma_unk); + execute_comma_nvar: if (IsAtomTerm(d1)) { /* atomic goal is simpler */ ENV_YREG[-EnvSizeInCells-2] = MkIntegerTerm((Int)PredPropByAtom(AtomOfTerm(d1),nmod)); } else if (IsApplTerm(d1)) { Functor f1 = FunctorOfTerm(d1); if (IsExtensionFunctor(f1)) { - goto traced_execute_metacall; + goto execute_metacall; } else { /* check for modules when looking up */ if (f1 == FunctorModule) { @@ -14356,14 +14383,14 @@ S_SREG = RepAppl(d0); if (!IsVarTerm(tmod) && IsAtomTerm(tmod)) { d1 = ArgOfTerm(2,d1); nmod = tmod; - goto traced_execute_comma_nvar; + goto execute_comma_nvar; } - goto traced_execute_metacall; + goto execute_metacall; } ENV_YREG[-EnvSizeInCells-2] = MkIntegerTerm((Int)PredPropByFunc(f1,nmod)); } } else { - goto traced_execute_metacall; + goto execute_metacall; } ENV_YREG[-EnvSizeInCells-3] = mod; /* now, we can create the new environment for the meta-call */ @@ -14382,15 +14409,15 @@ S_SREG = RepAppl(d0); /* for profiler */ save_pc(); d0 = SREG[1]; - goto restart_traced_execute; + goto restart_execute; BEGP(pt1); - deref_body(d1, pt1, traced_execute_comma_unk, traced_execute_comma_nvar); - goto traced_execute_metacall; + deref_body(d1, pt1, execute_comma_unk, execute_comma_nvar); + goto execute_metacall; ENDP(pt1); ENDD(d1); } else if (mod != CurrentModule) { - goto traced_execute_metacall; + goto execute_metacall; } } @@ -14416,7 +14443,7 @@ S_SREG = RepAppl(d0); CACHE_A1(); } else if (IsAtomTerm(d0)) { pen = RepPredProp(PredPropByAtom(AtomOfTerm(d0), mod)); - traced_execute_pred_a: + execute_pred_a: /* handle extra pruning */ if (pen->FunctorOfPred == (Functor)AtomCut) { if (b_ptr != B) { @@ -14426,16 +14453,16 @@ S_SREG = RepAppl(d0); } } } else { - goto traced_execute_metacall; + goto execute_metacall; } - /* traced_execute, but test first for interrupts */ - traced_execute_end: + /* execute, but test first for interrupts */ + execute_end: /* code copied from call */ #ifndef NO_CHECKING check_stack(TracedNoStackPExecute, HR); #endif - traced_execute_stack_checked: + execute_stack_checked: CPREG = NEXTOP(PREG, Osbmp); ALWAYS_LOOKAHEAD(pen->OpcodeOfPred); PREG = pen->CodeOfPred; @@ -14469,8 +14496,8 @@ S_SREG = RepAppl(d0); /* meta-call: Prolog to the rescue */ BEGP(pt1); - deref_body(d0, pt1, traced_execute_unk, traced_execute_nvar); - traced_execute_metacall: + deref_body(d0, pt1, execute_unk, execute_nvar); + execute_metacall: ARG1 = ARG3 = d0; pen = PredMetaCall; ARG2 = Yap_cp_as_integer(b_ptr); @@ -14478,7 +14505,7 @@ S_SREG = RepAppl(d0); ARG4 = mod; else ARG4 = TermProlog; - goto traced_execute_end; + goto execute_end; ENDP(pt1); /* at this point, we have the arguments all set in the argument registers, pen says who is the current predicate. don't remove. */ @@ -14494,8 +14521,8 @@ S_SREG = RepAppl(d0); SREG = Yap_REGS.S_; #endif if (!d0) FAIL(); - if (d0 == 2) goto traced_execute_stack_checked; - goto traced_execute_end; + if (d0 == 2) goto execute_stack_checked; + goto execute_end; ENDBOp(); ENDD(d0); @@ -14503,3 +14530,60 @@ S_SREG = RepAppl(d0); } + + BOp(unify_l_string ,ou); + goto Ystop; + ENDBOp(); + BOp(unify_string ,ou); + goto Ystop; + ENDBOp(); + BOp(get_string ,xu); + goto Ystop; + ENDBOp(); + BOp(get_atom_exo ,x); + goto Ystop; + ENDBOp(); + BOp(retry_exo_udi ,lp); + goto Ystop; + ENDBOp(); + BOp(retry_exo ,lp); + goto Ystop; + ENDBOp(); + BOp(retry_udi ,p); + goto Ystop; + ENDBOp(); + BOp(retry_all_exo ,lp); + goto Ystop; + ENDBOp(); + BOp(enter_exo ,e); + goto Ystop; + ENDBOp(); + BOp(try_exo ,lp); + goto Ystop; + ENDBOp(); + BOp(try_exo_udi ,lp); + goto Ystop; + ENDBOp(); + BOp(try_all_exo ,lp); + goto Ystop; + ENDBOp(); + BOp(try_udi ,p); + goto Ystop; + ENDBOp(); + /* BOp(table_answer_resolution_completion, Otapl); + goto Ystop; + ENDBOp(); + BOp(run_eam, os); + goto Ystop; + ENDBOp(); + BOp(retry_eam, e); + goto Ystop; + ENDBOp(); + BOp(thread_local, e); + goto Ystop; + ENDBOp(); + BOp(clause_with_cut, e); + goto Ystop; + ENDBOp(); */ + + diff --git a/CMakeLists.txt b/CMakeLists.txt index 7b8821ab5..6ed4bbf47 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -141,6 +141,7 @@ endif() # Model Specific if (HAVE_GCC) set_property( DIRECTORY APPEND_STRING PROPERTY COMPILE_OPTIONS -Wall;-Wstrict-prototypes;-Wmissing-prototypes ) + set_property( DIRECTORY APPEND_STRING PROPERTY COMPILE_OPTIONS -fexceptions ) endif() message(STATUS "Original CMAKE_C_FLAGS ${CMAKE_C_FLAGS}") diff --git a/H/YapOpcodes.h b/H/YapOpcodes.h index 58d22ae09..4176aaf87 100644 --- a/H/YapOpcodes.h +++ b/H/YapOpcodes.h @@ -422,414 +422,9 @@ OPCODE(trie_trust_gterm ,e), OPCODE(trie_try_gterm ,e), OPCODE(trie_retry_gterm ,e), -#endif -#ifdef YAP_JIT - OPCODE(traced_Ystop ,l), - OPCODE(traced_Nstop ,e), - OPCODE(traced_try_me ,Otapl), - OPCODE(traced_retry_me ,Otapl), - OPCODE(traced_trust_me ,Otapl), - OPCODE(traced_enter_profiling ,p), - OPCODE(traced_retry_profiled ,p), - OPCODE(traced_profiled_retry_me ,Otapl), - OPCODE(traced_profiled_trust_me ,Otapl), - OPCODE(traced_profiled_retry_logical,OtaLl), - OPCODE(traced_profiled_trust_logical,OtILl), - OPCODE(traced_count_call ,p), - OPCODE(traced_count_retry ,p), - OPCODE(traced_count_retry_me ,Otapl), - OPCODE(traced_count_trust_me ,Otapl), - OPCODE(traced_count_retry_logical ,OtaLl), - OPCODE(traced_count_trust_logical ,OtILl), - OPCODE(traced_lock_lu ,p), - OPCODE(traced_unlock_lu ,e), - OPCODE(traced_alloc_for_logical_pred,L), - OPCODE(traced_copy_idb_term ,e), - OPCODE(traced_unify_idb_term ,e), - OPCODE(traced_ensure_space ,Osbpa), - OPCODE(traced_spy_or_trymark ,Otapl), - OPCODE(traced_try_and_mark ,Otapl), - OPCODE(traced_count_retry_and_mark,Otapl), - OPCODE(traced_profiled_retry_and_mark,Otapl), - OPCODE(traced_retry_and_mark ,Otapl), - OPCODE(traced_trust_fail ,e), - OPCODE(traced_op_fail ,e), - OPCODE(traced_cut ,s), - OPCODE(traced_cut_t ,s), - OPCODE(traced_cut_e ,s), - OPCODE(traced_save_b_x ,x), - OPCODE(traced_save_b_y ,y), - OPCODE(traced_commit_b_x ,xps), - OPCODE(traced_commit_b_y ,yps), - OPCODE(traced_execute ,pp), - OPCODE(traced_dexecute ,pp), - OPCODE(traced_fcall ,Osbpp), - OPCODE(traced_call ,Osbpp), - OPCODE(traced_procceed ,p), - OPCODE(traced_allocate ,e), - OPCODE(traced_deallocate ,p), - OPCODE(traced_retry_eam ,e), - OPCODE(traced_run_eam ,os), - OPCODE(traced_get_x_var ,xx), - OPCODE(traced_get_y_var ,yx), - OPCODE(traced_get_yy_var ,yyxx), - OPCODE(traced_get_x_val ,xx), - OPCODE(traced_get_y_val ,yx), - OPCODE(traced_get_atom ,xc), - OPCODE(traced_get_2atoms ,cc), - OPCODE(traced_get_3atoms ,ccc), - OPCODE(traced_get_4atoms ,cccc), - OPCODE(traced_get_5atoms ,ccccc), - OPCODE(traced_get_6atoms ,cccccc), - OPCODE(traced_get_list ,x), - OPCODE(traced_get_struct ,xfa), - OPCODE(traced_get_float ,xd), - OPCODE(traced_get_longint ,xi), - OPCODE(traced_get_bigint ,xN), - OPCODE(traced_get_dbterm ,xD), - OPCODE(traced_glist_valx ,xx), - OPCODE(traced_glist_valy ,yx), - OPCODE(traced_gl_void_varx ,xx), - OPCODE(traced_gl_void_vary ,yx), - OPCODE(traced_gl_void_valx ,xx), - OPCODE(traced_gl_void_valy ,yx), - OPCODE(traced_unify_x_var ,ox), - OPCODE(traced_unify_x_var_write ,ox), - OPCODE(traced_unify_l_x_var ,ox), - OPCODE(traced_unify_l_x_var_write ,ox), - OPCODE(traced_unify_x_var2 ,oxx), - OPCODE(traced_unify_x_var2_write ,oxx), - OPCODE(traced_unify_l_x_var2 ,oxx), - OPCODE(traced_unify_l_x_var2_write,oxx), - OPCODE(traced_unify_y_var ,oy), - OPCODE(traced_unify_y_var_write ,oy), - OPCODE(traced_unify_l_y_var ,oy), - OPCODE(traced_unify_l_y_var_write ,oy), - OPCODE(traced_unify_x_val ,ox), - OPCODE(traced_unify_x_val_write ,ox), - OPCODE(traced_unify_l_x_val ,ox), - OPCODE(traced_unify_l_x_val_write ,ox), - OPCODE(traced_unify_y_val ,oy), - OPCODE(traced_unify_y_val_write ,oy), - OPCODE(traced_unify_l_y_val ,oy), - OPCODE(traced_unify_l_y_val_write ,oy), - OPCODE(traced_unify_x_loc ,ox), - OPCODE(traced_unify_x_loc_write ,ox), - OPCODE(traced_unify_l_x_loc ,ox), - OPCODE(traced_unify_l_x_loc_write ,ox), - OPCODE(traced_unify_y_loc ,oy), - OPCODE(traced_unify_y_loc_write ,oy), - OPCODE(traced_unify_l_y_loc ,oy), - OPCODE(traced_unify_l_y_loc_write ,oy), - OPCODE(traced_unify_void ,o), - OPCODE(traced_unify_void_write ,o), - OPCODE(traced_unify_l_void ,o), - OPCODE(traced_unify_l_void_write ,o), - OPCODE(traced_unify_n_voids ,os), - OPCODE(traced_unify_n_voids_write ,os), - OPCODE(traced_unify_l_n_voids ,os), - OPCODE(traced_unify_l_n_voids_write,os), - OPCODE(traced_unify_atom ,oc), - OPCODE(traced_unify_atom_write ,oc), - OPCODE(traced_unify_l_atom ,oc), - OPCODE(traced_unify_l_atom_write ,oc), - OPCODE(traced_unify_n_atoms ,osc), - OPCODE(traced_unify_n_atoms_write ,osc), - OPCODE(traced_unify_float ,od), - OPCODE(traced_unify_float_write ,od), - OPCODE(traced_unify_l_float ,od), - OPCODE(traced_unify_l_float_write ,od), - OPCODE(traced_unify_longint ,oi), - OPCODE(traced_unify_longint_write ,oi), - OPCODE(traced_unify_l_longint ,oi), - OPCODE(traced_unify_l_longint_write,oi), - OPCODE(traced_unify_bigint ,oN), - OPCODE(traced_unify_l_bigint ,oN), - OPCODE(traced_unify_dbterm ,oD), - OPCODE(traced_unify_l_dbterm ,oD), - OPCODE(traced_unify_list ,o), - OPCODE(traced_unify_list_write ,o), - OPCODE(traced_unify_l_list ,o), - OPCODE(traced_unify_l_list_write ,o), - OPCODE(traced_unify_struct ,ofa), - OPCODE(traced_unify_struct_write ,ofa), - OPCODE(traced_unify_l_struc ,ofa), - OPCODE(traced_unify_l_struc_write ,ofa), - OPCODE(traced_put_x_var ,xx), - OPCODE(traced_put_y_var ,yx), - OPCODE(traced_put_x_val ,xx), - OPCODE(traced_put_xx_val ,xxxx), - OPCODE(traced_put_y_val ,yx), - OPCODE(traced_put_y_vals ,yyxx), - OPCODE(traced_put_unsafe ,yx), - OPCODE(traced_put_atom ,xc), - OPCODE(traced_put_dbterm ,xD), - OPCODE(traced_put_bigint ,xN), - OPCODE(traced_put_float ,xd), - OPCODE(traced_put_longint ,xi), - OPCODE(traced_put_list ,x), - OPCODE(traced_put_struct ,xfa), - OPCODE(traced_write_x_var ,x), - OPCODE(traced_write_void ,e), - OPCODE(traced_write_n_voids ,s), - OPCODE(traced_write_y_var ,y), - OPCODE(traced_write_x_val ,x), - OPCODE(traced_write_x_loc ,x), - OPCODE(traced_write_y_val ,y), - OPCODE(traced_write_y_loc ,y), - OPCODE(traced_write_atom ,c), - OPCODE(traced_write_bigint ,N), - OPCODE(traced_write_dbterm ,D), - OPCODE(traced_write_float ,d), - OPCODE(traced_write_longint ,i), - OPCODE(traced_write_n_atoms ,sc), - OPCODE(traced_write_list ,e), - OPCODE(traced_write_l_list ,e), - OPCODE(traced_write_struct ,fa), - OPCODE(traced_write_l_struc ,fa), - OPCODE(traced_save_pair_x ,ox), - OPCODE(traced_save_pair_x_write ,ox), - OPCODE(traced_save_pair_y ,oy), - OPCODE(traced_save_pair_y_write ,oy), - OPCODE(traced_save_appl_x ,ox), - OPCODE(traced_save_appl_x_write ,ox), - OPCODE(traced_save_appl_y ,oy), - OPCODE(traced_save_appl_y_write ,oy), - OPCODE(traced_jump ,l), - OPCODE(traced_move_back ,l), - OPCODE(traced_skip ,l), - OPCODE(traced_either ,Osblp), - OPCODE(traced_or_else ,Osblp), - OPCODE(traced_pop_n ,s), - OPCODE(traced_pop ,e), - OPCODE(traced_call_cpred ,Osbpp), - OPCODE(traced_execute_cpred ,pp), - OPCODE(traced_call_usercpred ,Osbpp), - OPCODE(traced_call_c_wfail ,slp), - OPCODE(traced_try_c ,OtapFs), - OPCODE(traced_retry_c ,OtapFs), - OPCODE(traced_cut_c ,OtapFs), - OPCODE(traced_try_userc ,OtapFs), - OPCODE(traced_retry_userc ,OtapFs), - OPCODE(traced_cut_userc ,OtapFs), - OPCODE(traced_lock_pred ,e), - OPCODE(traced_index_pred ,e), - OPCODE(traced_thread_local ,e), - OPCODE(traced_expand_index ,e), - OPCODE(traced_expand_clauses ,sssllp), - OPCODE(traced_undef_p ,e), - OPCODE(traced_spy_pred ,e), - OPCODE(traced_try_clause ,Otapl), - OPCODE(traced_try_clause2 ,l), - OPCODE(traced_try_clause3 ,l), - OPCODE(traced_try_clause4 ,l), - OPCODE(traced_retry ,Otapl), - OPCODE(traced_retry2 ,l), - OPCODE(traced_retry3 ,l), - OPCODE(traced_retry4 ,l), - OPCODE(traced_trust ,Otapl), - OPCODE(traced_try_in ,l), - OPCODE(traced_enter_lu_pred ,Illss), - OPCODE(traced_try_logical ,OtaLl), - OPCODE(traced_retry_logical ,OtaLl), - OPCODE(traced_trust_logical ,OtILl), - OPCODE(traced_user_switch ,lp), - OPCODE(traced_switch_on_type ,llll), - OPCODE(traced_switch_list_nl ,ollll), - OPCODE(traced_switch_on_arg_type ,xllll), - OPCODE(traced_switch_on_sub_arg_type,sllll), - OPCODE(traced_jump_if_var ,l), - OPCODE(traced_jump_if_nonvar ,xll), - OPCODE(traced_if_not_then ,clll), - OPCODE(traced_switch_on_func ,sssl), - OPCODE(traced_switch_on_cons ,sssl), - OPCODE(traced_go_on_func ,sssl), - OPCODE(traced_go_on_cons ,sssl), - OPCODE(traced_if_func ,sssl), - OPCODE(traced_if_cons ,sssl), - OPCODE(traced_index_dbref ,e), - OPCODE(traced_index_blob ,e), - OPCODE(traced_index_long ,e), - OPCODE(traced_jit_handler ,J), - OPCODE(traced_p_atom_x ,xl), - OPCODE(traced_p_atom_y ,yl), - OPCODE(traced_p_atomic_x ,xl), - OPCODE(traced_p_atomic_y ,yl), - OPCODE(traced_p_integer_x ,xl), - OPCODE(traced_p_integer_y ,yl), - OPCODE(traced_p_nonvar_x ,xl), - OPCODE(traced_p_nonvar_y ,yl), - OPCODE(traced_p_number_x ,xl), - OPCODE(traced_p_number_y ,yl), - OPCODE(traced_p_var_x ,xl), - OPCODE(traced_p_var_y ,yl), - OPCODE(traced_p_db_ref_x ,xl), - OPCODE(traced_p_db_ref_y ,yl), - OPCODE(traced_p_primitive_x ,xl), - OPCODE(traced_p_primitive_y ,yl), - OPCODE(traced_p_compound_x ,xl), - OPCODE(traced_p_compound_y ,yl), - OPCODE(traced_p_float_x ,xl), - OPCODE(traced_p_float_y ,yl), - OPCODE(traced_p_plus_vv ,xxx), - OPCODE(traced_p_plus_vc ,xxn), - OPCODE(traced_p_plus_y_vv ,yxx), - OPCODE(traced_p_plus_y_vc ,yxn), - OPCODE(traced_p_minus_vv ,xxx), - OPCODE(traced_p_minus_cv ,xxn), - OPCODE(traced_p_minus_y_vv ,yxx), - OPCODE(traced_p_minus_y_cv ,yxn), - OPCODE(traced_p_times_vv ,xxx), - OPCODE(traced_p_times_vc ,xxn), - OPCODE(traced_p_times_y_vv ,yxx), - OPCODE(traced_p_times_y_vc ,yxn), - OPCODE(traced_p_div_vv ,xxx), - OPCODE(traced_p_div_vc ,xxn), - OPCODE(traced_p_div_cv ,xxn), - OPCODE(traced_p_div_y_vv ,yxx), - OPCODE(traced_p_div_y_vc ,yxn), - OPCODE(traced_p_div_y_cv ,yxn), - OPCODE(traced_p_and_vv ,xxx), - OPCODE(traced_p_and_vc ,xxn), - OPCODE(traced_p_and_y_vv ,yxx), - OPCODE(traced_p_and_y_vc ,yxn), - OPCODE(traced_p_or_vv ,xxx), - OPCODE(traced_p_or_vc ,xxn), - OPCODE(traced_p_or_y_vv ,yxx), - OPCODE(traced_p_or_y_vc ,yxn), - OPCODE(traced_p_sll_vv ,xxx), - OPCODE(traced_p_sll_vc ,xxn), - OPCODE(traced_p_sll_cv ,xxn), - OPCODE(traced_p_sll_y_vv ,yxx), - OPCODE(traced_p_sll_y_vc ,yxn), - OPCODE(traced_p_sll_y_cv ,yxn), - OPCODE(traced_p_slr_vv ,xxx), - OPCODE(traced_p_slr_vc ,xxn), - OPCODE(traced_p_slr_cv ,xxn), - OPCODE(traced_p_slr_y_vv ,yxx), - OPCODE(traced_p_slr_y_vc ,yxn), - OPCODE(traced_p_slr_y_cv ,yxn), - OPCODE(traced_call_bfunc_xx ,plxxs), - OPCODE(traced_call_bfunc_yx ,plxys), - OPCODE(traced_call_bfunc_xy ,plxys), - OPCODE(traced_call_bfunc_yy ,plyys), - OPCODE(traced_p_equal ,e), - OPCODE(traced_p_dif ,l), - OPCODE(traced_p_eq ,l), - OPCODE(traced_p_arg_vv ,xxx), - OPCODE(traced_p_arg_cv ,xxn), - OPCODE(traced_p_arg_y_vv ,yxx), - OPCODE(traced_p_arg_y_cv ,yxn), - OPCODE(traced_p_func2s_vv ,xxx), - OPCODE(traced_p_func2s_cv ,xxc), - OPCODE(traced_p_func2s_vc ,xxn), - OPCODE(traced_p_func2s_y_vv ,yxx), - OPCODE(traced_p_func2s_y_cv ,yxn), - OPCODE(traced_p_func2s_y_vc ,yxn), - OPCODE(traced_p_func2f_xx ,xxx), - OPCODE(traced_p_func2f_xy ,xxy), - OPCODE(traced_p_func2f_yx ,yxx), - OPCODE(traced_p_func2f_yy ,yyx), - OPCODE(traced_p_functor ,e), - OPCODE(traced_p_execute_tail ,Osbmp), - OPCODE(traced_p_execute2 ,Osbpp), - OPCODE(traced_p_execute ,Osbmp), -#ifdef YAPOR - OPCODE(traced_getwork_first_time ,e), - OPCODE(traced_getwork ,Otapl), - OPCODE(traced_getwork_seq ,Otapl), - OPCODE(traced_sync ,Otapl), -#endif -#ifdef TABLING - OPCODE(traced_clause_with_cut ,e), - OPCODE(traced_table_load_answer ,Otapl), - OPCODE(traced_table_try_answer ,Otapl), - OPCODE(traced_table_try_single ,Otapl), - OPCODE(traced_table_try_me ,Otapl), - OPCODE(traced_table_try ,Otapl), - OPCODE(traced_table_retry_me ,Otapl), - OPCODE(traced_table_retry ,Otapl), - OPCODE(traced_table_trust_me ,Otapl), - OPCODE(traced_table_trust ,Otapl), - OPCODE(traced_table_new_answer ,s), - OPCODE(traced_table_answer_resolution,Otapl), - OPCODE(traced_table_completion ,Otapl), - OPCODE(traced_table_answer_resolution_completion,Otapl), - OPCODE(traced_trie_do_var ,e), - OPCODE(traced_trie_trust_var ,e), - OPCODE(traced_trie_try_var ,e), - OPCODE(traced_trie_retry_var ,e), - OPCODE(traced_trie_do_var_in_pair ,e), - OPCODE(traced_trie_trust_var_in_pair,e), - OPCODE(traced_trie_try_var_in_pair,e), - OPCODE(traced_trie_retry_var_in_pair,e), - OPCODE(traced_trie_do_val ,e), - OPCODE(traced_trie_trust_val ,e), - OPCODE(traced_trie_try_val ,e), - OPCODE(traced_trie_retry_val ,e), - OPCODE(traced_trie_do_val_in_pair ,e), - OPCODE(traced_trie_trust_val_in_pair,e), - OPCODE(traced_trie_try_val_in_pair,e), - OPCODE(traced_trie_retry_val_in_pair,e), - OPCODE(traced_trie_do_atom ,e), - OPCODE(traced_trie_trust_atom ,e), - OPCODE(traced_trie_try_atom ,e), - OPCODE(traced_trie_retry_atom ,e), - OPCODE(traced_trie_do_atom_in_pair,e), - OPCODE(traced_trie_trust_atom_in_pair,e), - OPCODE(traced_trie_try_atom_in_pair,e), - OPCODE(traced_trie_retry_atom_in_pair,e), - OPCODE(traced_trie_do_null ,e), - OPCODE(traced_trie_trust_null ,e), - OPCODE(traced_trie_try_null ,e), - OPCODE(traced_trie_retry_null ,e), - OPCODE(traced_trie_do_null_in_pair,e), - OPCODE(traced_trie_trust_null_in_pair,e), - OPCODE(traced_trie_try_null_in_pair,e), - OPCODE(traced_trie_retry_null_in_pair,e), - OPCODE(traced_trie_do_pair ,e), - OPCODE(traced_trie_trust_pair ,e), - OPCODE(traced_trie_try_pair ,e), - OPCODE(traced_trie_retry_pair ,e), - OPCODE(traced_trie_do_appl ,e), - OPCODE(traced_trie_trust_appl ,e), - OPCODE(traced_trie_try_appl ,e), - OPCODE(traced_trie_retry_appl ,e), - OPCODE(traced_trie_do_appl_in_pair,e), - OPCODE(traced_trie_trust_appl_in_pair,e), - OPCODE(traced_trie_try_appl_in_pair,e), - OPCODE(traced_trie_retry_appl_in_pair,e), - OPCODE(traced_trie_do_extension ,e), - OPCODE(traced_trie_trust_extension,e), - OPCODE(traced_trie_try_extension ,e), - OPCODE(traced_trie_retry_extension,e), - OPCODE(traced_trie_do_double ,e), - OPCODE(traced_trie_trust_double ,e), - OPCODE(traced_trie_try_double ,e), - OPCODE(traced_trie_retry_double ,e), - OPCODE(traced_trie_do_longint ,e), - OPCODE(traced_trie_trust_longint ,e), - OPCODE(traced_trie_try_longint ,e), - OPCODE(traced_trie_retry_longint ,e), - OPCODE(traced_trie_do_bigint ,e), - OPCODE(traced_trie_trust_bigint ,e), - OPCODE(traced_trie_try_bigint ,e), - OPCODE(traced_trie_retry_bigint ,e), - OPCODE(traced_trie_do_gterm ,e), - OPCODE(traced_trie_trust_gterm ,e), - OPCODE(traced_trie_try_gterm ,e), - OPCODE(traced_trie_retry_gterm ,e), -#endif #endif /* this instruction is hardwired */ /* or_last must be the last instruction. */ -#ifdef YAP_JIT -#ifdef YAPOR - OPCODE(traced_or_last ,sblp), -#else - OPCODE(traced_or_last ,p), -#endif -#endif #ifdef YAPOR OPCODE(or_last ,sblp), #else diff --git a/H/absmi.h b/H/absmi.h index 45a075e96..48ff56782 100755 --- a/H/absmi.h +++ b/H/absmi.h @@ -32,6 +32,11 @@ static char SccsId[] = "%W% %G%"; #define Yapc_Compile(P) 0 #endif +#ifdef __cplusplus +#define register +#endif + + /*************************************************************** * Macros for register manipulation * ***************************************************************/ @@ -416,7 +421,13 @@ restore_absmi_regs(REGSTORE * old_regs) ******************************************************************/ -#if USE_THREADED_CODE +#if __YAP_TRACED + +#define DO_PREFETCH(TYPE) + +#define DO_PREFETCH_W(TYPE) + +#elif USE_THREADED_CODE #ifndef _NATIVE @@ -616,7 +627,7 @@ restore_absmi_regs(REGSTORE * old_regs) #define END_PREFETCH() -#define END_PREFETCH_W() +#define END_PREFETCH_W() #endif /* _NATIVE */ @@ -626,7 +637,17 @@ restore_absmi_regs(REGSTORE * old_regs) ******************************************************************/ -#if USE_THREADED_CODE +#if __YAP_TRACED + +#define JMP(Lab) { opcode = Yap_op_from_opcode( goto *Lab ); goto op_switch; } + +#define JMPNext(Lab) { opcode = Yap_op_from_opcode( PREG->opc ) + ExpEnv.config_struc.current_displacement; goto op_switch; } + +#define JMPNextW(Lab) { opcode = Yap_op_from_opcode( PREG->opcw ) + ExpEnv.config_struc.current_displacement; goto op_switch; } + + + +#elif USE_THREADED_CODE #ifndef _NATIVE @@ -683,7 +704,7 @@ restore_absmi_regs(REGSTORE * old_regs) return ((void *) OpAddress[Yap_op_from_opcode((*_PREG)->opc) + ExpEnv.config_struc.current_displacement]); \ return ((void *) ((*_PREG)->opc)); \ } - + #define BACK() \ { \ if ((char*)ExpEnv.debug_struc.pprint_me.nativerun_exit_by_fail != 0 && (char*)ExpEnv.debug_struc.pprint_me.nativerun_exit_by_fail != (char*)0x1) { \ @@ -692,7 +713,7 @@ restore_absmi_regs(REGSTORE * old_regs) } \ return ((void *) OpAddress[Yap_op_from_opcode((*_PREG)->opc)]); \ } - + #else /* YAP_DBG_PREDS */ #define SUCCESSBACK() \ @@ -714,12 +735,12 @@ restore_absmi_regs(REGSTORE * old_regs) return ((void *) OpAddress[Yap_op_from_opcode((*_PREG)->opc) + ExpEnv.config_struc.current_displacement]); \ return ((void *) ((*_PREG)->opc)); \ } - + #define BACK() \ { \ return ((void *) OpAddress[Yap_op_from_opcode((*_PREG)->opc)]); \ } - + #endif /* YAP_DBG_PREDS */ #else /* YAP_STAT_PREDS */ @@ -748,7 +769,7 @@ restore_absmi_regs(REGSTORE * old_regs) return ((void *) OpAddress[Yap_op_from_opcode((*_PREG)->opc) + ExpEnv.config_struc.current_displacement]); \ return ((void *) ((*_PREG)->opc)); \ } - + #define BACK() \ { \ if ((char*)ExpEnv.debug_struc.pprint_me.nativerun_exit_by_fail != 0 && (char*)ExpEnv.debug_struc.pprint_me.nativerun_exit_by_fail != (char*)0x1) { \ @@ -757,7 +778,7 @@ restore_absmi_regs(REGSTORE * old_regs) } \ return ((void *) OpAddress[Yap_op_from_opcode((*_PREG)->opc)]); \ } - + #else /* YAP_DBG_PREDS */ #define SUCCESSBACK() \ @@ -778,12 +799,12 @@ restore_absmi_regs(REGSTORE * old_regs) return ((void *) OpAddress[Yap_op_from_opcode((*_PREG)->opc) + ExpEnv.config_struc.current_displacement]); \ return ((void *) ((*_PREG)->opc)); \ } - + #define BACK() \ { \ return ((void *) OpAddress[Yap_op_from_opcode((*_PREG)->opc)]); \ } - + #endif /* YAP_DBG_PREDS */ #endif /* YAP_STAT_PREDS */ @@ -877,7 +898,7 @@ restore_absmi_regs(REGSTORE * old_regs) Label:{ print_instruction(PREG, ON_INTERPRETER); #endif /* YAP_JIT */ - + #else /* YAP_DBG_PREDS */ #define Op(Label,Type) \ @@ -887,13 +908,13 @@ restore_absmi_regs(REGSTORE * old_regs) Label:{ START_PREFETCH_W(Type) #define BOp(Label,Type) \ - Label:{ + Label:{ #define PBOp(Label,Type) \ Label:{ INIT_PREFETCH() #define OpRW(Label,Type) \ - Label:{ + Label:{ #endif /* YAP_DBG_PREDS */ @@ -1113,13 +1134,13 @@ Macros to check the limits of stacks } \ return external_labels[9]; \ } - + #else /* YAP_DBG_PREDS */ #define check_trail(x) if (__builtin_expect((Unsigned(CurrentTrailTop) < Unsigned(x)),0)) { \ return external_labels[9]; \ } - + #endif /* YAP_DBG_PREDS */ #define check_trail_in_indexing(x) if (__builtin_expect((Unsigned(CurrentTrailTop) < Unsigned(x)),0)) \ @@ -1136,7 +1157,7 @@ Macros to check the limits of stacks } \ goto notrailleft; \ } - + #else /* YAP_DBG_PREDS */ #define check_trail(x) if (__builtin_expect((Unsigned(CurrentTrailTop) < Unsigned(x)),0)) { \ @@ -1275,7 +1296,7 @@ Macros to check the limits of stacks #define store_yaam_regs_for_either(AP,d0) \ COUNT_CPS(); \ - pt1 --; /* Jump to CP_BASE */ \ + pt1 --; /* Jump to CP_BASE */ \ /* Save Information */ \ HBREG = HR; \ pt1->cp_tr = TR; \ @@ -1516,7 +1537,7 @@ Macros to check the limits of stacks } \ goto traced_fail; \ } - + #else /* YAP_DBG_PREDS */ #define FAIL() { \ @@ -1526,7 +1547,7 @@ Macros to check the limits of stacks #define TRACED_FAIL() { \ goto traced_fail; \ } - + #endif /* YAP_DBG_PREDS */ #else @@ -1635,7 +1656,7 @@ Macros to check the limits of stacks else { FAIL(); } \ } \ else { FAIL(); } - + #define traced_UnifyBound_TEST_ATTACHED(f,d0,pt0,d1) \ if (IsExtensionFunctor(f)) { \ if (unify_extension(f, d0, RepAppl(d0), d1)) \ @@ -1701,7 +1722,7 @@ typedef struct v_record { #if defined(IN_ABSMI_C) || defined(IN_UNIFY_C) -static int +static int IUnify_complex(CELL *pt0, CELL *pt0_end, CELL *pt1) { CACHE_REGS @@ -1728,7 +1749,7 @@ IUnify_complex(CELL *pt0, CELL *pt0_end, CELL *pt1) loop: while (pt0 < pt0_end) { - register CELL *ptd0 = pt0+1; + register CELL *ptd0 = pt0+1; register CELL d0; ++pt1; @@ -1881,7 +1902,7 @@ IUnify_complex(CELL *pt0, CELL *pt0_end, CELL *pt1) return FALSE; #ifdef THREADS #undef Yap_REGS -#define Yap_REGS (*Yap_regp) +#define Yap_REGS (*Yap_regp) #elif defined(SHADOW_REGS) #if defined(B) || defined(TR) #undef Yap_REGS @@ -1899,7 +1920,7 @@ IUnify_complex(CELL *pt0, CELL *pt0_end, CELL *pt1) #if defined(IN_ABSMI_C) || defined(IN_INLINES_C) -static int +static int iequ_complex(register CELL *pt0, register CELL *pt0_end, register CELL *pt1 ) @@ -1928,7 +1949,7 @@ iequ_complex(register CELL *pt0, register CELL *pt0_end, loop: while (pt0 < pt0_end) { - register CELL *ptd0 = pt0+1; + register CELL *ptd0 = pt0+1; register CELL d0; ++pt1; @@ -2083,7 +2104,7 @@ iequ_complex(register CELL *pt0, register CELL *pt0_end, return FALSE; #ifdef THREADS #undef Yap_REGS -#define Yap_REGS (*Yap_regp) +#define Yap_REGS (*Yap_regp) #elif defined(SHADOW_REGS) #if defined(B) || defined(TR) #undef Yap_REGS @@ -2206,10 +2227,15 @@ extern char fin[1024]; #ifndef _NATIVE #include + +#ifndef __cplusplus #include "JIT_Compiler.hpp" -extern struct JIT_Compiler *J; - +void* (*Yap_JitCall)(JIT_Compiler* jc, yamop* p); +void (* Yap_llvmShutdown)(void ) ; +Int (* Yap_traced_absmi)(void ) ; +extern JIT_Compiler *J; +#endif extern NativeContext *NativeArea; extern IntermediatecodeContext *IntermediatecodeArea; @@ -2259,4 +2285,3 @@ yamop* headoftrace; #endif #endif // ABSMI_H - diff --git a/H/amijit.h b/H/amijit.h index e06c9e5f0..4a43e8af8 100644 --- a/H/amijit.h +++ b/H/amijit.h @@ -489,6 +489,9 @@ typedef struct jit_handl_context { CELL torecomp; }jitman; } JitHandlContext; + +void **Yap_ABSMI_ControlLabels; + #endif /* YAP_JIT */ diff --git a/H/findclause.h b/H/findclause.h index 365513a18..7929ecd94 100644 --- a/H/findclause.h +++ b/H/findclause.h @@ -1533,12 +1533,6 @@ cl = NEXTOP(cl,Otapl); break; #endif -#ifdef YAP_JIT -#ifdef YAPOR -#endif -#ifdef TABLING -#endif -#endif default: clause->Tag = (CELL)NULL; return; diff --git a/H/headclause.h b/H/headclause.h index 2e87bc391..d6ef01a0e 100644 --- a/H/headclause.h +++ b/H/headclause.h @@ -814,12 +814,6 @@ cl = NEXTOP(cl,Otapl); break; #endif -#ifdef YAP_JIT -#ifdef YAPOR -#endif -#ifdef TABLING -#endif -#endif default: clause->Tag = (CELL)NULL; return; diff --git a/H/rclause.h b/H/rclause.h index 454732372..dcb70afab 100644 --- a/H/rclause.h +++ b/H/rclause.h @@ -935,905 +935,8 @@ restore_opcodes(yamop *pc, yamop *max USES_REGS) if (op == _Nstop || op == _copy_idb_term || op == _unify_idb_term) return; pc = NEXTOP(pc,e); break; -#endif -#ifdef YAP_JIT - /* instructions type D */ - case _traced_write_dbterm: - pc->y_u.D.D = DBGroundTermAdjust(pc->y_u.D.D); - pc = NEXTOP(pc,D); - break; - /* instructions type Illss */ - case _traced_enter_lu_pred: - pc->y_u.Illss.I = PtoLUIndexAdjust(pc->y_u.Illss.I); - pc->y_u.Illss.l1 = PtoOpAdjust(pc->y_u.Illss.l1); - pc->y_u.Illss.l2 = PtoOpAdjust(pc->y_u.Illss.l2); - pc->y_u.Illss.s = ConstantAdjust(pc->y_u.Illss.s); - pc->y_u.Illss.e = ConstantAdjust(pc->y_u.Illss.e); - opc = NEXTOP(pc,Illss); - pc = pc->y_u.Illss.l1; - break; - /* instructions type J */ - case _traced_jit_handler: - /* instructions type L */ - case _traced_alloc_for_logical_pred: - pc->y_u.L.ClBase = PtoLUClauseAdjust(pc->y_u.L.ClBase); - pc = NEXTOP(pc,L); - break; - /* instructions type N */ - case _traced_write_bigint: - pc->y_u.N.b = BlobTermInCodeAdjust(pc->y_u.N.b); - pc = NEXTOP(pc,N); - break; - /* instructions type Osblp */ - case _traced_either: - case _traced_or_else: - OrArgAdjust(pc->y_u.Osblp.or_arg); - pc->y_u.Osblp.s = ConstantAdjust(pc->y_u.Osblp.s); - pc->y_u.Osblp.bmap = CellPtoHeapAdjust(pc->y_u.Osblp.bmap); - pc->y_u.Osblp.l = PtoOpAdjust(pc->y_u.Osblp.l); - pc->y_u.Osblp.p0 = PtoPredAdjust(pc->y_u.Osblp.p0); - pc = NEXTOP(pc,Osblp); - break; - /* instructions type Osbmp */ - case _traced_p_execute: - case _traced_p_execute_tail: - OrArgAdjust(pc->y_u.Osbmp.or_arg); - pc->y_u.Osbmp.s = ConstantAdjust(pc->y_u.Osbmp.s); - pc->y_u.Osbmp.bmap = CellPtoHeapAdjust(pc->y_u.Osbmp.bmap); - pc->y_u.Osbmp.mod = ModuleAdjust(pc->y_u.Osbmp.mod); - pc->y_u.Osbmp.p0 = PtoPredAdjust(pc->y_u.Osbmp.p0); - pc = NEXTOP(pc,Osbmp); - break; - /* instructions type Osbpa */ - case _traced_ensure_space: - OrArgAdjust(pc->y_u.Osbpa.or_arg); - pc->y_u.Osbpa.s = ConstantAdjust(pc->y_u.Osbpa.s); - pc->y_u.Osbpa.bmap = CellPtoHeapAdjust(pc->y_u.Osbpa.bmap); - pc->y_u.Osbpa.p = PtoPredAdjust(pc->y_u.Osbpa.p); - pc->y_u.Osbpa.i = ArityAdjust(pc->y_u.Osbpa.i); - pc = NEXTOP(pc,Osbpa); - break; - /* instructions type Osbpp */ - case _traced_call: - case _traced_call_cpred: - case _traced_call_usercpred: - case _traced_fcall: - case _traced_p_execute2: - OrArgAdjust(pc->y_u.Osbpp.or_arg); - pc->y_u.Osbpp.s = ConstantAdjust(pc->y_u.Osbpp.s); - pc->y_u.Osbpp.bmap = CellPtoHeapAdjust(pc->y_u.Osbpp.bmap); - pc->y_u.Osbpp.p = PtoPredAdjust(pc->y_u.Osbpp.p); - pc->y_u.Osbpp.p0 = PtoPredAdjust(pc->y_u.Osbpp.p0); - pc = NEXTOP(pc,Osbpp); - break; - /* instructions type OtILl */ - case _traced_count_trust_logical: - case _traced_profiled_trust_logical: - case _traced_trust_logical: - OrArgAdjust(pc->y_u.OtILl.or_arg); - TabEntryAdjust(pc->y_u.OtILl.te); - pc->y_u.OtILl.block = PtoLUIndexAdjust(pc->y_u.OtILl.block); - pc->y_u.OtILl.d = PtoLUClauseAdjust(pc->y_u.OtILl.d); - pc->y_u.OtILl.n = PtoOpAdjust(pc->y_u.OtILl.n); - pc = opc; - break; - /* instructions type OtaLl */ - case _traced_count_retry_logical: - case _traced_profiled_retry_logical: - case _traced_retry_logical: - case _traced_try_logical: - OrArgAdjust(pc->y_u.OtaLl.or_arg); - TabEntryAdjust(pc->y_u.OtaLl.te); - pc->y_u.OtaLl.s = ArityAdjust(pc->y_u.OtaLl.s); - pc->y_u.OtaLl.d = PtoLUClauseAdjust(pc->y_u.OtaLl.d); - pc->y_u.OtaLl.n = PtoOpAdjust(pc->y_u.OtaLl.n); - pc = pc->y_u.OtaLl.n; - break; - /* instructions type OtapFs */ - case _traced_cut_c: - case _traced_cut_userc: - case _traced_retry_c: - case _traced_retry_userc: - case _traced_try_c: - case _traced_try_userc: - OrArgAdjust(pc->y_u.OtapFs.or_arg); - TabEntryAdjust(pc->y_u.OtapFs.te); - pc->y_u.OtapFs.s = ArityAdjust(pc->y_u.OtapFs.s); - pc->y_u.OtapFs.p = PtoPredAdjust(pc->y_u.OtapFs.p); - pc->y_u.OtapFs.f = ExternalFunctionAdjust(pc->y_u.OtapFs.f); - pc->y_u.OtapFs.extra = ConstantAdjust(pc->y_u.OtapFs.extra); - pc = NEXTOP(pc,OtapFs); - break; - /* instructions type Otapl */ - case _traced_count_retry_and_mark: - case _traced_count_retry_me: - case _traced_count_trust_me: - case _traced_profiled_retry_and_mark: - case _traced_profiled_retry_me: - case _traced_profiled_trust_me: - case _traced_retry: - case _traced_retry_and_mark: - case _traced_retry_me: - case _traced_spy_or_trymark: - case _traced_trust: - case _traced_trust_me: - case _traced_try_and_mark: - case _traced_try_clause: - case _traced_try_me: - OrArgAdjust(pc->y_u.Otapl.or_arg); - TabEntryAdjust(pc->y_u.Otapl.te); - pc->y_u.Otapl.s = ArityAdjust(pc->y_u.Otapl.s); - pc->y_u.Otapl.p = PtoPredAdjust(pc->y_u.Otapl.p); - pc->y_u.Otapl.d = PtoOpAdjust(pc->y_u.Otapl.d); - pc = NEXTOP(pc,Otapl); - break; - /* instructions type c */ - case _traced_write_atom: - pc->y_u.c.c = ConstantTermAdjust(pc->y_u.c.c); - pc = NEXTOP(pc,c); - break; - /* instructions type cc */ - case _traced_get_2atoms: - pc->y_u.cc.c1 = ConstantTermAdjust(pc->y_u.cc.c1); - pc->y_u.cc.c2 = ConstantTermAdjust(pc->y_u.cc.c2); - pc = NEXTOP(pc,cc); - break; - /* instructions type ccc */ - case _traced_get_3atoms: - pc->y_u.ccc.c1 = ConstantTermAdjust(pc->y_u.ccc.c1); - pc->y_u.ccc.c2 = ConstantTermAdjust(pc->y_u.ccc.c2); - pc->y_u.ccc.c3 = ConstantTermAdjust(pc->y_u.ccc.c3); - pc = NEXTOP(pc,ccc); - break; - /* instructions type cccc */ - case _traced_get_4atoms: - pc->y_u.cccc.c1 = ConstantTermAdjust(pc->y_u.cccc.c1); - pc->y_u.cccc.c2 = ConstantTermAdjust(pc->y_u.cccc.c2); - pc->y_u.cccc.c3 = ConstantTermAdjust(pc->y_u.cccc.c3); - pc->y_u.cccc.c4 = ConstantTermAdjust(pc->y_u.cccc.c4); - pc = NEXTOP(pc,cccc); - break; - /* instructions type ccccc */ - case _traced_get_5atoms: - pc->y_u.ccccc.c1 = ConstantTermAdjust(pc->y_u.ccccc.c1); - pc->y_u.ccccc.c2 = ConstantTermAdjust(pc->y_u.ccccc.c2); - pc->y_u.ccccc.c3 = ConstantTermAdjust(pc->y_u.ccccc.c3); - pc->y_u.ccccc.c4 = ConstantTermAdjust(pc->y_u.ccccc.c4); - pc->y_u.ccccc.c5 = ConstantTermAdjust(pc->y_u.ccccc.c5); - pc = NEXTOP(pc,ccccc); - break; - /* instructions type cccccc */ - case _traced_get_6atoms: - pc->y_u.cccccc.c1 = ConstantTermAdjust(pc->y_u.cccccc.c1); - pc->y_u.cccccc.c2 = ConstantTermAdjust(pc->y_u.cccccc.c2); - pc->y_u.cccccc.c3 = ConstantTermAdjust(pc->y_u.cccccc.c3); - pc->y_u.cccccc.c4 = ConstantTermAdjust(pc->y_u.cccccc.c4); - pc->y_u.cccccc.c5 = ConstantTermAdjust(pc->y_u.cccccc.c5); - pc->y_u.cccccc.c6 = ConstantTermAdjust(pc->y_u.cccccc.c6); - pc = NEXTOP(pc,cccccc); - break; - /* instructions type clll */ - case _traced_if_not_then: - pc->y_u.clll.c = ConstantTermAdjust(pc->y_u.clll.c); - pc->y_u.clll.l1 = PtoOpAdjust(pc->y_u.clll.l1); - pc->y_u.clll.l2 = PtoOpAdjust(pc->y_u.clll.l2); - pc->y_u.clll.l3 = PtoOpAdjust(pc->y_u.clll.l3); - pc = NEXTOP(pc,clll); - break; - /* instructions type d */ - case _traced_write_float: - DoubleInCodeAdjust(pc->y_u.d.d); - pc = NEXTOP(pc,d); - break; - /* instructions type e */ - case _traced_Nstop: - case _traced_allocate: - case _traced_copy_idb_term: - case _traced_expand_index: - case _traced_index_blob: - case _traced_index_dbref: - case _traced_index_long: - case _traced_index_pred: - case _traced_lock_pred: - case _traced_op_fail: - case _traced_p_equal: - case _traced_p_functor: - case _traced_pop: - case _traced_retry_eam: - case _traced_spy_pred: - case _traced_thread_local: - case _traced_trust_fail: - case _traced_undef_p: - case _traced_unify_idb_term: - case _traced_unlock_lu: - case _traced_write_l_list: - case _traced_write_list: - case _traced_write_void: - if (op == _Nstop || op == _copy_idb_term || op == _unify_idb_term) return; - pc = NEXTOP(pc,e); - break; - /* instructions type fa */ - case _traced_write_l_struc: - case _traced_write_struct: - pc->y_u.fa.f = FuncAdjust(pc->y_u.fa.f); - pc->y_u.fa.a = ArityAdjust(pc->y_u.fa.a); - pc = NEXTOP(pc,fa); - break; - /* instructions type i */ - case _traced_write_longint: - IntegerInCodeAdjust(pc->y_u.i.i); - pc = NEXTOP(pc,i); - break; - /* instructions type l */ - case _traced_Ystop: - case _traced_jump: - case _traced_jump_if_var: - case _traced_move_back: - case _traced_p_dif: - case _traced_p_eq: - case _traced_retry2: - case _traced_retry3: - case _traced_retry4: - case _traced_skip: - case _traced_try_clause2: - case _traced_try_clause3: - case _traced_try_clause4: - case _traced_try_in: - pc->y_u.l.l = PtoOpAdjust(pc->y_u.l.l); - if (op == _Ystop) return; - pc = NEXTOP(pc,l); - break; - /* instructions type llll */ - case _traced_switch_on_type: - pc->y_u.llll.l1 = PtoOpAdjust(pc->y_u.llll.l1); - pc->y_u.llll.l2 = PtoOpAdjust(pc->y_u.llll.l2); - pc->y_u.llll.l3 = PtoOpAdjust(pc->y_u.llll.l3); - pc->y_u.llll.l4 = PtoOpAdjust(pc->y_u.llll.l4); - pc = NEXTOP(pc,llll); - break; - /* instructions type lp */ - case _traced_user_switch: - pc->y_u.lp.l = PtoOpAdjust(pc->y_u.lp.l); - pc->y_u.lp.p = PtoPredAdjust(pc->y_u.lp.p); - pc = NEXTOP(pc,lp); - break; - /* instructions type o */ - case _traced_unify_l_list: - case _traced_unify_l_list_write: - case _traced_unify_l_void: - case _traced_unify_l_void_write: - case _traced_unify_list: - case _traced_unify_list_write: - case _traced_unify_void: - case _traced_unify_void_write: - pc->y_u.o.opcw = OpcodeAdjust(pc->y_u.o.opcw); - pc = NEXTOP(pc,o); - break; - /* instructions type oD */ - case _traced_unify_dbterm: - case _traced_unify_l_dbterm: - pc->y_u.oD.opcw = OpcodeAdjust(pc->y_u.oD.opcw); - pc->y_u.oD.D = DBGroundTermAdjust(pc->y_u.oD.D); - pc = NEXTOP(pc,oD); - break; - /* instructions type oN */ - case _traced_unify_bigint: - case _traced_unify_l_bigint: - pc->y_u.oN.opcw = OpcodeAdjust(pc->y_u.oN.opcw); - pc->y_u.oN.b = BlobTermInCodeAdjust(pc->y_u.oN.b); - pc = NEXTOP(pc,oN); - break; - /* instructions type oc */ - case _traced_unify_atom: - case _traced_unify_atom_write: - case _traced_unify_l_atom: - case _traced_unify_l_atom_write: - pc->y_u.oc.opcw = OpcodeAdjust(pc->y_u.oc.opcw); - pc->y_u.oc.c = ConstantTermAdjust(pc->y_u.oc.c); - pc = NEXTOP(pc,oc); - break; - /* instructions type od */ - case _traced_unify_float: - case _traced_unify_float_write: - case _traced_unify_l_float: - case _traced_unify_l_float_write: - pc->y_u.od.opcw = OpcodeAdjust(pc->y_u.od.opcw); - DoubleInCodeAdjust(pc->y_u.od.d); - pc = NEXTOP(pc,od); - break; - /* instructions type ofa */ - case _traced_unify_l_struc: - case _traced_unify_l_struc_write: - case _traced_unify_struct: - case _traced_unify_struct_write: - pc->y_u.ofa.opcw = OpcodeAdjust(pc->y_u.ofa.opcw); - pc->y_u.ofa.f = FuncAdjust(pc->y_u.ofa.f); - pc->y_u.ofa.a = ArityAdjust(pc->y_u.ofa.a); - pc = NEXTOP(pc,ofa); - break; - /* instructions type oi */ - case _traced_unify_l_longint: - case _traced_unify_l_longint_write: - case _traced_unify_longint: - case _traced_unify_longint_write: - pc->y_u.oi.opcw = OpcodeAdjust(pc->y_u.oi.opcw); - IntegerInCodeAdjust(pc->y_u.oi.i); - pc = NEXTOP(pc,oi); - break; - /* instructions type ollll */ - case _traced_switch_list_nl: - pc->y_u.ollll.pop = OpcodeAdjust(pc->y_u.ollll.pop); - pc->y_u.ollll.l1 = PtoOpAdjust(pc->y_u.ollll.l1); - pc->y_u.ollll.l2 = PtoOpAdjust(pc->y_u.ollll.l2); - pc->y_u.ollll.l3 = PtoOpAdjust(pc->y_u.ollll.l3); - pc->y_u.ollll.l4 = PtoOpAdjust(pc->y_u.ollll.l4); - pc = NEXTOP(pc,ollll); - break; - /* instructions type os */ - case _traced_run_eam: - case _traced_unify_l_n_voids: - case _traced_unify_l_n_voids_write: - case _traced_unify_n_voids: - case _traced_unify_n_voids_write: - pc->y_u.os.opcw = OpcodeAdjust(pc->y_u.os.opcw); - pc->y_u.os.s = ConstantAdjust(pc->y_u.os.s); - pc = NEXTOP(pc,os); - break; - /* instructions type osc */ - case _traced_unify_n_atoms: - case _traced_unify_n_atoms_write: - pc->y_u.osc.opcw = OpcodeAdjust(pc->y_u.osc.opcw); - pc->y_u.osc.s = ConstantAdjust(pc->y_u.osc.s); - pc->y_u.osc.c = ConstantTermAdjust(pc->y_u.osc.c); - pc = NEXTOP(pc,osc); - break; - /* instructions type ox */ - case _traced_save_appl_x: - case _traced_save_appl_x_write: - case _traced_save_pair_x: - case _traced_save_pair_x_write: - case _traced_unify_l_x_loc: - case _traced_unify_l_x_loc_write: - case _traced_unify_l_x_val: - case _traced_unify_l_x_val_write: - case _traced_unify_l_x_var: - case _traced_unify_l_x_var_write: - case _traced_unify_x_loc: - case _traced_unify_x_loc_write: - case _traced_unify_x_val: - case _traced_unify_x_val_write: - case _traced_unify_x_var: - case _traced_unify_x_var_write: - pc->y_u.ox.opcw = OpcodeAdjust(pc->y_u.ox.opcw); - pc->y_u.ox.x = XAdjust(pc->y_u.ox.x); - pc = NEXTOP(pc,ox); - break; - /* instructions type oxx */ - case _traced_unify_l_x_var2: - case _traced_unify_l_x_var2_write: - case _traced_unify_x_var2: - case _traced_unify_x_var2_write: - pc->y_u.oxx.opcw = OpcodeAdjust(pc->y_u.oxx.opcw); - pc->y_u.oxx.xl = XAdjust(pc->y_u.oxx.xl); - pc->y_u.oxx.xr = XAdjust(pc->y_u.oxx.xr); - pc = NEXTOP(pc,oxx); - break; - /* instructions type oy */ - case _traced_save_appl_y: - case _traced_save_appl_y_write: - case _traced_save_pair_y: - case _traced_save_pair_y_write: - case _traced_unify_l_y_loc: - case _traced_unify_l_y_loc_write: - case _traced_unify_l_y_val: - case _traced_unify_l_y_val_write: - case _traced_unify_l_y_var: - case _traced_unify_l_y_var_write: - case _traced_unify_y_loc: - case _traced_unify_y_loc_write: - case _traced_unify_y_val: - case _traced_unify_y_val_write: - case _traced_unify_y_var: - case _traced_unify_y_var_write: - pc->y_u.oy.opcw = OpcodeAdjust(pc->y_u.oy.opcw); - pc->y_u.oy.y = YAdjust(pc->y_u.oy.y); - pc = NEXTOP(pc,oy); - break; - /* instructions type p */ - case _traced_count_call: - case _traced_count_retry: - case _traced_deallocate: - case _traced_enter_profiling: - case _traced_lock_lu: - case _traced_procceed: - case _traced_retry_profiled: - pc->y_u.p.p = PtoPredAdjust(pc->y_u.p.p); - pc = NEXTOP(pc,p); - break; - /* instructions type plxxs */ - case _traced_call_bfunc_xx: - pc->y_u.plxxs.p = PtoPredAdjust(pc->y_u.plxxs.p); - pc->y_u.plxxs.f = PtoOpAdjust(pc->y_u.plxxs.f); - pc->y_u.plxxs.x1 = XAdjust(pc->y_u.plxxs.x1); - pc->y_u.plxxs.x2 = XAdjust(pc->y_u.plxxs.x2); - pc->y_u.plxxs.flags = ConstantAdjust(pc->y_u.plxxs.flags); - pc = NEXTOP(pc,plxxs); - break; - /* instructions type plxys */ - case _traced_call_bfunc_xy: - case _traced_call_bfunc_yx: - pc->y_u.plxys.p = PtoPredAdjust(pc->y_u.plxys.p); - pc->y_u.plxys.f = PtoOpAdjust(pc->y_u.plxys.f); - pc->y_u.plxys.x = XAdjust(pc->y_u.plxys.x); - pc->y_u.plxys.y = YAdjust(pc->y_u.plxys.y); - pc->y_u.plxys.flags = ConstantAdjust(pc->y_u.plxys.flags); - pc = NEXTOP(pc,plxys); - break; - /* instructions type plyys */ - case _traced_call_bfunc_yy: - pc->y_u.plyys.p = PtoPredAdjust(pc->y_u.plyys.p); - pc->y_u.plyys.f = PtoOpAdjust(pc->y_u.plyys.f); - pc->y_u.plyys.y1 = YAdjust(pc->y_u.plyys.y1); - pc->y_u.plyys.y2 = YAdjust(pc->y_u.plyys.y2); - pc->y_u.plyys.flags = ConstantAdjust(pc->y_u.plyys.flags); - pc = NEXTOP(pc,plyys); - break; - /* instructions type pp */ - case _traced_dexecute: - case _traced_execute: - case _traced_execute_cpred: - pc->y_u.pp.p = PtoPredAdjust(pc->y_u.pp.p); - pc->y_u.pp.p0 = PtoPredAdjust(pc->y_u.pp.p0); - pc = NEXTOP(pc,pp); - break; - /* instructions type s */ - case _traced_cut: - case _traced_cut_e: - case _traced_cut_t: - case _traced_pop_n: - case _traced_write_n_voids: - pc->y_u.s.s = ConstantAdjust(pc->y_u.s.s); - pc = NEXTOP(pc,s); - break; - /* instructions type sc */ - case _traced_write_n_atoms: - pc->y_u.sc.s = ConstantAdjust(pc->y_u.sc.s); - pc->y_u.sc.c = ConstantTermAdjust(pc->y_u.sc.c); - pc = NEXTOP(pc,sc); - break; - /* instructions type sllll */ - case _traced_switch_on_sub_arg_type: - pc->y_u.sllll.s = ConstantAdjust(pc->y_u.sllll.s); - pc->y_u.sllll.l1 = PtoOpAdjust(pc->y_u.sllll.l1); - pc->y_u.sllll.l2 = PtoOpAdjust(pc->y_u.sllll.l2); - pc->y_u.sllll.l3 = PtoOpAdjust(pc->y_u.sllll.l3); - pc->y_u.sllll.l4 = PtoOpAdjust(pc->y_u.sllll.l4); - pc = NEXTOP(pc,sllll); - break; - /* instructions type slp */ - case _traced_call_c_wfail: - pc->y_u.slp.s = ConstantAdjust(pc->y_u.slp.s); - pc->y_u.slp.l = PtoOpAdjust(pc->y_u.slp.l); - pc->y_u.slp.p = PtoPredAdjust(pc->y_u.slp.p); - pc = NEXTOP(pc,slp); - break; - /* instructions type sssl */ - case _traced_go_on_cons: - case _traced_go_on_func: - case _traced_if_cons: - case _traced_if_func: - case _traced_switch_on_cons: - case _traced_switch_on_func: - pc->y_u.sssl.s = ConstantAdjust(pc->y_u.sssl.s); - pc->y_u.sssl.e = ConstantAdjust(pc->y_u.sssl.e); - pc->y_u.sssl.w = ConstantAdjust(pc->y_u.sssl.w); - pc->y_u.sssl.l = PtoOpAdjust(pc->y_u.sssl.l); - AdjustSwitchTable(op, pc->y_u.sssl.l, pc->y_u.sssl.s); - pc = NEXTOP(pc,sssl); - break; - /* instructions type sssllp */ - case _traced_expand_clauses: - pc->y_u.sssllp.s1 = ConstantAdjust(pc->y_u.sssllp.s1); - pc->y_u.sssllp.s2 = ConstantAdjust(pc->y_u.sssllp.s2); - pc->y_u.sssllp.s3 = ConstantAdjust(pc->y_u.sssllp.s3); - pc->y_u.sssllp.sprev = PtoOpAdjust(pc->y_u.sssllp.sprev); - pc->y_u.sssllp.snext = PtoOpAdjust(pc->y_u.sssllp.snext); - pc->y_u.sssllp.p = PtoPredAdjust(pc->y_u.sssllp.p); - pc = NEXTOP(pc,sssllp); - break; - /* instructions type x */ - case _traced_get_list: - case _traced_put_list: - case _traced_save_b_x: - case _traced_write_x_loc: - case _traced_write_x_val: - case _traced_write_x_var: - pc->y_u.x.x = XAdjust(pc->y_u.x.x); - pc = NEXTOP(pc,x); - break; - /* instructions type xD */ - case _traced_get_dbterm: - case _traced_put_dbterm: - pc->y_u.xD.x = XAdjust(pc->y_u.xD.x); - pc->y_u.xD.D = DBGroundTermAdjust(pc->y_u.xD.D); - pc = NEXTOP(pc,xD); - break; - /* instructions type xN */ - case _traced_get_bigint: - case _traced_put_bigint: - pc->y_u.xN.x = XAdjust(pc->y_u.xN.x); - pc->y_u.xN.b = BlobTermInCodeAdjust(pc->y_u.xN.b); - pc = NEXTOP(pc,xN); - break; - /* instructions type xc */ - case _traced_get_atom: - case _traced_put_atom: - pc->y_u.xc.x = XAdjust(pc->y_u.xc.x); - pc->y_u.xc.c = ConstantTermAdjust(pc->y_u.xc.c); - pc = NEXTOP(pc,xc); - break; - /* instructions type xd */ - case _traced_get_float: - case _traced_put_float: - pc->y_u.xd.x = XAdjust(pc->y_u.xd.x); - DoubleInCodeAdjust(pc->y_u.xd.d); - pc = NEXTOP(pc,xd); - break; - /* instructions type xfa */ - case _traced_get_struct: - case _traced_put_struct: - pc->y_u.xfa.x = XAdjust(pc->y_u.xfa.x); - pc->y_u.xfa.f = FuncAdjust(pc->y_u.xfa.f); - pc->y_u.xfa.a = ArityAdjust(pc->y_u.xfa.a); - pc = NEXTOP(pc,xfa); - break; - /* instructions type xi */ - case _traced_get_longint: - case _traced_put_longint: - pc->y_u.xi.x = XAdjust(pc->y_u.xi.x); - IntegerInCodeAdjust(pc->y_u.xi.i); - pc = NEXTOP(pc,xi); - break; - /* instructions type xl */ - case _traced_p_atom_x: - case _traced_p_atomic_x: - case _traced_p_compound_x: - case _traced_p_db_ref_x: - case _traced_p_float_x: - case _traced_p_integer_x: - case _traced_p_nonvar_x: - case _traced_p_number_x: - case _traced_p_primitive_x: - case _traced_p_var_x: - pc->y_u.xl.x = XAdjust(pc->y_u.xl.x); - pc->y_u.xl.F = PtoOpAdjust(pc->y_u.xl.F); - pc = NEXTOP(pc,xl); - break; - /* instructions type xll */ - case _traced_jump_if_nonvar: - pc->y_u.xll.x = XAdjust(pc->y_u.xll.x); - pc->y_u.xll.l1 = PtoOpAdjust(pc->y_u.xll.l1); - pc->y_u.xll.l2 = PtoOpAdjust(pc->y_u.xll.l2); - pc = NEXTOP(pc,xll); - break; - /* instructions type xllll */ - case _traced_switch_on_arg_type: - pc->y_u.xllll.x = XAdjust(pc->y_u.xllll.x); - pc->y_u.xllll.l1 = PtoOpAdjust(pc->y_u.xllll.l1); - pc->y_u.xllll.l2 = PtoOpAdjust(pc->y_u.xllll.l2); - pc->y_u.xllll.l3 = PtoOpAdjust(pc->y_u.xllll.l3); - pc->y_u.xllll.l4 = PtoOpAdjust(pc->y_u.xllll.l4); - pc = NEXTOP(pc,xllll); - break; - /* instructions type xps */ - case _traced_commit_b_x: - pc->y_u.xps.x = XAdjust(pc->y_u.xps.x); - pc->y_u.xps.p0 = PtoPredAdjust(pc->y_u.xps.p0); - pc->y_u.xps.s = ConstantAdjust(pc->y_u.xps.s); - pc = NEXTOP(pc,xps); - break; - /* instructions type xx */ - case _traced_get_x_val: - case _traced_get_x_var: - case _traced_gl_void_valx: - case _traced_gl_void_varx: - case _traced_glist_valx: - case _traced_put_x_val: - case _traced_put_x_var: - pc->y_u.xx.xl = XAdjust(pc->y_u.xx.xl); - pc->y_u.xx.xr = XAdjust(pc->y_u.xx.xr); - pc = NEXTOP(pc,xx); - break; - /* instructions type xxc */ - case _traced_p_func2s_cv: - pc->y_u.xxc.x = XAdjust(pc->y_u.xxc.x); - pc->y_u.xxc.xi = XAdjust(pc->y_u.xxc.xi); - pc->y_u.xxc.c = ConstantTermAdjust(pc->y_u.xxc.c); - pc = NEXTOP(pc,xxc); - break; - /* instructions type xxn */ - case _traced_p_and_vc: - case _traced_p_arg_cv: - case _traced_p_div_cv: - case _traced_p_div_vc: - case _traced_p_func2s_vc: - case _traced_p_minus_cv: - case _traced_p_or_vc: - case _traced_p_plus_vc: - case _traced_p_sll_cv: - case _traced_p_sll_vc: - case _traced_p_slr_cv: - case _traced_p_slr_vc: - case _traced_p_times_vc: - pc->y_u.xxn.x = XAdjust(pc->y_u.xxn.x); - pc->y_u.xxn.xi = XAdjust(pc->y_u.xxn.xi); - pc->y_u.xxn.c = IntegerAdjust(pc->y_u.xxn.c); - pc = NEXTOP(pc,xxn); - break; - /* instructions type xxx */ - case _traced_p_and_vv: - case _traced_p_arg_vv: - case _traced_p_div_vv: - case _traced_p_func2f_xx: - case _traced_p_func2s_vv: - case _traced_p_minus_vv: - case _traced_p_or_vv: - case _traced_p_plus_vv: - case _traced_p_sll_vv: - case _traced_p_slr_vv: - case _traced_p_times_vv: - pc->y_u.xxx.x = XAdjust(pc->y_u.xxx.x); - pc->y_u.xxx.x1 = XAdjust(pc->y_u.xxx.x1); - pc->y_u.xxx.x2 = XAdjust(pc->y_u.xxx.x2); - pc = NEXTOP(pc,xxx); - break; - /* instructions type xxxx */ - case _traced_put_xx_val: - pc->y_u.xxxx.xl1 = XAdjust(pc->y_u.xxxx.xl1); - pc->y_u.xxxx.xl2 = XAdjust(pc->y_u.xxxx.xl2); - pc->y_u.xxxx.xr1 = XAdjust(pc->y_u.xxxx.xr1); - pc->y_u.xxxx.xr2 = XAdjust(pc->y_u.xxxx.xr2); - pc = NEXTOP(pc,xxxx); - break; - /* instructions type xxy */ - case _traced_p_func2f_xy: - pc->y_u.xxy.x = XAdjust(pc->y_u.xxy.x); - pc->y_u.xxy.x1 = XAdjust(pc->y_u.xxy.x1); - pc->y_u.xxy.y2 = YAdjust(pc->y_u.xxy.y2); - pc = NEXTOP(pc,xxy); - break; - /* instructions type y */ - case _traced_save_b_y: - case _traced_write_y_loc: - case _traced_write_y_val: - case _traced_write_y_var: - pc->y_u.y.y = YAdjust(pc->y_u.y.y); - pc = NEXTOP(pc,y); - break; - /* instructions type yl */ - case _traced_p_atom_y: - case _traced_p_atomic_y: - case _traced_p_compound_y: - case _traced_p_db_ref_y: - case _traced_p_float_y: - case _traced_p_integer_y: - case _traced_p_nonvar_y: - case _traced_p_number_y: - case _traced_p_primitive_y: - case _traced_p_var_y: - pc->y_u.yl.y = YAdjust(pc->y_u.yl.y); - pc->y_u.yl.F = PtoOpAdjust(pc->y_u.yl.F); - pc = NEXTOP(pc,yl); - break; - /* instructions type yps */ - case _traced_commit_b_y: - pc->y_u.yps.y = YAdjust(pc->y_u.yps.y); - pc->y_u.yps.p0 = PtoPredAdjust(pc->y_u.yps.p0); - pc->y_u.yps.s = ConstantAdjust(pc->y_u.yps.s); - pc = NEXTOP(pc,yps); - break; - /* instructions type yx */ - case _traced_get_y_val: - case _traced_get_y_var: - case _traced_gl_void_valy: - case _traced_gl_void_vary: - case _traced_glist_valy: - case _traced_put_unsafe: - case _traced_put_y_val: - case _traced_put_y_var: - pc->y_u.yx.y = YAdjust(pc->y_u.yx.y); - pc->y_u.yx.x = XAdjust(pc->y_u.yx.x); - pc = NEXTOP(pc,yx); - break; - /* instructions type yxn */ - case _traced_p_and_y_vc: - case _traced_p_arg_y_cv: - case _traced_p_div_y_cv: - case _traced_p_div_y_vc: - case _traced_p_func2s_y_cv: - case _traced_p_func2s_y_vc: - case _traced_p_minus_y_cv: - case _traced_p_or_y_vc: - case _traced_p_plus_y_vc: - case _traced_p_sll_y_cv: - case _traced_p_sll_y_vc: - case _traced_p_slr_y_cv: - case _traced_p_slr_y_vc: - case _traced_p_times_y_vc: - pc->y_u.yxn.y = YAdjust(pc->y_u.yxn.y); - pc->y_u.yxn.xi = XAdjust(pc->y_u.yxn.xi); - pc->y_u.yxn.c = IntegerAdjust(pc->y_u.yxn.c); - pc = NEXTOP(pc,yxn); - break; - /* instructions type yxx */ - case _traced_p_and_y_vv: - case _traced_p_arg_y_vv: - case _traced_p_div_y_vv: - case _traced_p_func2f_yx: - case _traced_p_func2s_y_vv: - case _traced_p_minus_y_vv: - case _traced_p_or_y_vv: - case _traced_p_plus_y_vv: - case _traced_p_sll_y_vv: - case _traced_p_slr_y_vv: - case _traced_p_times_y_vv: - pc->y_u.yxx.y = YAdjust(pc->y_u.yxx.y); - pc->y_u.yxx.x1 = XAdjust(pc->y_u.yxx.x1); - pc->y_u.yxx.x2 = XAdjust(pc->y_u.yxx.x2); - pc = NEXTOP(pc,yxx); - break; - /* instructions type yyx */ - case _traced_p_func2f_yy: - pc->y_u.yyx.y1 = YAdjust(pc->y_u.yyx.y1); - pc->y_u.yyx.y2 = YAdjust(pc->y_u.yyx.y2); - pc->y_u.yyx.x = XAdjust(pc->y_u.yyx.x); - pc = NEXTOP(pc,yyx); - break; - /* instructions type yyxx */ - case _traced_get_yy_var: - case _traced_put_y_vals: - pc->y_u.yyxx.y1 = YAdjust(pc->y_u.yyxx.y1); - pc->y_u.yyxx.y2 = YAdjust(pc->y_u.yyxx.y2); - pc->y_u.yyxx.x1 = XAdjust(pc->y_u.yyxx.x1); - pc->y_u.yyxx.x2 = XAdjust(pc->y_u.yyxx.x2); - pc = NEXTOP(pc,yyxx); - break; -#ifdef YAPOR - /* instructions type Otapl */ - case _traced_getwork: - case _traced_getwork_seq: - case _traced_sync: - OrArgAdjust(pc->y_u.Otapl.or_arg); - TabEntryAdjust(pc->y_u.Otapl.te); - pc->y_u.Otapl.s = ArityAdjust(pc->y_u.Otapl.s); - pc->y_u.Otapl.p = PtoPredAdjust(pc->y_u.Otapl.p); - pc->y_u.Otapl.d = PtoOpAdjust(pc->y_u.Otapl.d); - pc = NEXTOP(pc,Otapl); - break; - /* instructions type e */ - case _traced_getwork_first_time: - if (op == _Nstop || op == _copy_idb_term || op == _unify_idb_term) return; - pc = NEXTOP(pc,e); - break; -#endif -#ifdef TABLING - /* instructions type Otapl */ - case _traced_table_answer_resolution: - case _traced_table_answer_resolution_completion: - case _traced_table_completion: - case _traced_table_load_answer: - case _traced_table_retry: - case _traced_table_retry_me: - case _traced_table_trust: - case _traced_table_trust_me: - case _traced_table_try: - case _traced_table_try_answer: - case _traced_table_try_me: - case _traced_table_try_single: - OrArgAdjust(pc->y_u.Otapl.or_arg); - TabEntryAdjust(pc->y_u.Otapl.te); - pc->y_u.Otapl.s = ArityAdjust(pc->y_u.Otapl.s); - pc->y_u.Otapl.p = PtoPredAdjust(pc->y_u.Otapl.p); - pc->y_u.Otapl.d = PtoOpAdjust(pc->y_u.Otapl.d); - pc = NEXTOP(pc,Otapl); - break; - /* instructions type e */ - case _traced_clause_with_cut: - if (op == _Nstop || op == _copy_idb_term || op == _unify_idb_term) return; - pc = NEXTOP(pc,e); - break; - /* instructions type s */ - case _traced_table_new_answer: - pc->y_u.s.s = ConstantAdjust(pc->y_u.s.s); - pc = NEXTOP(pc,s); - break; - /* instructions type e */ - case _traced_trie_do_appl: - case _traced_trie_do_appl_in_pair: - case _traced_trie_do_atom: - case _traced_trie_do_atom_in_pair: - case _traced_trie_do_bigint: - case _traced_trie_do_double: - case _traced_trie_do_extension: - case _traced_trie_do_gterm: - case _traced_trie_do_longint: - case _traced_trie_do_null: - case _traced_trie_do_null_in_pair: - case _traced_trie_do_pair: - case _traced_trie_do_val: - case _traced_trie_do_val_in_pair: - case _traced_trie_do_var: - case _traced_trie_do_var_in_pair: - case _traced_trie_retry_appl: - case _traced_trie_retry_appl_in_pair: - case _traced_trie_retry_atom: - case _traced_trie_retry_atom_in_pair: - case _traced_trie_retry_bigint: - case _traced_trie_retry_double: - case _traced_trie_retry_extension: - case _traced_trie_retry_gterm: - case _traced_trie_retry_longint: - case _traced_trie_retry_null: - case _traced_trie_retry_null_in_pair: - case _traced_trie_retry_pair: - case _traced_trie_retry_val: - case _traced_trie_retry_val_in_pair: - case _traced_trie_retry_var: - case _traced_trie_retry_var_in_pair: - case _traced_trie_trust_appl: - case _traced_trie_trust_appl_in_pair: - case _traced_trie_trust_atom: - case _traced_trie_trust_atom_in_pair: - case _traced_trie_trust_bigint: - case _traced_trie_trust_double: - case _traced_trie_trust_extension: - case _traced_trie_trust_gterm: - case _traced_trie_trust_longint: - case _traced_trie_trust_null: - case _traced_trie_trust_null_in_pair: - case _traced_trie_trust_pair: - case _traced_trie_trust_val: - case _traced_trie_trust_val_in_pair: - case _traced_trie_trust_var: - case _traced_trie_trust_var_in_pair: - case _traced_trie_try_appl: - case _traced_trie_try_appl_in_pair: - case _traced_trie_try_atom: - case _traced_trie_try_atom_in_pair: - case _traced_trie_try_bigint: - case _traced_trie_try_double: - case _traced_trie_try_extension: - case _traced_trie_try_gterm: - case _traced_trie_try_longint: - case _traced_trie_try_null: - case _traced_trie_try_null_in_pair: - case _traced_trie_try_pair: - case _traced_trie_try_val: - case _traced_trie_try_val_in_pair: - case _traced_trie_try_var: - case _traced_trie_try_var_in_pair: - if (op == _Nstop || op == _copy_idb_term || op == _unify_idb_term) return; - pc = NEXTOP(pc,e); - break; -#endif #endif /* this instruction is hardwired */ -#ifdef YAP_JIT - case _traced_or_last: -#ifdef YAPOR - OrArgAdjust(pc->y_u.Osblp.or_arg); - pc->y_u.Osblp.s = ConstantAdjust(pc->y_u.Osblp.s); - pc->y_u.Osblp.bmap = CellPtoHeapAdjust(pc->y_u.Osblp.bmap); - pc->y_u.Osblp.l = PtoOpAdjust(pc->y_u.Osblp.l); - pc->y_u.Osblp.p0 = PtoPredAdjust(pc->y_u.Osblp.p0); - pc = NEXTOP(pc,Osblp); - break; -#else - pc->y_u.p.p = PtoPredAdjust(pc->y_u.p.p); - pc = NEXTOP(pc,p); - break; -#endif -#endif case _or_last: #ifdef YAPOR OrArgAdjust(pc->y_u.Osblp.or_arg); diff --git a/H/saveclause.h b/H/saveclause.h index 7b1f5dc31..04d7fe409 100644 --- a/H/saveclause.h +++ b/H/saveclause.h @@ -960,916 +960,6 @@ pc = NEXTOP(pc,e); break; #endif -#ifdef YAP_JIT - /* instructions type D */ - case _traced_write_dbterm: - CHECK(save_DBGroundTerm(stream, pc->y_u.D.D)); - pc = NEXTOP(pc,D); - break; - /* instructions type Illss */ - case _traced_enter_lu_pred: - CHECK(save_PtoLUIndex(stream, pc->y_u.Illss.I)); - CHECK(save_PtoOp(stream, pc->y_u.Illss.l1)); - CHECK(save_PtoOp(stream, pc->y_u.Illss.l2)); - CHECK(save_Constant(stream, pc->y_u.Illss.s)); - CHECK(save_Constant(stream, pc->y_u.Illss.e)); - pc = NEXTOP(pc,Illss); - break; - /* instructions type J */ - case _traced_jit_handler: - /* instructions type L */ - case _traced_alloc_for_logical_pred: - CHECK(save_PtoLUClause(stream, pc->y_u.L.ClBase)); - pc = NEXTOP(pc,L); - break; - /* instructions type N */ - case _traced_write_bigint: - CHECK(save_BlobTermInCode(stream, pc->y_u.N.b)); - pc = NEXTOP(pc,N); - break; - /* instructions type Osblp */ - case _traced_either: - case _traced_or_else: -#ifdef YAPOR - CHECK(save_OrArg(stream, pc->y_u.Osblp.or_arg)); -#endif - CHECK(save_Constant(stream, pc->y_u.Osblp.s)); - CHECK(save_CellPtoHeap(stream, pc->y_u.Osblp.bmap)); - CHECK(save_PtoOp(stream, pc->y_u.Osblp.l)); - CHECK(save_PtoPred(stream, pc->y_u.Osblp.p0)); - pc = NEXTOP(pc,Osblp); - break; - /* instructions type Osbmp */ - case _traced_p_execute: - case _traced_p_execute_tail: -#ifdef YAPOR - CHECK(save_OrArg(stream, pc->y_u.Osbmp.or_arg)); -#endif - CHECK(save_Constant(stream, pc->y_u.Osbmp.s)); - CHECK(save_CellPtoHeap(stream, pc->y_u.Osbmp.bmap)); - CHECK(save_Module(stream, pc->y_u.Osbmp.mod)); - CHECK(save_PtoPred(stream, pc->y_u.Osbmp.p0)); - pc = NEXTOP(pc,Osbmp); - break; - /* instructions type Osbpa */ - case _traced_ensure_space: -#ifdef YAPOR - CHECK(save_OrArg(stream, pc->y_u.Osbpa.or_arg)); -#endif - CHECK(save_Constant(stream, pc->y_u.Osbpa.s)); - CHECK(save_CellPtoHeap(stream, pc->y_u.Osbpa.bmap)); - CHECK(save_PtoPred(stream, pc->y_u.Osbpa.p)); - CHECK(save_Arity(stream, pc->y_u.Osbpa.i)); - pc = NEXTOP(pc,Osbpa); - break; - /* instructions type Osbpp */ - case _traced_call: - case _traced_call_cpred: - case _traced_call_usercpred: - case _traced_fcall: - case _traced_p_execute2: -#ifdef YAPOR - CHECK(save_OrArg(stream, pc->y_u.Osbpp.or_arg)); -#endif - CHECK(save_Constant(stream, pc->y_u.Osbpp.s)); - CHECK(save_CellPtoHeap(stream, pc->y_u.Osbpp.bmap)); - CHECK(save_PtoPred(stream, pc->y_u.Osbpp.p)); - CHECK(save_PtoPred(stream, pc->y_u.Osbpp.p0)); - pc = NEXTOP(pc,Osbpp); - break; - /* instructions type OtILl */ - case _traced_count_trust_logical: - case _traced_profiled_trust_logical: - case _traced_trust_logical: -#ifdef YAPOR - CHECK(save_OrArg(stream, pc->y_u.OtILl.or_arg)); -#endif -#ifdef TABLING - CHECK(save_TabEntry(stream, pc->y_u.OtILl.te)); -#endif - CHECK(save_PtoLUIndex(stream, pc->y_u.OtILl.block)); - CHECK(save_PtoLUClause(stream, pc->y_u.OtILl.d)); - CHECK(save_PtoOp(stream, pc->y_u.OtILl.n)); - pc = NEXTOP(pc,OtILl); - break; - /* instructions type OtaLl */ - case _traced_count_retry_logical: - case _traced_profiled_retry_logical: - case _traced_retry_logical: - case _traced_try_logical: -#ifdef YAPOR - CHECK(save_OrArg(stream, pc->y_u.OtaLl.or_arg)); -#endif -#ifdef TABLING - CHECK(save_TabEntry(stream, pc->y_u.OtaLl.te)); -#endif - CHECK(save_Arity(stream, pc->y_u.OtaLl.s)); - CHECK(save_PtoLUClause(stream, pc->y_u.OtaLl.d)); - CHECK(save_PtoOp(stream, pc->y_u.OtaLl.n)); - pc = NEXTOP(pc,OtaLl); - break; - /* instructions type OtapFs */ - case _traced_cut_c: - case _traced_cut_userc: - case _traced_retry_c: - case _traced_retry_userc: - case _traced_try_c: - case _traced_try_userc: -#ifdef YAPOR - CHECK(save_OrArg(stream, pc->y_u.OtapFs.or_arg)); -#endif -#ifdef TABLING - CHECK(save_TabEntry(stream, pc->y_u.OtapFs.te)); -#endif - CHECK(save_Arity(stream, pc->y_u.OtapFs.s)); - CHECK(save_PtoPred(stream, pc->y_u.OtapFs.p)); - CHECK(save_ExternalFunction(stream, pc->y_u.OtapFs.f)); - CHECK(save_Constant(stream, pc->y_u.OtapFs.extra)); - pc = NEXTOP(pc,OtapFs); - break; - /* instructions type Otapl */ - case _traced_count_retry_and_mark: - case _traced_count_retry_me: - case _traced_count_trust_me: - case _traced_profiled_retry_and_mark: - case _traced_profiled_retry_me: - case _traced_profiled_trust_me: - case _traced_retry: - case _traced_retry_and_mark: - case _traced_retry_me: - case _traced_spy_or_trymark: - case _traced_trust: - case _traced_trust_me: - case _traced_try_and_mark: - case _traced_try_clause: - case _traced_try_me: -#ifdef YAPOR - CHECK(save_OrArg(stream, pc->y_u.Otapl.or_arg)); -#endif -#ifdef TABLING - CHECK(save_TabEntry(stream, pc->y_u.Otapl.te)); -#endif - CHECK(save_Arity(stream, pc->y_u.Otapl.s)); - CHECK(save_PtoPred(stream, pc->y_u.Otapl.p)); - CHECK(save_PtoOp(stream, pc->y_u.Otapl.d)); - pc = NEXTOP(pc,Otapl); - break; - /* instructions type c */ - case _traced_write_atom: - CHECK(save_ConstantTerm(stream, pc->y_u.c.c)); - pc = NEXTOP(pc,c); - break; - /* instructions type cc */ - case _traced_get_2atoms: - CHECK(save_ConstantTerm(stream, pc->y_u.cc.c1)); - CHECK(save_ConstantTerm(stream, pc->y_u.cc.c2)); - pc = NEXTOP(pc,cc); - break; - /* instructions type ccc */ - case _traced_get_3atoms: - CHECK(save_ConstantTerm(stream, pc->y_u.ccc.c1)); - CHECK(save_ConstantTerm(stream, pc->y_u.ccc.c2)); - CHECK(save_ConstantTerm(stream, pc->y_u.ccc.c3)); - pc = NEXTOP(pc,ccc); - break; - /* instructions type cccc */ - case _traced_get_4atoms: - CHECK(save_ConstantTerm(stream, pc->y_u.cccc.c1)); - CHECK(save_ConstantTerm(stream, pc->y_u.cccc.c2)); - CHECK(save_ConstantTerm(stream, pc->y_u.cccc.c3)); - CHECK(save_ConstantTerm(stream, pc->y_u.cccc.c4)); - pc = NEXTOP(pc,cccc); - break; - /* instructions type ccccc */ - case _traced_get_5atoms: - CHECK(save_ConstantTerm(stream, pc->y_u.ccccc.c1)); - CHECK(save_ConstantTerm(stream, pc->y_u.ccccc.c2)); - CHECK(save_ConstantTerm(stream, pc->y_u.ccccc.c3)); - CHECK(save_ConstantTerm(stream, pc->y_u.ccccc.c4)); - CHECK(save_ConstantTerm(stream, pc->y_u.ccccc.c5)); - pc = NEXTOP(pc,ccccc); - break; - /* instructions type cccccc */ - case _traced_get_6atoms: - CHECK(save_ConstantTerm(stream, pc->y_u.cccccc.c1)); - CHECK(save_ConstantTerm(stream, pc->y_u.cccccc.c2)); - CHECK(save_ConstantTerm(stream, pc->y_u.cccccc.c3)); - CHECK(save_ConstantTerm(stream, pc->y_u.cccccc.c4)); - CHECK(save_ConstantTerm(stream, pc->y_u.cccccc.c5)); - CHECK(save_ConstantTerm(stream, pc->y_u.cccccc.c6)); - pc = NEXTOP(pc,cccccc); - break; - /* instructions type clll */ - case _traced_if_not_then: - CHECK(save_ConstantTerm(stream, pc->y_u.clll.c)); - CHECK(save_PtoOp(stream, pc->y_u.clll.l1)); - CHECK(save_PtoOp(stream, pc->y_u.clll.l2)); - CHECK(save_PtoOp(stream, pc->y_u.clll.l3)); - pc = NEXTOP(pc,clll); - break; - /* instructions type d */ - case _traced_write_float: - CHECK(save_DoubleInCode(stream, pc->y_u.d.d)); - pc = NEXTOP(pc,d); - break; - /* instructions type e */ - case _traced_Nstop: - case _traced_allocate: - case _traced_copy_idb_term: - case _traced_expand_index: - case _traced_index_blob: - case _traced_index_dbref: - case _traced_index_long: - case _traced_index_pred: - case _traced_lock_pred: - case _traced_op_fail: - case _traced_p_equal: - case _traced_p_functor: - case _traced_pop: - case _traced_retry_eam: - case _traced_spy_pred: - case _traced_thread_local: - case _traced_trust_fail: - case _traced_undef_p: - case _traced_unify_idb_term: - case _traced_unlock_lu: - case _traced_write_l_list: - case _traced_write_list: - case _traced_write_void: - if (op == _Nstop || op == _copy_idb_term || op == _unify_idb_term) return 1; - pc = NEXTOP(pc,e); - break; - /* instructions type fa */ - case _traced_write_l_struc: - case _traced_write_struct: - CHECK(save_Func(stream, pc->y_u.fa.f)); - CHECK(save_Arity(stream, pc->y_u.fa.a)); - pc = NEXTOP(pc,fa); - break; - /* instructions type i */ - case _traced_write_longint: - CHECK(save_IntegerInCode(stream, pc->y_u.i.i)); - pc = NEXTOP(pc,i); - break; - /* instructions type l */ - case _traced_Ystop: - case _traced_jump: - case _traced_jump_if_var: - case _traced_move_back: - case _traced_p_dif: - case _traced_p_eq: - case _traced_retry2: - case _traced_retry3: - case _traced_retry4: - case _traced_skip: - case _traced_try_clause2: - case _traced_try_clause3: - case _traced_try_clause4: - case _traced_try_in: - CHECK(save_PtoOp(stream, pc->y_u.l.l)); - pc = NEXTOP(pc,l); - break; - /* instructions type llll */ - case _traced_switch_on_type: - CHECK(save_PtoOp(stream, pc->y_u.llll.l1)); - CHECK(save_PtoOp(stream, pc->y_u.llll.l2)); - CHECK(save_PtoOp(stream, pc->y_u.llll.l3)); - CHECK(save_PtoOp(stream, pc->y_u.llll.l4)); - pc = NEXTOP(pc,llll); - break; - /* instructions type lp */ - case _traced_user_switch: - CHECK(save_PtoOp(stream, pc->y_u.lp.l)); - CHECK(save_PtoPred(stream, pc->y_u.lp.p)); - pc = NEXTOP(pc,lp); - break; - /* instructions type o */ - case _traced_unify_l_list: - case _traced_unify_l_list_write: - case _traced_unify_l_void: - case _traced_unify_l_void_write: - case _traced_unify_list: - case _traced_unify_list_write: - case _traced_unify_void: - case _traced_unify_void_write: - CHECK(save_Opcode(stream, pc->y_u.o.opcw)); - pc = NEXTOP(pc,o); - break; - /* instructions type oD */ - case _traced_unify_dbterm: - case _traced_unify_l_dbterm: - CHECK(save_Opcode(stream, pc->y_u.oD.opcw)); - CHECK(save_DBGroundTerm(stream, pc->y_u.oD.D)); - pc = NEXTOP(pc,oD); - break; - /* instructions type oN */ - case _traced_unify_bigint: - case _traced_unify_l_bigint: - CHECK(save_Opcode(stream, pc->y_u.oN.opcw)); - CHECK(save_BlobTermInCode(stream, pc->y_u.oN.b)); - pc = NEXTOP(pc,oN); - break; - /* instructions type oc */ - case _traced_unify_atom: - case _traced_unify_atom_write: - case _traced_unify_l_atom: - case _traced_unify_l_atom_write: - CHECK(save_Opcode(stream, pc->y_u.oc.opcw)); - CHECK(save_ConstantTerm(stream, pc->y_u.oc.c)); - pc = NEXTOP(pc,oc); - break; - /* instructions type od */ - case _traced_unify_float: - case _traced_unify_float_write: - case _traced_unify_l_float: - case _traced_unify_l_float_write: - CHECK(save_Opcode(stream, pc->y_u.od.opcw)); - CHECK(save_DoubleInCode(stream, pc->y_u.od.d)); - pc = NEXTOP(pc,od); - break; - /* instructions type ofa */ - case _traced_unify_l_struc: - case _traced_unify_l_struc_write: - case _traced_unify_struct: - case _traced_unify_struct_write: - CHECK(save_Opcode(stream, pc->y_u.ofa.opcw)); - CHECK(save_Func(stream, pc->y_u.ofa.f)); - CHECK(save_Arity(stream, pc->y_u.ofa.a)); - pc = NEXTOP(pc,ofa); - break; - /* instructions type oi */ - case _traced_unify_l_longint: - case _traced_unify_l_longint_write: - case _traced_unify_longint: - case _traced_unify_longint_write: - CHECK(save_Opcode(stream, pc->y_u.oi.opcw)); - CHECK(save_IntegerInCode(stream, pc->y_u.oi.i)); - pc = NEXTOP(pc,oi); - break; - /* instructions type ollll */ - case _traced_switch_list_nl: - CHECK(save_Opcode(stream, pc->y_u.ollll.pop)); - CHECK(save_PtoOp(stream, pc->y_u.ollll.l1)); - CHECK(save_PtoOp(stream, pc->y_u.ollll.l2)); - CHECK(save_PtoOp(stream, pc->y_u.ollll.l3)); - CHECK(save_PtoOp(stream, pc->y_u.ollll.l4)); - pc = NEXTOP(pc,ollll); - break; - /* instructions type os */ - case _traced_run_eam: - case _traced_unify_l_n_voids: - case _traced_unify_l_n_voids_write: - case _traced_unify_n_voids: - case _traced_unify_n_voids_write: - CHECK(save_Opcode(stream, pc->y_u.os.opcw)); - CHECK(save_Constant(stream, pc->y_u.os.s)); - pc = NEXTOP(pc,os); - break; - /* instructions type osc */ - case _traced_unify_n_atoms: - case _traced_unify_n_atoms_write: - CHECK(save_Opcode(stream, pc->y_u.osc.opcw)); - CHECK(save_Constant(stream, pc->y_u.osc.s)); - CHECK(save_ConstantTerm(stream, pc->y_u.osc.c)); - pc = NEXTOP(pc,osc); - break; - /* instructions type ox */ - case _traced_save_appl_x: - case _traced_save_appl_x_write: - case _traced_save_pair_x: - case _traced_save_pair_x_write: - case _traced_unify_l_x_loc: - case _traced_unify_l_x_loc_write: - case _traced_unify_l_x_val: - case _traced_unify_l_x_val_write: - case _traced_unify_l_x_var: - case _traced_unify_l_x_var_write: - case _traced_unify_x_loc: - case _traced_unify_x_loc_write: - case _traced_unify_x_val: - case _traced_unify_x_val_write: - case _traced_unify_x_var: - case _traced_unify_x_var_write: - CHECK(save_Opcode(stream, pc->y_u.ox.opcw)); - CHECK(save_X(stream, pc->y_u.ox.x)); - pc = NEXTOP(pc,ox); - break; - /* instructions type oxx */ - case _traced_unify_l_x_var2: - case _traced_unify_l_x_var2_write: - case _traced_unify_x_var2: - case _traced_unify_x_var2_write: - CHECK(save_Opcode(stream, pc->y_u.oxx.opcw)); - CHECK(save_X(stream, pc->y_u.oxx.xl)); - CHECK(save_X(stream, pc->y_u.oxx.xr)); - pc = NEXTOP(pc,oxx); - break; - /* instructions type oy */ - case _traced_save_appl_y: - case _traced_save_appl_y_write: - case _traced_save_pair_y: - case _traced_save_pair_y_write: - case _traced_unify_l_y_loc: - case _traced_unify_l_y_loc_write: - case _traced_unify_l_y_val: - case _traced_unify_l_y_val_write: - case _traced_unify_l_y_var: - case _traced_unify_l_y_var_write: - case _traced_unify_y_loc: - case _traced_unify_y_loc_write: - case _traced_unify_y_val: - case _traced_unify_y_val_write: - case _traced_unify_y_var: - case _traced_unify_y_var_write: - CHECK(save_Opcode(stream, pc->y_u.oy.opcw)); - CHECK(save_Y(stream, pc->y_u.oy.y)); - pc = NEXTOP(pc,oy); - break; - /* instructions type p */ - case _traced_count_call: - case _traced_count_retry: - case _traced_deallocate: - case _traced_enter_profiling: - case _traced_lock_lu: - case _traced_procceed: - case _traced_retry_profiled: - CHECK(save_PtoPred(stream, pc->y_u.p.p)); - pc = NEXTOP(pc,p); - break; - /* instructions type plxxs */ - case _traced_call_bfunc_xx: - CHECK(save_PtoPred(stream, pc->y_u.plxxs.p)); - CHECK(save_PtoOp(stream, pc->y_u.plxxs.f)); - CHECK(save_X(stream, pc->y_u.plxxs.x1)); - CHECK(save_X(stream, pc->y_u.plxxs.x2)); - CHECK(save_Constant(stream, pc->y_u.plxxs.flags)); - pc = NEXTOP(pc,plxxs); - break; - /* instructions type plxys */ - case _traced_call_bfunc_xy: - case _traced_call_bfunc_yx: - CHECK(save_PtoPred(stream, pc->y_u.plxys.p)); - CHECK(save_PtoOp(stream, pc->y_u.plxys.f)); - CHECK(save_X(stream, pc->y_u.plxys.x)); - CHECK(save_Y(stream, pc->y_u.plxys.y)); - CHECK(save_Constant(stream, pc->y_u.plxys.flags)); - pc = NEXTOP(pc,plxys); - break; - /* instructions type plyys */ - case _traced_call_bfunc_yy: - CHECK(save_PtoPred(stream, pc->y_u.plyys.p)); - CHECK(save_PtoOp(stream, pc->y_u.plyys.f)); - CHECK(save_Y(stream, pc->y_u.plyys.y1)); - CHECK(save_Y(stream, pc->y_u.plyys.y2)); - CHECK(save_Constant(stream, pc->y_u.plyys.flags)); - pc = NEXTOP(pc,plyys); - break; - /* instructions type pp */ - case _traced_dexecute: - case _traced_execute: - case _traced_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 */ - case _traced_cut: - case _traced_cut_e: - case _traced_cut_t: - case _traced_pop_n: - case _traced_write_n_voids: - CHECK(save_Constant(stream, pc->y_u.s.s)); - pc = NEXTOP(pc,s); - break; - /* instructions type sc */ - case _traced_write_n_atoms: - CHECK(save_Constant(stream, pc->y_u.sc.s)); - CHECK(save_ConstantTerm(stream, pc->y_u.sc.c)); - pc = NEXTOP(pc,sc); - break; - /* instructions type sllll */ - case _traced_switch_on_sub_arg_type: - CHECK(save_Constant(stream, pc->y_u.sllll.s)); - CHECK(save_PtoOp(stream, pc->y_u.sllll.l1)); - CHECK(save_PtoOp(stream, pc->y_u.sllll.l2)); - CHECK(save_PtoOp(stream, pc->y_u.sllll.l3)); - CHECK(save_PtoOp(stream, pc->y_u.sllll.l4)); - pc = NEXTOP(pc,sllll); - break; - /* instructions type slp */ - case _traced_call_c_wfail: - CHECK(save_Constant(stream, pc->y_u.slp.s)); - CHECK(save_PtoOp(stream, pc->y_u.slp.l)); - CHECK(save_PtoPred(stream, pc->y_u.slp.p)); - pc = NEXTOP(pc,slp); - break; - /* instructions type sssl */ - case _traced_go_on_cons: - case _traced_go_on_func: - case _traced_if_cons: - case _traced_if_func: - case _traced_switch_on_cons: - case _traced_switch_on_func: - CHECK(save_Constant(stream, pc->y_u.sssl.s)); - CHECK(save_Constant(stream, pc->y_u.sssl.e)); - CHECK(save_Constant(stream, pc->y_u.sssl.w)); - CHECK(save_PtoOp(stream, pc->y_u.sssl.l)); - pc = NEXTOP(pc,sssl); - break; - /* instructions type sssllp */ - case _traced_expand_clauses: - CHECK(save_Constant(stream, pc->y_u.sssllp.s1)); - CHECK(save_Constant(stream, pc->y_u.sssllp.s2)); - CHECK(save_Constant(stream, pc->y_u.sssllp.s3)); - CHECK(save_PtoOp(stream, pc->y_u.sssllp.sprev)); - CHECK(save_PtoOp(stream, pc->y_u.sssllp.snext)); - CHECK(save_PtoPred(stream, pc->y_u.sssllp.p)); - pc = NEXTOP(pc,sssllp); - break; - /* instructions type x */ - case _traced_get_list: - case _traced_put_list: - case _traced_save_b_x: - case _traced_write_x_loc: - case _traced_write_x_val: - case _traced_write_x_var: - CHECK(save_X(stream, pc->y_u.x.x)); - pc = NEXTOP(pc,x); - break; - /* instructions type xD */ - case _traced_get_dbterm: - case _traced_put_dbterm: - CHECK(save_X(stream, pc->y_u.xD.x)); - CHECK(save_DBGroundTerm(stream, pc->y_u.xD.D)); - pc = NEXTOP(pc,xD); - break; - /* instructions type xN */ - case _traced_get_bigint: - case _traced_put_bigint: - CHECK(save_X(stream, pc->y_u.xN.x)); - CHECK(save_BlobTermInCode(stream, pc->y_u.xN.b)); - pc = NEXTOP(pc,xN); - break; - /* instructions type xc */ - case _traced_get_atom: - case _traced_put_atom: - CHECK(save_X(stream, pc->y_u.xc.x)); - CHECK(save_ConstantTerm(stream, pc->y_u.xc.c)); - pc = NEXTOP(pc,xc); - break; - /* instructions type xd */ - case _traced_get_float: - case _traced_put_float: - CHECK(save_X(stream, pc->y_u.xd.x)); - CHECK(save_DoubleInCode(stream, pc->y_u.xd.d)); - pc = NEXTOP(pc,xd); - break; - /* instructions type xfa */ - case _traced_get_struct: - case _traced_put_struct: - CHECK(save_X(stream, pc->y_u.xfa.x)); - CHECK(save_Func(stream, pc->y_u.xfa.f)); - CHECK(save_Arity(stream, pc->y_u.xfa.a)); - pc = NEXTOP(pc,xfa); - break; - /* instructions type xi */ - case _traced_get_longint: - case _traced_put_longint: - CHECK(save_X(stream, pc->y_u.xi.x)); - CHECK(save_IntegerInCode(stream, pc->y_u.xi.i)); - pc = NEXTOP(pc,xi); - break; - /* instructions type xl */ - case _traced_p_atom_x: - case _traced_p_atomic_x: - case _traced_p_compound_x: - case _traced_p_db_ref_x: - case _traced_p_float_x: - case _traced_p_integer_x: - case _traced_p_nonvar_x: - case _traced_p_number_x: - case _traced_p_primitive_x: - case _traced_p_var_x: - CHECK(save_X(stream, pc->y_u.xl.x)); - CHECK(save_PtoOp(stream, pc->y_u.xl.F)); - pc = NEXTOP(pc,xl); - break; - /* instructions type xll */ - case _traced_jump_if_nonvar: - CHECK(save_X(stream, pc->y_u.xll.x)); - CHECK(save_PtoOp(stream, pc->y_u.xll.l1)); - CHECK(save_PtoOp(stream, pc->y_u.xll.l2)); - pc = NEXTOP(pc,xll); - break; - /* instructions type xllll */ - case _traced_switch_on_arg_type: - CHECK(save_X(stream, pc->y_u.xllll.x)); - CHECK(save_PtoOp(stream, pc->y_u.xllll.l1)); - CHECK(save_PtoOp(stream, pc->y_u.xllll.l2)); - CHECK(save_PtoOp(stream, pc->y_u.xllll.l3)); - CHECK(save_PtoOp(stream, pc->y_u.xllll.l4)); - pc = NEXTOP(pc,xllll); - break; - /* instructions type xps */ - case _traced_commit_b_x: - CHECK(save_X(stream, pc->y_u.xps.x)); - CHECK(save_PtoPred(stream, pc->y_u.xps.p0)); - CHECK(save_Constant(stream, pc->y_u.xps.s)); - pc = NEXTOP(pc,xps); - break; - /* instructions type xx */ - case _traced_get_x_val: - case _traced_get_x_var: - case _traced_gl_void_valx: - case _traced_gl_void_varx: - case _traced_glist_valx: - case _traced_put_x_val: - case _traced_put_x_var: - CHECK(save_X(stream, pc->y_u.xx.xl)); - CHECK(save_X(stream, pc->y_u.xx.xr)); - pc = NEXTOP(pc,xx); - break; - /* instructions type xxc */ - case _traced_p_func2s_cv: - CHECK(save_X(stream, pc->y_u.xxc.x)); - CHECK(save_X(stream, pc->y_u.xxc.xi)); - CHECK(save_ConstantTerm(stream, pc->y_u.xxc.c)); - pc = NEXTOP(pc,xxc); - break; - /* instructions type xxn */ - case _traced_p_and_vc: - case _traced_p_arg_cv: - case _traced_p_div_cv: - case _traced_p_div_vc: - case _traced_p_func2s_vc: - case _traced_p_minus_cv: - case _traced_p_or_vc: - case _traced_p_plus_vc: - case _traced_p_sll_cv: - case _traced_p_sll_vc: - case _traced_p_slr_cv: - case _traced_p_slr_vc: - case _traced_p_times_vc: - CHECK(save_X(stream, pc->y_u.xxn.x)); - CHECK(save_X(stream, pc->y_u.xxn.xi)); - CHECK(save_Integer(stream, pc->y_u.xxn.c)); - pc = NEXTOP(pc,xxn); - break; - /* instructions type xxx */ - case _traced_p_and_vv: - case _traced_p_arg_vv: - case _traced_p_div_vv: - case _traced_p_func2f_xx: - case _traced_p_func2s_vv: - case _traced_p_minus_vv: - case _traced_p_or_vv: - case _traced_p_plus_vv: - case _traced_p_sll_vv: - case _traced_p_slr_vv: - case _traced_p_times_vv: - CHECK(save_X(stream, pc->y_u.xxx.x)); - CHECK(save_X(stream, pc->y_u.xxx.x1)); - CHECK(save_X(stream, pc->y_u.xxx.x2)); - pc = NEXTOP(pc,xxx); - break; - /* instructions type xxxx */ - case _traced_put_xx_val: - CHECK(save_X(stream, pc->y_u.xxxx.xl1)); - CHECK(save_X(stream, pc->y_u.xxxx.xl2)); - CHECK(save_X(stream, pc->y_u.xxxx.xr1)); - CHECK(save_X(stream, pc->y_u.xxxx.xr2)); - pc = NEXTOP(pc,xxxx); - break; - /* instructions type xxy */ - case _traced_p_func2f_xy: - CHECK(save_X(stream, pc->y_u.xxy.x)); - CHECK(save_X(stream, pc->y_u.xxy.x1)); - CHECK(save_Y(stream, pc->y_u.xxy.y2)); - pc = NEXTOP(pc,xxy); - break; - /* instructions type y */ - case _traced_save_b_y: - case _traced_write_y_loc: - case _traced_write_y_val: - case _traced_write_y_var: - CHECK(save_Y(stream, pc->y_u.y.y)); - pc = NEXTOP(pc,y); - break; - /* instructions type yl */ - case _traced_p_atom_y: - case _traced_p_atomic_y: - case _traced_p_compound_y: - case _traced_p_db_ref_y: - case _traced_p_float_y: - case _traced_p_integer_y: - case _traced_p_nonvar_y: - case _traced_p_number_y: - case _traced_p_primitive_y: - case _traced_p_var_y: - CHECK(save_Y(stream, pc->y_u.yl.y)); - CHECK(save_PtoOp(stream, pc->y_u.yl.F)); - pc = NEXTOP(pc,yl); - break; - /* instructions type yps */ - case _traced_commit_b_y: - CHECK(save_Y(stream, pc->y_u.yps.y)); - CHECK(save_PtoPred(stream, pc->y_u.yps.p0)); - CHECK(save_Constant(stream, pc->y_u.yps.s)); - pc = NEXTOP(pc,yps); - break; - /* instructions type yx */ - case _traced_get_y_val: - case _traced_get_y_var: - case _traced_gl_void_valy: - case _traced_gl_void_vary: - case _traced_glist_valy: - case _traced_put_unsafe: - case _traced_put_y_val: - case _traced_put_y_var: - CHECK(save_Y(stream, pc->y_u.yx.y)); - CHECK(save_X(stream, pc->y_u.yx.x)); - pc = NEXTOP(pc,yx); - break; - /* instructions type yxn */ - case _traced_p_and_y_vc: - case _traced_p_arg_y_cv: - case _traced_p_div_y_cv: - case _traced_p_div_y_vc: - case _traced_p_func2s_y_cv: - case _traced_p_func2s_y_vc: - case _traced_p_minus_y_cv: - case _traced_p_or_y_vc: - case _traced_p_plus_y_vc: - case _traced_p_sll_y_cv: - case _traced_p_sll_y_vc: - case _traced_p_slr_y_cv: - case _traced_p_slr_y_vc: - case _traced_p_times_y_vc: - CHECK(save_Y(stream, pc->y_u.yxn.y)); - CHECK(save_X(stream, pc->y_u.yxn.xi)); - CHECK(save_Integer(stream, pc->y_u.yxn.c)); - pc = NEXTOP(pc,yxn); - break; - /* instructions type yxx */ - case _traced_p_and_y_vv: - case _traced_p_arg_y_vv: - case _traced_p_div_y_vv: - case _traced_p_func2f_yx: - case _traced_p_func2s_y_vv: - case _traced_p_minus_y_vv: - case _traced_p_or_y_vv: - case _traced_p_plus_y_vv: - case _traced_p_sll_y_vv: - case _traced_p_slr_y_vv: - case _traced_p_times_y_vv: - CHECK(save_Y(stream, pc->y_u.yxx.y)); - CHECK(save_X(stream, pc->y_u.yxx.x1)); - CHECK(save_X(stream, pc->y_u.yxx.x2)); - pc = NEXTOP(pc,yxx); - break; - /* instructions type yyx */ - case _traced_p_func2f_yy: - CHECK(save_Y(stream, pc->y_u.yyx.y1)); - CHECK(save_Y(stream, pc->y_u.yyx.y2)); - CHECK(save_X(stream, pc->y_u.yyx.x)); - pc = NEXTOP(pc,yyx); - break; - /* instructions type yyxx */ - case _traced_get_yy_var: - case _traced_put_y_vals: - CHECK(save_Y(stream, pc->y_u.yyxx.y1)); - CHECK(save_Y(stream, pc->y_u.yyxx.y2)); - CHECK(save_X(stream, pc->y_u.yyxx.x1)); - CHECK(save_X(stream, pc->y_u.yyxx.x2)); - pc = NEXTOP(pc,yyxx); - break; -#ifdef YAPOR - /* instructions type Otapl */ - case _traced_getwork: - case _traced_getwork_seq: - case _traced_sync: -#ifdef YAPOR - CHECK(save_OrArg(stream, pc->y_u.Otapl.or_arg)); -#endif -#ifdef TABLING - CHECK(save_TabEntry(stream, pc->y_u.Otapl.te)); -#endif - CHECK(save_Arity(stream, pc->y_u.Otapl.s)); - CHECK(save_PtoPred(stream, pc->y_u.Otapl.p)); - CHECK(save_PtoOp(stream, pc->y_u.Otapl.d)); - pc = NEXTOP(pc,Otapl); - break; - /* instructions type e */ - case _traced_getwork_first_time: - if (op == _Nstop || op == _copy_idb_term || op == _unify_idb_term) return 1; - pc = NEXTOP(pc,e); - break; -#endif -#ifdef TABLING - /* instructions type Otapl */ - case _traced_table_answer_resolution: - case _traced_table_answer_resolution_completion: - case _traced_table_completion: - case _traced_table_load_answer: - case _traced_table_retry: - case _traced_table_retry_me: - case _traced_table_trust: - case _traced_table_trust_me: - case _traced_table_try: - case _traced_table_try_answer: - case _traced_table_try_me: - case _traced_table_try_single: -#ifdef YAPOR - CHECK(save_OrArg(stream, pc->y_u.Otapl.or_arg)); -#endif -#ifdef TABLING - CHECK(save_TabEntry(stream, pc->y_u.Otapl.te)); -#endif - CHECK(save_Arity(stream, pc->y_u.Otapl.s)); - CHECK(save_PtoPred(stream, pc->y_u.Otapl.p)); - CHECK(save_PtoOp(stream, pc->y_u.Otapl.d)); - pc = NEXTOP(pc,Otapl); - break; - /* instructions type e */ - case _traced_clause_with_cut: - if (op == _Nstop || op == _copy_idb_term || op == _unify_idb_term) return 1; - pc = NEXTOP(pc,e); - break; - /* instructions type s */ - case _traced_table_new_answer: - CHECK(save_Constant(stream, pc->y_u.s.s)); - pc = NEXTOP(pc,s); - break; - /* instructions type e */ - case _traced_trie_do_appl: - case _traced_trie_do_appl_in_pair: - case _traced_trie_do_atom: - case _traced_trie_do_atom_in_pair: - case _traced_trie_do_bigint: - case _traced_trie_do_double: - case _traced_trie_do_extension: - case _traced_trie_do_gterm: - case _traced_trie_do_longint: - case _traced_trie_do_null: - case _traced_trie_do_null_in_pair: - case _traced_trie_do_pair: - case _traced_trie_do_val: - case _traced_trie_do_val_in_pair: - case _traced_trie_do_var: - case _traced_trie_do_var_in_pair: - case _traced_trie_retry_appl: - case _traced_trie_retry_appl_in_pair: - case _traced_trie_retry_atom: - case _traced_trie_retry_atom_in_pair: - case _traced_trie_retry_bigint: - case _traced_trie_retry_double: - case _traced_trie_retry_extension: - case _traced_trie_retry_gterm: - case _traced_trie_retry_longint: - case _traced_trie_retry_null: - case _traced_trie_retry_null_in_pair: - case _traced_trie_retry_pair: - case _traced_trie_retry_val: - case _traced_trie_retry_val_in_pair: - case _traced_trie_retry_var: - case _traced_trie_retry_var_in_pair: - case _traced_trie_trust_appl: - case _traced_trie_trust_appl_in_pair: - case _traced_trie_trust_atom: - case _traced_trie_trust_atom_in_pair: - case _traced_trie_trust_bigint: - case _traced_trie_trust_double: - case _traced_trie_trust_extension: - case _traced_trie_trust_gterm: - case _traced_trie_trust_longint: - case _traced_trie_trust_null: - case _traced_trie_trust_null_in_pair: - case _traced_trie_trust_pair: - case _traced_trie_trust_val: - case _traced_trie_trust_val_in_pair: - case _traced_trie_trust_var: - case _traced_trie_trust_var_in_pair: - case _traced_trie_try_appl: - case _traced_trie_try_appl_in_pair: - case _traced_trie_try_atom: - case _traced_trie_try_atom_in_pair: - case _traced_trie_try_bigint: - case _traced_trie_try_double: - case _traced_trie_try_extension: - case _traced_trie_try_gterm: - case _traced_trie_try_longint: - case _traced_trie_try_null: - case _traced_trie_try_null_in_pair: - case _traced_trie_try_pair: - case _traced_trie_try_val: - case _traced_trie_try_val_in_pair: - case _traced_trie_try_var: - case _traced_trie_try_var_in_pair: - if (op == _Nstop || op == _copy_idb_term || op == _unify_idb_term) return 1; - pc = NEXTOP(pc,e); - break; -#endif -#endif default: return -1; } diff --git a/H/walkclause.h b/H/walkclause.h index 5d731b6ab..21efd7c2b 100644 --- a/H/walkclause.h +++ b/H/walkclause.h @@ -726,680 +726,8 @@ case _trie_try_var_in_pair: pc = NEXTOP(pc,e); break; -#endif -#ifdef YAP_JIT - /* instructions type D */ - case _traced_write_dbterm: - pc = NEXTOP(pc,D); - break; - /* instructions type Illss */ - case _traced_enter_lu_pred: - return walk_got_lu_block(pc->y_u.Illss.I, startp, endp); - /* instructions type J */ - case _traced_jit_handler: - pc = NEXTOP(pc,J); - break; - /* instructions type L */ - case _traced_alloc_for_logical_pred: - return walk_got_lu_clause(pc->y_u.L.ClBase, startp, endp); - /* instructions type N */ - case _traced_write_bigint: - pc = NEXTOP(pc,N); - break; - /* instructions type Osblp */ - case _traced_either: - case _traced_or_else: - clause_code = TRUE; - pp = pc->y_u.Osblp.p0; - pc = NEXTOP(pc,Osblp); - break; - /* instructions type Osbmp */ - case _traced_p_execute: - case _traced_p_execute_tail: - pc = NEXTOP(pc,Osbmp); - break; - /* instructions type Osbpa */ - case _traced_ensure_space: - pc = NEXTOP(pc,Osbpa); - break; - /* instructions type Osbpp */ - case _traced_call: - case _traced_call_cpred: - case _traced_call_usercpred: - case _traced_fcall: - case _traced_p_execute2: - clause_code = TRUE; - pp = pc->y_u.Osbpp.p0; - pc = NEXTOP(pc,Osbpp); - break; - /* instructions type OtILl */ - case _traced_count_trust_logical: - case _traced_profiled_trust_logical: - case _traced_trust_logical: - return walk_got_lu_block(pc->y_u.OtILl.block, startp, endp); - /* instructions type OtaLl */ - case _traced_count_retry_logical: - case _traced_profiled_retry_logical: - case _traced_retry_logical: - case _traced_try_logical: - pc = pc->y_u.OtaLl.n; - break; - /* instructions type OtapFs */ - case _traced_cut_c: - case _traced_cut_userc: - case _traced_retry_c: - case _traced_retry_userc: - case _traced_try_c: - case _traced_try_userc: - clause_code = TRUE; - pp = pc->y_u.OtapFs.p; - pc = NEXTOP(pc,OtapFs); - break; - /* instructions type Otapl */ - case _traced_count_retry_and_mark: - case _traced_count_retry_me: - case _traced_count_trust_me: - case _traced_profiled_retry_and_mark: - case _traced_profiled_retry_me: - case _traced_profiled_trust_me: - case _traced_retry: - case _traced_retry_and_mark: - case _traced_retry_me: - case _traced_spy_or_trymark: - case _traced_trust: - case _traced_trust_me: - case _traced_try_and_mark: - case _traced_try_clause: - case _traced_try_me: - clause_code = FALSE; - pp = pc->y_u.Otapl.p; - pc = NEXTOP(pc,Otapl); - break; - /* instructions type c */ - case _traced_write_atom: - pc = NEXTOP(pc,c); - break; - /* instructions type cc */ - case _traced_get_2atoms: - pc = NEXTOP(pc,cc); - break; - /* instructions type ccc */ - case _traced_get_3atoms: - pc = NEXTOP(pc,ccc); - break; - /* instructions type cccc */ - case _traced_get_4atoms: - pc = NEXTOP(pc,cccc); - break; - /* instructions type ccccc */ - case _traced_get_5atoms: - pc = NEXTOP(pc,ccccc); - break; - /* instructions type cccccc */ - case _traced_get_6atoms: - pc = NEXTOP(pc,cccccc); - break; - /* instructions type clll */ - case _traced_if_not_then: - pc = NEXTOP(pc,clll); - break; - /* instructions type d */ - case _traced_write_float: - pc = NEXTOP(pc,d); - break; - /* instructions type e */ - case _traced_Nstop: - case _traced_allocate: - case _traced_copy_idb_term: - case _traced_expand_index: - case _traced_index_blob: - case _traced_index_dbref: - case _traced_index_long: - case _traced_index_pred: - case _traced_lock_pred: - case _traced_op_fail: - case _traced_p_equal: - case _traced_p_functor: - case _traced_pop: - case _traced_retry_eam: - case _traced_spy_pred: - case _traced_thread_local: - case _traced_trust_fail: - case _traced_undef_p: - case _traced_unify_idb_term: - case _traced_unlock_lu: - case _traced_write_l_list: - case _traced_write_list: - case _traced_write_void: - pc = NEXTOP(pc,e); - break; - /* instructions type fa */ - case _traced_write_l_struc: - case _traced_write_struct: - pc = NEXTOP(pc,fa); - break; - /* instructions type i */ - case _traced_write_longint: - pc = NEXTOP(pc,i); - break; - /* instructions type l */ - case _traced_Ystop: - case _traced_jump: - case _traced_jump_if_var: - case _traced_move_back: - case _traced_p_dif: - case _traced_p_eq: - case _traced_retry2: - case _traced_retry3: - case _traced_retry4: - case _traced_skip: - case _traced_try_clause2: - case _traced_try_clause3: - case _traced_try_clause4: - case _traced_try_in: - pc = NEXTOP(pc,l); - break; - /* instructions type llll */ - case _traced_switch_on_type: - pc = NEXTOP(pc,llll); - break; - /* instructions type lp */ - case _traced_user_switch: - pc = NEXTOP(pc,lp); - break; - /* instructions type o */ - case _traced_unify_l_list: - case _traced_unify_l_list_write: - case _traced_unify_l_void: - case _traced_unify_l_void_write: - case _traced_unify_list: - case _traced_unify_list_write: - case _traced_unify_void: - case _traced_unify_void_write: - pc = NEXTOP(pc,o); - break; - /* instructions type oD */ - case _traced_unify_dbterm: - case _traced_unify_l_dbterm: - pc = NEXTOP(pc,oD); - break; - /* instructions type oN */ - case _traced_unify_bigint: - case _traced_unify_l_bigint: - pc = NEXTOP(pc,oN); - break; - /* instructions type oc */ - case _traced_unify_atom: - case _traced_unify_atom_write: - case _traced_unify_l_atom: - case _traced_unify_l_atom_write: - pc = NEXTOP(pc,oc); - break; - /* instructions type od */ - case _traced_unify_float: - case _traced_unify_float_write: - case _traced_unify_l_float: - case _traced_unify_l_float_write: - pc = NEXTOP(pc,od); - break; - /* instructions type ofa */ - case _traced_unify_l_struc: - case _traced_unify_l_struc_write: - case _traced_unify_struct: - case _traced_unify_struct_write: - pc = NEXTOP(pc,ofa); - break; - /* instructions type oi */ - case _traced_unify_l_longint: - case _traced_unify_l_longint_write: - case _traced_unify_longint: - case _traced_unify_longint_write: - pc = NEXTOP(pc,oi); - break; - /* instructions type ollll */ - case _traced_switch_list_nl: - pc = NEXTOP(pc,ollll); - break; - /* instructions type os */ - case _traced_run_eam: - case _traced_unify_l_n_voids: - case _traced_unify_l_n_voids_write: - case _traced_unify_n_voids: - case _traced_unify_n_voids_write: - pc = NEXTOP(pc,os); - break; - /* instructions type osc */ - case _traced_unify_n_atoms: - case _traced_unify_n_atoms_write: - pc = NEXTOP(pc,osc); - break; - /* instructions type ox */ - case _traced_save_appl_x: - case _traced_save_appl_x_write: - case _traced_save_pair_x: - case _traced_save_pair_x_write: - case _traced_unify_l_x_loc: - case _traced_unify_l_x_loc_write: - case _traced_unify_l_x_val: - case _traced_unify_l_x_val_write: - case _traced_unify_l_x_var: - case _traced_unify_l_x_var_write: - case _traced_unify_x_loc: - case _traced_unify_x_loc_write: - case _traced_unify_x_val: - case _traced_unify_x_val_write: - case _traced_unify_x_var: - case _traced_unify_x_var_write: - pc = NEXTOP(pc,ox); - break; - /* instructions type oxx */ - case _traced_unify_l_x_var2: - case _traced_unify_l_x_var2_write: - case _traced_unify_x_var2: - case _traced_unify_x_var2_write: - pc = NEXTOP(pc,oxx); - break; - /* instructions type oy */ - case _traced_save_appl_y: - case _traced_save_appl_y_write: - case _traced_save_pair_y: - case _traced_save_pair_y_write: - case _traced_unify_l_y_loc: - case _traced_unify_l_y_loc_write: - case _traced_unify_l_y_val: - case _traced_unify_l_y_val_write: - case _traced_unify_l_y_var: - case _traced_unify_l_y_var_write: - case _traced_unify_y_loc: - case _traced_unify_y_loc_write: - case _traced_unify_y_val: - case _traced_unify_y_val_write: - case _traced_unify_y_var: - case _traced_unify_y_var_write: - pc = NEXTOP(pc,oy); - break; - /* instructions type p */ - case _traced_count_call: - case _traced_count_retry: - case _traced_deallocate: - case _traced_enter_profiling: - case _traced_lock_lu: - case _traced_procceed: - case _traced_retry_profiled: - pc = NEXTOP(pc,p); - break; - /* instructions type plxxs */ - case _traced_call_bfunc_xx: - pc = NEXTOP(pc,plxxs); - break; - /* instructions type plxys */ - case _traced_call_bfunc_xy: - case _traced_call_bfunc_yx: - pc = NEXTOP(pc,plxys); - break; - /* instructions type plyys */ - case _traced_call_bfunc_yy: - pc = NEXTOP(pc,plyys); - break; - /* instructions type pp */ - case _traced_dexecute: - case _traced_execute: - case _traced_execute_cpred: - clause_code = TRUE; - pp = pc->y_u.pp.p0; - pc = NEXTOP(pc,pp); - break; - /* instructions type s */ - case _traced_cut: - case _traced_cut_e: - case _traced_cut_t: - case _traced_pop_n: - case _traced_write_n_voids: - pc = NEXTOP(pc,s); - break; - /* instructions type sc */ - case _traced_write_n_atoms: - pc = NEXTOP(pc,sc); - break; - /* instructions type sllll */ - case _traced_switch_on_sub_arg_type: - pc = NEXTOP(pc,sllll); - break; - /* instructions type slp */ - case _traced_call_c_wfail: - pc = NEXTOP(pc,slp); - break; - /* instructions type sssl */ - case _traced_go_on_cons: - case _traced_go_on_func: - case _traced_if_cons: - case _traced_if_func: - case _traced_switch_on_cons: - case _traced_switch_on_func: - pc = NEXTOP(pc,sssl); - break; - /* instructions type sssllp */ - case _traced_expand_clauses: - return found_expand_index(pc, startp, endp, codeptr PASS_REGS); - pc = NEXTOP(pc,sssllp); - break; - /* instructions type x */ - case _traced_get_list: - case _traced_put_list: - case _traced_save_b_x: - case _traced_write_x_loc: - case _traced_write_x_val: - case _traced_write_x_var: - pc = NEXTOP(pc,x); - break; - /* instructions type xD */ - case _traced_get_dbterm: - case _traced_put_dbterm: - pc = NEXTOP(pc,xD); - break; - /* instructions type xN */ - case _traced_get_bigint: - case _traced_put_bigint: - pc = NEXTOP(pc,xN); - break; - /* instructions type xc */ - case _traced_get_atom: - case _traced_put_atom: - pc = NEXTOP(pc,xc); - break; - /* instructions type xd */ - case _traced_get_float: - case _traced_put_float: - pc = NEXTOP(pc,xd); - break; - /* instructions type xfa */ - case _traced_get_struct: - case _traced_put_struct: - pc = NEXTOP(pc,xfa); - break; - /* instructions type xi */ - case _traced_get_longint: - case _traced_put_longint: - pc = NEXTOP(pc,xi); - break; - /* instructions type xl */ - case _traced_p_atom_x: - case _traced_p_atomic_x: - case _traced_p_compound_x: - case _traced_p_db_ref_x: - case _traced_p_float_x: - case _traced_p_integer_x: - case _traced_p_nonvar_x: - case _traced_p_number_x: - case _traced_p_primitive_x: - case _traced_p_var_x: - pc = NEXTOP(pc,xl); - break; - /* instructions type xll */ - case _traced_jump_if_nonvar: - pc = NEXTOP(pc,xll); - break; - /* instructions type xllll */ - case _traced_switch_on_arg_type: - pc = NEXTOP(pc,xllll); - break; - /* instructions type xps */ - case _traced_commit_b_x: - pc = NEXTOP(pc,xps); - break; - /* instructions type xx */ - case _traced_get_x_val: - case _traced_get_x_var: - case _traced_gl_void_valx: - case _traced_gl_void_varx: - case _traced_glist_valx: - case _traced_put_x_val: - case _traced_put_x_var: - pc = NEXTOP(pc,xx); - break; - /* instructions type xxc */ - case _traced_p_func2s_cv: - pc = NEXTOP(pc,xxc); - break; - /* instructions type xxn */ - case _traced_p_and_vc: - case _traced_p_arg_cv: - case _traced_p_div_cv: - case _traced_p_div_vc: - case _traced_p_func2s_vc: - case _traced_p_minus_cv: - case _traced_p_or_vc: - case _traced_p_plus_vc: - case _traced_p_sll_cv: - case _traced_p_sll_vc: - case _traced_p_slr_cv: - case _traced_p_slr_vc: - case _traced_p_times_vc: - pc = NEXTOP(pc,xxn); - break; - /* instructions type xxx */ - case _traced_p_and_vv: - case _traced_p_arg_vv: - case _traced_p_div_vv: - case _traced_p_func2f_xx: - case _traced_p_func2s_vv: - case _traced_p_minus_vv: - case _traced_p_or_vv: - case _traced_p_plus_vv: - case _traced_p_sll_vv: - case _traced_p_slr_vv: - case _traced_p_times_vv: - pc = NEXTOP(pc,xxx); - break; - /* instructions type xxxx */ - case _traced_put_xx_val: - pc = NEXTOP(pc,xxxx); - break; - /* instructions type xxy */ - case _traced_p_func2f_xy: - pc = NEXTOP(pc,xxy); - break; - /* instructions type y */ - case _traced_save_b_y: - case _traced_write_y_loc: - case _traced_write_y_val: - case _traced_write_y_var: - pc = NEXTOP(pc,y); - break; - /* instructions type yl */ - case _traced_p_atom_y: - case _traced_p_atomic_y: - case _traced_p_compound_y: - case _traced_p_db_ref_y: - case _traced_p_float_y: - case _traced_p_integer_y: - case _traced_p_nonvar_y: - case _traced_p_number_y: - case _traced_p_primitive_y: - case _traced_p_var_y: - pc = NEXTOP(pc,yl); - break; - /* instructions type yps */ - case _traced_commit_b_y: - pc = NEXTOP(pc,yps); - break; - /* instructions type yx */ - case _traced_get_y_val: - case _traced_get_y_var: - case _traced_gl_void_valy: - case _traced_gl_void_vary: - case _traced_glist_valy: - case _traced_put_unsafe: - case _traced_put_y_val: - case _traced_put_y_var: - pc = NEXTOP(pc,yx); - break; - /* instructions type yxn */ - case _traced_p_and_y_vc: - case _traced_p_arg_y_cv: - case _traced_p_div_y_cv: - case _traced_p_div_y_vc: - case _traced_p_func2s_y_cv: - case _traced_p_func2s_y_vc: - case _traced_p_minus_y_cv: - case _traced_p_or_y_vc: - case _traced_p_plus_y_vc: - case _traced_p_sll_y_cv: - case _traced_p_sll_y_vc: - case _traced_p_slr_y_cv: - case _traced_p_slr_y_vc: - case _traced_p_times_y_vc: - pc = NEXTOP(pc,yxn); - break; - /* instructions type yxx */ - case _traced_p_and_y_vv: - case _traced_p_arg_y_vv: - case _traced_p_div_y_vv: - case _traced_p_func2f_yx: - case _traced_p_func2s_y_vv: - case _traced_p_minus_y_vv: - case _traced_p_or_y_vv: - case _traced_p_plus_y_vv: - case _traced_p_sll_y_vv: - case _traced_p_slr_y_vv: - case _traced_p_times_y_vv: - pc = NEXTOP(pc,yxx); - break; - /* instructions type yyx */ - case _traced_p_func2f_yy: - pc = NEXTOP(pc,yyx); - break; - /* instructions type yyxx */ - case _traced_get_yy_var: - case _traced_put_y_vals: - pc = NEXTOP(pc,yyxx); - break; -#ifdef YAPOR - /* instructions type Otapl */ - case _traced_getwork: - case _traced_getwork_seq: - case _traced_sync: - clause_code = FALSE; - pp = pc->y_u.Otapl.p; - pc = NEXTOP(pc,Otapl); - break; - /* instructions type e */ - case _traced_getwork_first_time: - pc = NEXTOP(pc,e); - break; -#endif -#ifdef TABLING - /* instructions type Otapl */ - case _traced_table_answer_resolution: - case _traced_table_answer_resolution_completion: - case _traced_table_completion: - case _traced_table_load_answer: - case _traced_table_retry: - case _traced_table_retry_me: - case _traced_table_trust: - case _traced_table_trust_me: - case _traced_table_try: - case _traced_table_try_answer: - case _traced_table_try_me: - case _traced_table_try_single: - clause_code = FALSE; - pp = pc->y_u.Otapl.p; - pc = NEXTOP(pc,Otapl); - break; - /* instructions type e */ - case _traced_clause_with_cut: - pc = NEXTOP(pc,e); - break; - /* instructions type s */ - case _traced_table_new_answer: - pc = NEXTOP(pc,s); - break; - /* instructions type e */ - case _traced_trie_do_appl: - case _traced_trie_do_appl_in_pair: - case _traced_trie_do_atom: - case _traced_trie_do_atom_in_pair: - case _traced_trie_do_bigint: - case _traced_trie_do_double: - case _traced_trie_do_extension: - case _traced_trie_do_gterm: - case _traced_trie_do_longint: - case _traced_trie_do_null: - case _traced_trie_do_null_in_pair: - case _traced_trie_do_pair: - case _traced_trie_do_val: - case _traced_trie_do_val_in_pair: - case _traced_trie_do_var: - case _traced_trie_do_var_in_pair: - case _traced_trie_retry_appl: - case _traced_trie_retry_appl_in_pair: - case _traced_trie_retry_atom: - case _traced_trie_retry_atom_in_pair: - case _traced_trie_retry_bigint: - case _traced_trie_retry_double: - case _traced_trie_retry_extension: - case _traced_trie_retry_gterm: - case _traced_trie_retry_longint: - case _traced_trie_retry_null: - case _traced_trie_retry_null_in_pair: - case _traced_trie_retry_pair: - case _traced_trie_retry_val: - case _traced_trie_retry_val_in_pair: - case _traced_trie_retry_var: - case _traced_trie_retry_var_in_pair: - case _traced_trie_trust_appl: - case _traced_trie_trust_appl_in_pair: - case _traced_trie_trust_atom: - case _traced_trie_trust_atom_in_pair: - case _traced_trie_trust_bigint: - case _traced_trie_trust_double: - case _traced_trie_trust_extension: - case _traced_trie_trust_gterm: - case _traced_trie_trust_longint: - case _traced_trie_trust_null: - case _traced_trie_trust_null_in_pair: - case _traced_trie_trust_pair: - case _traced_trie_trust_val: - case _traced_trie_trust_val_in_pair: - case _traced_trie_trust_var: - case _traced_trie_trust_var_in_pair: - case _traced_trie_try_appl: - case _traced_trie_try_appl_in_pair: - case _traced_trie_try_atom: - case _traced_trie_try_atom_in_pair: - case _traced_trie_try_bigint: - case _traced_trie_try_double: - case _traced_trie_try_extension: - case _traced_trie_try_gterm: - case _traced_trie_try_longint: - case _traced_trie_try_null: - case _traced_trie_try_null_in_pair: - case _traced_trie_try_pair: - case _traced_trie_try_val: - case _traced_trie_try_val_in_pair: - case _traced_trie_try_var: - case _traced_trie_try_var_in_pair: - pc = NEXTOP(pc,e); - break; -#endif #endif /* this instruction is hardwired */ -#ifdef YAP_JIT - case _traced_or_last: -#ifdef YAPOR - pp = pc->y_u.Osblp.p0; - if (pp->PredFlags & MegaClausePredFlag) - return found_mega_clause(pp, startp, endp); - clause_code = TRUE; - pc = NEXTOP(pc,Osblp); -#else - pp = pc->y_u.p.p; - if (pp->PredFlags & MegaClausePredFlag) - return found_mega_clause(pp, startp, endp); - clause_code = TRUE; - pc = NEXTOP(pc,p); -#endif -#endif case _or_last: #ifdef YAPOR pp = pc->y_u.Osblp.p0; diff --git a/JIT/CMakeLists.txt b/JIT/CMakeLists.txt index 53e45d029..93dd865ca 100644 --- a/JIT/CMakeLists.txt +++ b/JIT/CMakeLists.txt @@ -10,7 +10,8 @@ set(LIBJIT_SOURCES jit_statisticpreds.c jit_codegenpreds.c jit_debugpreds.c - jit_transformpreds.c + jit_traced.c + jit_transformpreds.c JIT_Compiler.cpp JIT_Init.cpp ) @@ -61,6 +62,6 @@ set_target_properties(libyapjit OUTPUT_NAME YapJIT ) -target_link_libraries(libyapjit libYap ${LLVM_LIBRARIES} ) +target_link_libraries(libyapjit libYap ${LLVM_LIBRARIES} z) set ( YAP_YAPJITLIB $ ) diff --git a/JIT/HPP/IsGround.h b/JIT/HPP/IsGround.h index f707d45fe..40d07652f 100644 --- a/JIT/HPP/IsGround.h +++ b/JIT/HPP/IsGround.h @@ -1207,1209 +1207,6 @@ IsGround(yamop* _p) { case _or_last : _p = ((yamop *)(&((_p)->y_u.p.next))); break; -#endif - case _traced_Ystop : - _p = ((yamop *)(&((_p)->y_u.l.next))); - break; - case _traced_Nstop : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_try_me : - _p = ((yamop *)(&((_p)->y_u.Otapl.next))); - break; - case _traced_retry_me : - _p = ((yamop *)(&((_p)->y_u.Otapl.next))); - break; - case _traced_trust_me : - _p = ((yamop *)(&((_p)->y_u.Otapl.next))); - break; - case _traced_enter_profiling : - _p = ((yamop *)(&((_p)->y_u.p.next))); - break; - case _traced_retry_profiled : - _p = ((yamop *)(&((_p)->y_u.p.next))); - break; - case _traced_profiled_retry_me : - _p = ((yamop *)(&((_p)->y_u.Otapl.next))); - break; - case _traced_profiled_trust_me : - _p = ((yamop *)(&((_p)->y_u.Otapl.next))); - break; - case _traced_profiled_retry_logical : - _p = ((yamop *)(&((_p)->y_u.OtaLl.next))); - break; - case _traced_profiled_trust_logical : - _p = ((yamop *)(&((_p)->y_u.OtILl.next))); - break; - case _traced_count_call : - _p = ((yamop *)(&((_p)->y_u.p.next))); - break; - case _traced_count_retry : - _p = ((yamop *)(&((_p)->y_u.p.next))); - break; - case _traced_count_retry_me : - _p = ((yamop *)(&((_p)->y_u.Otapl.next))); - break; - case _traced_count_trust_me : - _p = ((yamop *)(&((_p)->y_u.Otapl.next))); - break; - case _traced_count_retry_logical : - _p = ((yamop *)(&((_p)->y_u.OtaLl.next))); - break; - case _traced_count_trust_logical : - _p = ((yamop *)(&((_p)->y_u.OtILl.next))); - break; - case _traced_lock_lu : - _p = ((yamop *)(&((_p)->y_u.p.next))); - break; - case _traced_unlock_lu : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_alloc_for_logical_pred : - _p = ((yamop *)(&((_p)->y_u.L.next))); - break; - case _traced_copy_idb_term : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_unify_idb_term : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_ensure_space : - _p = ((yamop *)(&((_p)->y_u.Osbpa.next))); - break; - case _traced_spy_or_trymark : - _p = ((yamop *)(&((_p)->y_u.Otapl.next))); - break; - case _traced_try_and_mark : - _p = ((yamop *)(&((_p)->y_u.Otapl.next))); - break; - case _traced_count_retry_and_mark : - _p = ((yamop *)(&((_p)->y_u.Otapl.next))); - break; - case _traced_profiled_retry_and_mark : - _p = ((yamop *)(&((_p)->y_u.Otapl.next))); - break; - case _traced_retry_and_mark : - _p = ((yamop *)(&((_p)->y_u.Otapl.next))); - break; - case _traced_trust_fail : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_op_fail : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_cut : - _p = ((yamop *)(&((_p)->y_u.s.next))); - c = 1; - break; - case _traced_cut_t : - _p = ((yamop *)(&((_p)->y_u.s.next))); - c = 1; - break; - case _traced_cut_e : - _p = ((yamop *)(&((_p)->y_u.s.next))); - c = 1; - break; - case _traced_save_b_x : - _p = ((yamop *)(&((_p)->y_u.x.next))); - break; - case _traced_save_b_y : - _p = ((yamop *)(&((_p)->y_u.y.next))); - break; - case _traced_commit_b_x : - _p = ((yamop *)(&((_p)->y_u.xps.next))); - break; - case _traced_commit_b_y : - _p = ((yamop *)(&((_p)->y_u.yps.next))); - break; - case _traced_execute : - _p = ((yamop *)(&((_p)->y_u.pp.next))); - l = (CELL)_p; - if (n > 5) return 0; - break; - case _traced_dexecute : - _p = ((yamop *)(&((_p)->y_u.pp.next))); - l = (CELL)_p; - if (n > 5) return 0; - break; - case _traced_fcall : - _p = ((yamop *)(&((_p)->y_u.Osbpp.next))); - if (c || n <= 3) { c = 0; break; } - return 0; - case _traced_call : - _p = ((yamop *)(&((_p)->y_u.Osbpp.next))); - if (c || n <= 3) { c = 0; break; } - return 0; - case _traced_procceed : - _p = ((yamop *)(&((_p)->y_u.p.next))); - l = (CELL)_p; - break; - case _traced_allocate : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_deallocate : - _p = ((yamop *)(&((_p)->y_u.p.next))); - break; -#ifdef BEAM - case _traced_retry_eam : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; -#endif -#ifdef BEAM - case _traced_run_eam : - _p = ((yamop *)(&((_p)->y_u.os.next))); - break; -#endif - case _traced_get_x_var : - _p = ((yamop *)(&((_p)->y_u.xx.next))); - break; - case _traced_get_y_var : - _p = ((yamop *)(&((_p)->y_u.yx.next))); - break; - case _traced_get_yy_var : - _p = ((yamop *)(&((_p)->y_u.yyxx.next))); - break; - case _traced_get_x_val : - _p = ((yamop *)(&((_p)->y_u.xx.next))); - break; - case _traced_get_y_val : - _p = ((yamop *)(&((_p)->y_u.yx.next))); - break; - case _traced_get_atom : - _p = ((yamop *)(&((_p)->y_u.xc.next))); - break; - case _traced_get_2atoms : - _p = ((yamop *)(&((_p)->y_u.cc.next))); - break; - case _traced_get_3atoms : - _p = ((yamop *)(&((_p)->y_u.ccc.next))); - break; - case _traced_get_4atoms : - _p = ((yamop *)(&((_p)->y_u.cccc.next))); - break; - case _traced_get_5atoms : - _p = ((yamop *)(&((_p)->y_u.ccccc.next))); - break; - case _traced_get_6atoms : - _p = ((yamop *)(&((_p)->y_u.cccccc.next))); - break; - case _traced_get_list : - _p = ((yamop *)(&((_p)->y_u.x.next))); - break; - case _traced_get_struct : - _p = ((yamop *)(&((_p)->y_u.xfa.next))); - break; - case _traced_get_float : - _p = ((yamop *)(&((_p)->y_u.xd.next))); - break; - case _traced_get_longint : - _p = ((yamop *)(&((_p)->y_u.xi.next))); - break; - case _traced_get_bigint : - _p = ((yamop *)(&((_p)->y_u.xN.next))); - break; - case _traced_get_dbterm : - _p = ((yamop *)(&((_p)->y_u.xD.next))); - break; - case _traced_glist_valx : - _p = ((yamop *)(&((_p)->y_u.xx.next))); - break; - case _traced_glist_valy : - _p = ((yamop *)(&((_p)->y_u.yx.next))); - break; - case _traced_gl_void_varx : - _p = ((yamop *)(&((_p)->y_u.xx.next))); - break; - case _traced_gl_void_vary : - _p = ((yamop *)(&((_p)->y_u.yx.next))); - break; - case _traced_gl_void_valx : - _p = ((yamop *)(&((_p)->y_u.xx.next))); - break; - case _traced_gl_void_valy : - _p = ((yamop *)(&((_p)->y_u.yx.next))); - break; - case _traced_unify_x_var : - _p = ((yamop *)(&((_p)->y_u.ox.next))); - break; - case _traced_unify_x_var_write : - _p = ((yamop *)(&((_p)->y_u.ox.next))); - break; - case _traced_unify_l_x_var : - _p = ((yamop *)(&((_p)->y_u.ox.next))); - break; - case _traced_unify_l_x_var_write : - _p = ((yamop *)(&((_p)->y_u.ox.next))); - break; - case _traced_unify_x_var2 : - _p = ((yamop *)(&((_p)->y_u.oxx.next))); - break; - case _traced_unify_x_var2_write : - _p = ((yamop *)(&((_p)->y_u.oxx.next))); - break; - case _traced_unify_l_x_var2 : - _p = ((yamop *)(&((_p)->y_u.oxx.next))); - break; - case _traced_unify_l_x_var2_write : - _p = ((yamop *)(&((_p)->y_u.oxx.next))); - break; - case _traced_unify_y_var : - _p = ((yamop *)(&((_p)->y_u.oy.next))); - break; - case _traced_unify_y_var_write : - _p = ((yamop *)(&((_p)->y_u.oy.next))); - break; - case _traced_unify_l_y_var : - _p = ((yamop *)(&((_p)->y_u.oy.next))); - break; - case _traced_unify_l_y_var_write : - _p = ((yamop *)(&((_p)->y_u.oy.next))); - break; - case _traced_unify_x_val : - _p = ((yamop *)(&((_p)->y_u.ox.next))); - break; - case _traced_unify_x_val_write : - _p = ((yamop *)(&((_p)->y_u.ox.next))); - break; - case _traced_unify_l_x_val : - _p = ((yamop *)(&((_p)->y_u.ox.next))); - break; - case _traced_unify_l_x_val_write : - _p = ((yamop *)(&((_p)->y_u.ox.next))); - break; - case _traced_unify_y_val : - _p = ((yamop *)(&((_p)->y_u.oy.next))); - break; - case _traced_unify_y_val_write : - _p = ((yamop *)(&((_p)->y_u.oy.next))); - break; - case _traced_unify_l_y_val : - _p = ((yamop *)(&((_p)->y_u.oy.next))); - break; - case _traced_unify_l_y_val_write : - _p = ((yamop *)(&((_p)->y_u.oy.next))); - break; - case _traced_unify_x_loc : - _p = ((yamop *)(&((_p)->y_u.ox.next))); - break; - case _traced_unify_x_loc_write : - _p = ((yamop *)(&((_p)->y_u.ox.next))); - break; - case _traced_unify_l_x_loc : - _p = ((yamop *)(&((_p)->y_u.ox.next))); - break; - case _traced_unify_l_x_loc_write : - _p = ((yamop *)(&((_p)->y_u.ox.next))); - break; - case _traced_unify_y_loc : - _p = ((yamop *)(&((_p)->y_u.oy.next))); - break; - case _traced_unify_y_loc_write : - _p = ((yamop *)(&((_p)->y_u.oy.next))); - break; - case _traced_unify_l_y_loc : - _p = ((yamop *)(&((_p)->y_u.oy.next))); - break; - case _traced_unify_l_y_loc_write : - _p = ((yamop *)(&((_p)->y_u.oy.next))); - break; - case _traced_unify_void : - _p = ((yamop *)(&((_p)->y_u.o.next))); - break; - case _traced_unify_void_write : - _p = ((yamop *)(&((_p)->y_u.o.next))); - break; - case _traced_unify_l_void : - _p = ((yamop *)(&((_p)->y_u.o.next))); - break; - case _traced_unify_l_void_write : - _p = ((yamop *)(&((_p)->y_u.o.next))); - break; - case _traced_unify_n_voids : - _p = ((yamop *)(&((_p)->y_u.os.next))); - break; - case _traced_unify_n_voids_write : - _p = ((yamop *)(&((_p)->y_u.os.next))); - break; - case _traced_unify_l_n_voids : - _p = ((yamop *)(&((_p)->y_u.os.next))); - break; - case _traced_unify_l_n_voids_write : - _p = ((yamop *)(&((_p)->y_u.os.next))); - break; - case _traced_unify_atom : - _p = ((yamop *)(&((_p)->y_u.oc.next))); - break; - case _traced_unify_atom_write : - _p = ((yamop *)(&((_p)->y_u.oc.next))); - break; - case _traced_unify_l_atom : - _p = ((yamop *)(&((_p)->y_u.oc.next))); - break; - case _traced_unify_l_atom_write : - _p = ((yamop *)(&((_p)->y_u.oc.next))); - break; - case _traced_unify_n_atoms : - _p = ((yamop *)(&((_p)->y_u.osc.next))); - break; - case _traced_unify_n_atoms_write : - _p = ((yamop *)(&((_p)->y_u.osc.next))); - break; - case _traced_unify_float : - _p = ((yamop *)(&((_p)->y_u.od.next))); - break; - case _traced_unify_float_write : - _p = ((yamop *)(&((_p)->y_u.od.next))); - break; - case _traced_unify_l_float : - _p = ((yamop *)(&((_p)->y_u.od.next))); - break; - case _traced_unify_l_float_write : - _p = ((yamop *)(&((_p)->y_u.od.next))); - break; - case _traced_unify_longint : - _p = ((yamop *)(&((_p)->y_u.oi.next))); - break; - case _traced_unify_longint_write : - _p = ((yamop *)(&((_p)->y_u.oi.next))); - break; - case _traced_unify_l_longint : - _p = ((yamop *)(&((_p)->y_u.oi.next))); - break; - case _traced_unify_l_longint_write : - _p = ((yamop *)(&((_p)->y_u.oi.next))); - break; - case _traced_unify_bigint : - _p = ((yamop *)(&((_p)->y_u.oN.next))); - break; - case _traced_unify_l_bigint : - _p = ((yamop *)(&((_p)->y_u.oN.next))); - break; - case _traced_unify_dbterm : - _p = ((yamop *)(&((_p)->y_u.oD.next))); - break; - case _traced_unify_l_dbterm : - _p = ((yamop *)(&((_p)->y_u.oD.next))); - break; - case _traced_unify_list : - _p = ((yamop *)(&((_p)->y_u.o.next))); - break; - case _traced_unify_list_write : - _p = ((yamop *)(&((_p)->y_u.o.next))); - break; - case _traced_unify_l_list : - _p = ((yamop *)(&((_p)->y_u.o.next))); - break; - case _traced_unify_l_list_write : - _p = ((yamop *)(&((_p)->y_u.o.next))); - break; - case _traced_unify_struct : - _p = ((yamop *)(&((_p)->y_u.ofa.next))); - break; - case _traced_unify_struct_write : - _p = ((yamop *)(&((_p)->y_u.ofa.next))); - break; - case _traced_unify_l_struc : - _p = ((yamop *)(&((_p)->y_u.ofa.next))); - break; - case _traced_unify_l_struc_write : - _p = ((yamop *)(&((_p)->y_u.ofa.next))); - break; - case _traced_put_x_var : - _p = ((yamop *)(&((_p)->y_u.xx.next))); - break; - case _traced_put_y_var : - _p = ((yamop *)(&((_p)->y_u.yx.next))); - break; - case _traced_put_x_val : - _p = ((yamop *)(&((_p)->y_u.xx.next))); - break; - case _traced_put_xx_val : - _p = ((yamop *)(&((_p)->y_u.xxxx.next))); - break; - case _traced_put_y_val : - _p = ((yamop *)(&((_p)->y_u.yx.next))); - break; - case _traced_put_y_vals : - _p = ((yamop *)(&((_p)->y_u.yyxx.next))); - break; - case _traced_put_unsafe : - _p = ((yamop *)(&((_p)->y_u.yx.next))); - break; - case _traced_put_atom : - _p = ((yamop *)(&((_p)->y_u.xc.next))); - break; - case _traced_put_dbterm : - _p = ((yamop *)(&((_p)->y_u.xD.next))); - break; - case _traced_put_bigint : - _p = ((yamop *)(&((_p)->y_u.xN.next))); - break; - case _traced_put_float : - _p = ((yamop *)(&((_p)->y_u.xd.next))); - break; - case _traced_put_longint : - _p = ((yamop *)(&((_p)->y_u.xi.next))); - break; - case _traced_put_list : - _p = ((yamop *)(&((_p)->y_u.x.next))); - break; - case _traced_put_struct : - _p = ((yamop *)(&((_p)->y_u.xfa.next))); - break; - case _traced_write_x_var : - _p = ((yamop *)(&((_p)->y_u.x.next))); - break; - case _traced_write_void : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_write_n_voids : - _p = ((yamop *)(&((_p)->y_u.s.next))); - break; - case _traced_write_y_var : - _p = ((yamop *)(&((_p)->y_u.y.next))); - break; - case _traced_write_x_val : - _p = ((yamop *)(&((_p)->y_u.x.next))); - break; - case _traced_write_x_loc : - _p = ((yamop *)(&((_p)->y_u.x.next))); - break; - case _traced_write_y_val : - _p = ((yamop *)(&((_p)->y_u.y.next))); - break; - case _traced_write_y_loc : - _p = ((yamop *)(&((_p)->y_u.y.next))); - break; - case _traced_write_atom : - _p = ((yamop *)(&((_p)->y_u.c.next))); - break; - case _traced_write_bigint : - _p = ((yamop *)(&((_p)->y_u.N.next))); - break; - case _traced_write_dbterm : - _p = ((yamop *)(&((_p)->y_u.D.next))); - break; - case _traced_write_float : - _p = ((yamop *)(&((_p)->y_u.d.next))); - break; - case _traced_write_longint : - _p = ((yamop *)(&((_p)->y_u.i.next))); - break; - case _traced_write_n_atoms : - _p = ((yamop *)(&((_p)->y_u.sc.next))); - break; - case _traced_write_list : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_write_l_list : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_write_struct : - _p = ((yamop *)(&((_p)->y_u.fa.next))); - break; - case _traced_write_l_struc : - _p = ((yamop *)(&((_p)->y_u.fa.next))); - break; - case _traced_save_pair_x : - _p = ((yamop *)(&((_p)->y_u.ox.next))); - break; - case _traced_save_pair_x_write : - _p = ((yamop *)(&((_p)->y_u.ox.next))); - break; - case _traced_save_pair_y : - _p = ((yamop *)(&((_p)->y_u.oy.next))); - break; - case _traced_save_pair_y_write : - _p = ((yamop *)(&((_p)->y_u.oy.next))); - break; - case _traced_save_appl_x : - _p = ((yamop *)(&((_p)->y_u.ox.next))); - break; - case _traced_save_appl_x_write : - _p = ((yamop *)(&((_p)->y_u.ox.next))); - break; - case _traced_save_appl_y : - _p = ((yamop *)(&((_p)->y_u.oy.next))); - break; - case _traced_save_appl_y_write : - _p = ((yamop *)(&((_p)->y_u.oy.next))); - break; - case _traced_jump : - _p = ((yamop *)(&((_p)->y_u.l.next))); - break; - case _traced_move_back : - _p = ((yamop *)(&((_p)->y_u.l.next))); - break; - case _traced_skip : - _p = ((yamop *)(&((_p)->y_u.l.next))); - break; - case _traced_either : - _p = ((yamop *)(&((_p)->y_u.Osblp.next))); - break; - case _traced_or_else : - _p = ((yamop *)(&((_p)->y_u.Osblp.next))); - break; - case _traced_pop_n : - _p = ((yamop *)(&((_p)->y_u.s.next))); - break; - case _traced_pop : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_call_cpred : - _p = ((yamop *)(&((_p)->y_u.Osbpp.next))); - break; - case _traced_execute_cpred : - _p = ((yamop *)(&((_p)->y_u.pp.next))); - break; - case _traced_call_usercpred : - _p = ((yamop *)(&((_p)->y_u.Osbpp.next))); - break; - case _traced_call_c_wfail : - _p = ((yamop *)(&((_p)->y_u.slp.next))); - break; - case _traced_try_c : - _p = ((yamop *)(&((_p)->y_u.OtapFs.next))); - break; - case _traced_retry_c : - _p = ((yamop *)(&((_p)->y_u.OtapFs.next))); - break; -#ifdef CUT_C - case _traced_cut_c : - _p = ((yamop *)(&((_p)->y_u.OtapFs.next))); - c = 1; - break; -#endif - case _traced_try_userc : - _p = ((yamop *)(&((_p)->y_u.OtapFs.next))); - break; - case _traced_retry_userc : - _p = ((yamop *)(&((_p)->y_u.OtapFs.next))); - break; -#ifdef CUT_C - case _traced_cut_userc : - _p = ((yamop *)(&((_p)->y_u.OtapFs.next))); - c = 1; - break; -#endif - case _traced_lock_pred : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_index_pred : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; -#ifdef THREADS - case _traced_thread_local : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; -#endif - case _traced_expand_index : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_expand_clauses : - _p = ((yamop *)(&((_p)->y_u.sssllp.next))); - break; - case _traced_undef_p : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_spy_pred : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_try_clause : - _p = ((yamop *)(&((_p)->y_u.Otapl.next))); - break; - case _traced_try_clause2 : - _p = ((yamop *)(&((_p)->y_u.l.next))); - break; - case _traced_try_clause3 : - _p = ((yamop *)(&((_p)->y_u.l.next))); - break; - case _traced_try_clause4 : - _p = ((yamop *)(&((_p)->y_u.l.next))); - break; - case _traced_retry : - _p = ((yamop *)(&((_p)->y_u.Otapl.next))); - break; - case _traced_retry2 : - _p = ((yamop *)(&((_p)->y_u.l.next))); - break; - case _traced_retry3 : - _p = ((yamop *)(&((_p)->y_u.l.next))); - break; - case _traced_retry4 : - _p = ((yamop *)(&((_p)->y_u.l.next))); - break; - case _traced_trust : - _p = ((yamop *)(&((_p)->y_u.Otapl.next))); - break; - case _traced_try_in : - _p = ((yamop *)(&((_p)->y_u.l.next))); - break; - case _traced_enter_lu_pred : - _p = ((yamop *)(&((_p)->y_u.Illss.next))); - break; - case _traced_try_logical : - _p = ((yamop *)(&((_p)->y_u.OtaLl.next))); - break; - case _traced_retry_logical : - _p = ((yamop *)(&((_p)->y_u.OtaLl.next))); - break; - case _traced_trust_logical : - _p = ((yamop *)(&((_p)->y_u.OtILl.next))); - break; - case _traced_user_switch : - _p = ((yamop *)(&((_p)->y_u.lp.next))); - break; - case _traced_switch_on_type : - _p = ((yamop *)(&((_p)->y_u.llll.next))); - break; - case _traced_switch_list_nl : - _p = ((yamop *)(&((_p)->y_u.ollll.next))); - break; - case _traced_switch_on_arg_type : - _p = ((yamop *)(&((_p)->y_u.xllll.next))); - break; - case _traced_switch_on_sub_arg_type : - _p = ((yamop *)(&((_p)->y_u.sllll.next))); - break; - case _traced_jump_if_var : - _p = ((yamop *)(&((_p)->y_u.l.next))); - break; - case _traced_jump_if_nonvar : - _p = ((yamop *)(&((_p)->y_u.xll.next))); - break; - case _traced_if_not_then : - _p = ((yamop *)(&((_p)->y_u.clll.next))); - break; - case _traced_switch_on_func : - _p = ((yamop *)(&((_p)->y_u.sssl.next))); - break; - case _traced_switch_on_cons : - _p = ((yamop *)(&((_p)->y_u.sssl.next))); - break; - case _traced_go_on_func : - _p = ((yamop *)(&((_p)->y_u.sssl.next))); - break; - case _traced_go_on_cons : - _p = ((yamop *)(&((_p)->y_u.sssl.next))); - break; - case _traced_if_func : - _p = ((yamop *)(&((_p)->y_u.sssl.next))); - break; - case _traced_if_cons : - _p = ((yamop *)(&((_p)->y_u.sssl.next))); - break; - case _traced_index_dbref : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_index_blob : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_index_long : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_jit_handler : - _p = ((yamop *)(&((_p)->y_u.J.next))); - break; - case _traced_p_atom_x : - _p = ((yamop *)(&((_p)->y_u.xl.next))); - break; - case _traced_p_atom_y : - _p = ((yamop *)(&((_p)->y_u.yl.next))); - break; - case _traced_p_atomic_x : - _p = ((yamop *)(&((_p)->y_u.xl.next))); - break; - case _traced_p_atomic_y : - _p = ((yamop *)(&((_p)->y_u.yl.next))); - break; - case _traced_p_integer_x : - _p = ((yamop *)(&((_p)->y_u.xl.next))); - break; - case _traced_p_integer_y : - _p = ((yamop *)(&((_p)->y_u.yl.next))); - break; - case _traced_p_nonvar_x : - _p = ((yamop *)(&((_p)->y_u.xl.next))); - break; - case _traced_p_nonvar_y : - _p = ((yamop *)(&((_p)->y_u.yl.next))); - break; - case _traced_p_number_x : - _p = ((yamop *)(&((_p)->y_u.xl.next))); - break; - case _traced_p_number_y : - _p = ((yamop *)(&((_p)->y_u.yl.next))); - break; - case _traced_p_var_x : - _p = ((yamop *)(&((_p)->y_u.xl.next))); - break; - case _traced_p_var_y : - _p = ((yamop *)(&((_p)->y_u.yl.next))); - break; - case _traced_p_db_ref_x : - _p = ((yamop *)(&((_p)->y_u.xl.next))); - break; - case _traced_p_db_ref_y : - _p = ((yamop *)(&((_p)->y_u.yl.next))); - break; - case _traced_p_primitive_x : - _p = ((yamop *)(&((_p)->y_u.xl.next))); - break; - case _traced_p_primitive_y : - _p = ((yamop *)(&((_p)->y_u.yl.next))); - break; - case _traced_p_compound_x : - _p = ((yamop *)(&((_p)->y_u.xl.next))); - break; - case _traced_p_compound_y : - _p = ((yamop *)(&((_p)->y_u.yl.next))); - break; - case _traced_p_float_x : - _p = ((yamop *)(&((_p)->y_u.xl.next))); - break; - case _traced_p_float_y : - _p = ((yamop *)(&((_p)->y_u.yl.next))); - break; - case _traced_p_plus_vv : - _p = ((yamop *)(&((_p)->y_u.xxx.next))); - break; - case _traced_p_plus_vc : - _p = ((yamop *)(&((_p)->y_u.xxn.next))); - break; - case _traced_p_plus_y_vv : - _p = ((yamop *)(&((_p)->y_u.yxx.next))); - break; - case _traced_p_plus_y_vc : - _p = ((yamop *)(&((_p)->y_u.yxn.next))); - break; - case _traced_p_minus_vv : - _p = ((yamop *)(&((_p)->y_u.xxx.next))); - break; - case _traced_p_minus_cv : - _p = ((yamop *)(&((_p)->y_u.xxn.next))); - break; - case _traced_p_minus_y_vv : - _p = ((yamop *)(&((_p)->y_u.yxx.next))); - break; - case _traced_p_minus_y_cv : - _p = ((yamop *)(&((_p)->y_u.yxn.next))); - break; - case _traced_p_times_vv : - _p = ((yamop *)(&((_p)->y_u.xxx.next))); - break; - case _traced_p_times_vc : - _p = ((yamop *)(&((_p)->y_u.xxn.next))); - break; - case _traced_p_times_y_vv : - _p = ((yamop *)(&((_p)->y_u.yxx.next))); - break; - case _traced_p_times_y_vc : - _p = ((yamop *)(&((_p)->y_u.yxn.next))); - break; - case _traced_p_div_vv : - _p = ((yamop *)(&((_p)->y_u.xxx.next))); - break; - case _traced_p_div_vc : - _p = ((yamop *)(&((_p)->y_u.xxn.next))); - break; - case _traced_p_div_cv : - _p = ((yamop *)(&((_p)->y_u.xxn.next))); - break; - case _traced_p_div_y_vv : - _p = ((yamop *)(&((_p)->y_u.yxx.next))); - break; - case _traced_p_div_y_vc : - _p = ((yamop *)(&((_p)->y_u.yxn.next))); - break; - case _traced_p_div_y_cv : - _p = ((yamop *)(&((_p)->y_u.yxn.next))); - break; - case _traced_p_and_vv : - _p = ((yamop *)(&((_p)->y_u.xxx.next))); - break; - case _traced_p_and_vc : - _p = ((yamop *)(&((_p)->y_u.xxn.next))); - break; - case _traced_p_and_y_vv : - _p = ((yamop *)(&((_p)->y_u.yxx.next))); - break; - case _traced_p_and_y_vc : - _p = ((yamop *)(&((_p)->y_u.yxn.next))); - break; - case _traced_p_or_vv : - _p = ((yamop *)(&((_p)->y_u.xxx.next))); - break; - case _traced_p_or_vc : - _p = ((yamop *)(&((_p)->y_u.xxn.next))); - break; - case _traced_p_or_y_vv : - _p = ((yamop *)(&((_p)->y_u.yxx.next))); - break; - case _traced_p_or_y_vc : - _p = ((yamop *)(&((_p)->y_u.yxn.next))); - break; - case _traced_p_sll_vv : - _p = ((yamop *)(&((_p)->y_u.xxx.next))); - break; - case _traced_p_sll_vc : - _p = ((yamop *)(&((_p)->y_u.xxn.next))); - break; - case _traced_p_sll_cv : - _p = ((yamop *)(&((_p)->y_u.xxn.next))); - break; - case _traced_p_sll_y_vv : - _p = ((yamop *)(&((_p)->y_u.yxx.next))); - break; - case _traced_p_sll_y_vc : - _p = ((yamop *)(&((_p)->y_u.yxn.next))); - break; - case _traced_p_sll_y_cv : - _p = ((yamop *)(&((_p)->y_u.yxn.next))); - break; - case _traced_p_slr_vv : - _p = ((yamop *)(&((_p)->y_u.xxx.next))); - break; - case _traced_p_slr_vc : - _p = ((yamop *)(&((_p)->y_u.xxn.next))); - break; - case _traced_p_slr_cv : - _p = ((yamop *)(&((_p)->y_u.xxn.next))); - break; - case _traced_p_slr_y_vv : - _p = ((yamop *)(&((_p)->y_u.yxx.next))); - break; - case _traced_p_slr_y_vc : - _p = ((yamop *)(&((_p)->y_u.yxn.next))); - break; - case _traced_p_slr_y_cv : - _p = ((yamop *)(&((_p)->y_u.yxn.next))); - break; - case _traced_call_bfunc_xx : - _p = ((yamop *)(&((_p)->y_u.plxxs.next))); - break; - case _traced_call_bfunc_yx : - _p = ((yamop *)(&((_p)->y_u.plxys.next))); - break; - case _traced_call_bfunc_xy : - _p = ((yamop *)(&((_p)->y_u.plxys.next))); - break; - case _traced_call_bfunc_yy : - _p = ((yamop *)(&((_p)->y_u.plyys.next))); - break; - case _traced_p_equal : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_p_dif : - _p = ((yamop *)(&((_p)->y_u.l.next))); - break; - case _traced_p_eq : - _p = ((yamop *)(&((_p)->y_u.l.next))); - break; - case _traced_p_arg_vv : - _p = ((yamop *)(&((_p)->y_u.xxx.next))); - break; - case _traced_p_arg_cv : - _p = ((yamop *)(&((_p)->y_u.xxn.next))); - break; - case _traced_p_arg_y_vv : - _p = ((yamop *)(&((_p)->y_u.yxx.next))); - break; - case _traced_p_arg_y_cv : - _p = ((yamop *)(&((_p)->y_u.yxn.next))); - break; - case _traced_p_func2s_vv : - _p = ((yamop *)(&((_p)->y_u.xxx.next))); - break; - case _traced_p_func2s_cv : - _p = ((yamop *)(&((_p)->y_u.xxc.next))); - break; - case _traced_p_func2s_vc : - _p = ((yamop *)(&((_p)->y_u.xxn.next))); - break; - case _traced_p_func2s_y_vv : - _p = ((yamop *)(&((_p)->y_u.yxx.next))); - break; - case _traced_p_func2s_y_cv : - _p = ((yamop *)(&((_p)->y_u.yxn.next))); - break; - case _traced_p_func2s_y_vc : - _p = ((yamop *)(&((_p)->y_u.yxn.next))); - break; - case _traced_p_func2f_xx : - _p = ((yamop *)(&((_p)->y_u.xxx.next))); - break; - case _traced_p_func2f_xy : - _p = ((yamop *)(&((_p)->y_u.xxy.next))); - break; - case _traced_p_func2f_yx : - _p = ((yamop *)(&((_p)->y_u.yxx.next))); - break; - case _traced_p_func2f_yy : - _p = ((yamop *)(&((_p)->y_u.yyx.next))); - break; - case _traced_p_functor : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_p_execute2 : - _p = ((yamop *)(&((_p)->y_u.Osbpp.next))); - break; - case _traced_p_execute : - _p = ((yamop *)(&((_p)->y_u.Osbmp.next))); - break; - case _traced_p_execute_tail : - _p = ((yamop *)(&((_p)->y_u.Osbpp.next))); - break; -#ifdef YAPOR - case _traced_getwork_first_time : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_getwork : - _p = ((yamop *)(&((_p)->y_u.Otapl.next))); - break; - case _traced_getwork_seq : - _p = ((yamop *)(&((_p)->y_u.Otapl.next))); - break; - case _traced_sync : - _p = ((yamop *)(&((_p)->y_u.Otapl.next))); - break; -#endif -#ifdef TABLING -#ifdef TABLING_INNER_CUTS - case _traced_clause_with_cut : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; -#endif - case _traced_table_load_answer : - _p = ((yamop *)(&((_p)->y_u.Otapl.next))); - break; - case _traced_table_try_answer : - _p = ((yamop *)(&((_p)->y_u.Otapl.next))); - break; - case _traced_table_try_single : - _p = ((yamop *)(&((_p)->y_u.Otapl.next))); - break; - case _traced_table_try_me : - _p = ((yamop *)(&((_p)->y_u.Otapl.next))); - break; - case _traced_table_try : - _p = ((yamop *)(&((_p)->y_u.Otapl.next))); - break; - case _traced_table_retry_me : - _p = ((yamop *)(&((_p)->y_u.Otapl.next))); - break; - case _traced_table_retry : - _p = ((yamop *)(&((_p)->y_u.Otapl.next))); - break; - case _traced_table_trust_me : - _p = ((yamop *)(&((_p)->y_u.Otapl.next))); - break; - case _traced_table_trust : - _p = ((yamop *)(&((_p)->y_u.Otapl.next))); - break; - case _traced_table_new_answer : - _p = ((yamop *)(&((_p)->y_u.s.next))); - break; - case _traced_table_answer_resolution : - _p = ((yamop *)(&((_p)->y_u.Otapl.next))); - break; - case _traced_table_completion : - _p = ((yamop *)(&((_p)->y_u.Otapl.next))); - break; -#ifdef THREADS_CONSUMER_SHARING - case _traced_table_answer_resolution_completion: - _p = ((yamop *)(&((_p)->y_u.Otapl.next))); - break; -#endif - case _traced_trie_do_var : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_trie_trust_var : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_trie_try_var : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_trie_retry_var : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_trie_do_var_in_pair : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_trie_trust_var_in_pair : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_trie_try_var_in_pair : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_trie_retry_var_in_pair : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_trie_do_val : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_trie_trust_val : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_trie_try_val : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_trie_retry_val : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_trie_do_val_in_pair : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_trie_trust_val_in_pair : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_trie_try_val_in_pair : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_trie_retry_val_in_pair : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_trie_do_atom : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_trie_trust_atom : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_trie_try_atom : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_trie_retry_atom : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_trie_do_atom_in_pair : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_trie_trust_atom_in_pair : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_trie_try_atom_in_pair : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_trie_retry_atom_in_pair : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_trie_do_null : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_trie_trust_null : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_trie_try_null : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_trie_retry_null : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_trie_do_null_in_pair : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_trie_trust_null_in_pair : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_trie_try_null_in_pair : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_trie_retry_null_in_pair : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_trie_do_pair : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_trie_trust_pair : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_trie_try_pair : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_trie_retry_pair : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_trie_do_appl : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_trie_trust_appl : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_trie_try_appl : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_trie_retry_appl : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_trie_do_appl_in_pair : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_trie_trust_appl_in_pair : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_trie_try_appl_in_pair : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_trie_retry_appl_in_pair : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_trie_do_extension : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_trie_trust_extension : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_trie_try_extension : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_trie_retry_extension : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_trie_do_double : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_trie_trust_double : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_trie_try_double : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_trie_retry_double : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_trie_do_longint : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_trie_trust_longint : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_trie_try_longint : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_trie_retry_longint : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_trie_do_gterm : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_trie_trust_gterm : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_trie_try_gterm : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_trie_retry_gterm : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; -#endif -#ifdef YAPOR - case _traced_or_last : - _p = ((yamop *)(&((_p)->y_u.sblp.next))); - break; -#else - case _traced_or_last : - _p = ((yamop *)(&((_p)->y_u.p.next))); - break; #endif default: return 0; diff --git a/JIT/HPP/JIT.hpp b/JIT/HPP/JIT.hpp index 5be738e74..94c41f236 100644 --- a/JIT/HPP/JIT.hpp +++ b/JIT/HPP/JIT.hpp @@ -12,6 +12,9 @@ #include #include #include "config.h" +#if USE_GMP +#include +#endif extern "C" { #include "absmi.h" } diff --git a/JIT/HPP/JIT_Compiler.hpp b/JIT/HPP/JIT_Compiler.hpp index 08551309a..395e3dc10 100644 --- a/JIT/HPP/JIT_Compiler.hpp +++ b/JIT/HPP/JIT_Compiler.hpp @@ -89,26 +89,21 @@ class JIT_Compiler { /* method invoked by wrapper 'call_JIT_Compiler' */ void* compile(yamop*); }; - #else - struct JIT_Compiler{}; // Doing this, I can call class 'JIT_Compiler' from C code + extern "C" void* call_JIT_Compiler(JIT_Compiler* jc, yamop* p); - #endif - - #ifdef __cplusplus - -extern "C" void* call_JIT_Compiler(JIT_Compiler* jc, yamop* p) { return jc->compile(p); } - -extern "C" void shutdown_llvm() { llvm_shutdown(); } + extern "C" void shutdown_llvm(); #else -INLINE_ONLY inline EXTERN void* call_JIT_Compiler(struct JIT_Compiler* jc, yamop* p); +typedef struct jit_compiler JIT_Compiler; -extern void* (*Yap_JitCall)(struct JIT_Compiler* jc, yamop* p); +EXTERN void* (*Yap_JitCall)(JIT_Compiler* jc, yamop* p); +INLINE_ONLY inline EXTERN void* call_JIT_Compiler(JIT_Compiler* jc, yamop* p); -INLINE_ONLY inline EXTERN void* call_JIT_Compiler(struct JIT_Compiler* jc, yamop* p) { return Yap_JitCall (jc,p); } +INLINE_ONLY inline EXTERN void* call_JIT_Compiler(JIT_Compiler* jc, yamop* p) { + return Yap_JitCall (jc,p); } INLINE_ONLY inline EXTERN void shutdown_llvm(void ) ; @@ -116,6 +111,6 @@ EXTERN void (* Yap_llvmShutdown)(void ) ; INLINE_ONLY inline EXTERN void shutdown_llvm(void ) { Yap_llvmShutdown (); } -#endif //#ifdef __cplusplus +#endif #endif diff --git a/JIT/HPP/PassPrinters.hh b/JIT/HPP/PassPrinters.hh index 9bc4c5ab4..91205b5e5 100644 --- a/JIT/HPP/PassPrinters.hh +++ b/JIT/HPP/PassPrinters.hh @@ -30,8 +30,8 @@ struct CallGraphSCCPassPrinter : public CallGraphSCCPass { const PassInfo *PassToPrint; std::string PassName; - CallGraphSCCPassPrinter(const PassInfo *PI) : - CallGraphSCCPass(ID), PassToPrint(PI) { + CallGraphSCCPassPrinter(const PassInfo *PassInfo) : + CallGraphSCCPass(ID), PassToPrint(PassInfo) { std::string PassToPrintName = PassToPrint->getPassName(); PassName = "CallGraphSCCPass Printer: " + PassToPrintName; } @@ -64,8 +64,8 @@ struct ModulePassPrinter : public ModulePass { const PassInfo *PassToPrint; std::string PassName; - ModulePassPrinter(const PassInfo *PI) - : ModulePass(ID), PassToPrint(PI) { + ModulePassPrinter(const PassInfo *PassInfo) + : ModulePass(ID), PassToPrint(PassInfo) { std::string PassToPrintName = PassToPrint->getPassName(); PassName = "ModulePass Printer: " + PassToPrintName; } @@ -93,8 +93,8 @@ struct FunctionPassPrinter : public FunctionPass { static char ID; std::string PassName; - FunctionPassPrinter(const PassInfo *PI) - : FunctionPass(ID), PassToPrint(PI) { + FunctionPassPrinter(const PassInfo *PassInfo) + : FunctionPass(ID), PassToPrint(PassInfo) { std::string PassToPrintName = PassToPrint->getPassName(); PassName = "FunctionPass Printer: " + PassToPrintName; } @@ -124,8 +124,8 @@ struct LoopPassPrinter : public LoopPass { const PassInfo *PassToPrint; std::string PassName; - LoopPassPrinter(const PassInfo *PI) : - LoopPass(ID), PassToPrint(PI) { + LoopPassPrinter(const PassInfo *PassInfo) : + LoopPass(ID), PassToPrint(PassInfo) { std::string PassToPrintName = PassToPrint->getPassName(); PassName = "LoopPass Printer: " + PassToPrintName; } @@ -155,8 +155,8 @@ struct RegionPassPrinter : public RegionPass { const PassInfo *PassToPrint; std::string PassName; - RegionPassPrinter(const PassInfo *PI) : RegionPass(ID), - PassToPrint(PI) { + RegionPassPrinter(const PassInfo *PassInfo) : RegionPass(ID), + PassToPrint(PassInfo) { std::string PassToPrintName = PassToPrint->getPassName(); PassName = "RegionPass Printer: " + PassToPrintName; } diff --git a/JIT/HPP/lastop.h b/JIT/HPP/lastop.h index 1fe127ccd..64a5ee14a 100644 --- a/JIT/HPP/lastop.h +++ b/JIT/HPP/lastop.h @@ -1196,1199 +1196,7 @@ lastop_of(yamop* _p) { _p = ((yamop *)(&((_p)->y_u.p.next))); break; #endif - case _traced_Ystop : - _p = ((yamop *)(&((_p)->y_u.l.next))); - break; - case _traced_Nstop : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_try_me : - _p = ((yamop *)(&((_p)->y_u.Otapl.next))); - break; - case _traced_retry_me : - _p = ((yamop *)(&((_p)->y_u.Otapl.next))); - break; - case _traced_trust_me : - _p = ((yamop *)(&((_p)->y_u.Otapl.next))); - break; - case _traced_enter_profiling : - _p = ((yamop *)(&((_p)->y_u.p.next))); - break; - case _traced_retry_profiled : - _p = ((yamop *)(&((_p)->y_u.p.next))); - break; - case _traced_profiled_retry_me : - _p = ((yamop *)(&((_p)->y_u.Otapl.next))); - break; - case _traced_profiled_trust_me : - _p = ((yamop *)(&((_p)->y_u.Otapl.next))); - break; - case _traced_profiled_retry_logical : - _p = ((yamop *)(&((_p)->y_u.OtaLl.next))); - break; - case _traced_profiled_trust_logical : - _p = ((yamop *)(&((_p)->y_u.OtILl.next))); - break; - case _traced_count_call : - _p = ((yamop *)(&((_p)->y_u.p.next))); - break; - case _traced_count_retry : - _p = ((yamop *)(&((_p)->y_u.p.next))); - break; - case _traced_count_retry_me : - _p = ((yamop *)(&((_p)->y_u.Otapl.next))); - break; - case _traced_count_trust_me : - _p = ((yamop *)(&((_p)->y_u.Otapl.next))); - break; - case _traced_count_retry_logical : - _p = ((yamop *)(&((_p)->y_u.OtaLl.next))); - break; - case _traced_count_trust_logical : - _p = ((yamop *)(&((_p)->y_u.OtILl.next))); - break; - case _traced_lock_lu : - _p = ((yamop *)(&((_p)->y_u.p.next))); - break; - case _traced_unlock_lu : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_alloc_for_logical_pred : - _p = ((yamop *)(&((_p)->y_u.L.next))); - break; - case _traced_copy_idb_term : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_unify_idb_term : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_ensure_space : - _p = ((yamop *)(&((_p)->y_u.Osbpa.next))); - break; - case _traced_spy_or_trymark : - _p = ((yamop *)(&((_p)->y_u.Otapl.next))); - break; - case _traced_try_and_mark : - _p = ((yamop *)(&((_p)->y_u.Otapl.next))); - break; - case _traced_count_retry_and_mark : - _p = ((yamop *)(&((_p)->y_u.Otapl.next))); - break; - case _traced_profiled_retry_and_mark : - _p = ((yamop *)(&((_p)->y_u.Otapl.next))); - break; - case _traced_retry_and_mark : - _p = ((yamop *)(&((_p)->y_u.Otapl.next))); - break; - case _traced_trust_fail : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_op_fail : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_cut : - _p = ((yamop *)(&((_p)->y_u.s.next))); - break; - case _traced_cut_t : - _p = ((yamop *)(&((_p)->y_u.s.next))); - break; - case _traced_cut_e : - _p = ((yamop *)(&((_p)->y_u.s.next))); - break; - case _traced_save_b_x : - _p = ((yamop *)(&((_p)->y_u.x.next))); - break; - case _traced_save_b_y : - _p = ((yamop *)(&((_p)->y_u.y.next))); - break; - case _traced_commit_b_x : - _p = ((yamop *)(&((_p)->y_u.xps.next))); - break; - case _traced_commit_b_y : - _p = ((yamop *)(&((_p)->y_u.yps.next))); - break; - case _traced_execute : - _p = ((yamop *)(&((_p)->y_u.pp.next))); - break; - case _traced_dexecute : - _p = ((yamop *)(&((_p)->y_u.pp.next))); - break; - case _traced_fcall : - _p = ((yamop *)(&((_p)->y_u.Osbpp.next))); - break; - case _traced_call : - _p = ((yamop *)(&((_p)->y_u.Osbpp.next))); - break; - case _traced_procceed : - _p = ((yamop *)(&((_p)->y_u.p.next))); - l = (CELL)_p; - break; - case _traced_allocate : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_deallocate : - _p = ((yamop *)(&((_p)->y_u.p.next))); - break; -#ifdef BEAM - case _traced_retry_eam : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; -#endif -#ifdef BEAM - case _traced_run_eam : - _p = ((yamop *)(&((_p)->y_u.os.next))); - break; -#endif - case _traced_get_x_var : - _p = ((yamop *)(&((_p)->y_u.xx.next))); - break; - case _traced_get_y_var : - _p = ((yamop *)(&((_p)->y_u.yx.next))); - break; - case _traced_get_yy_var : - _p = ((yamop *)(&((_p)->y_u.yyxx.next))); - break; - case _traced_get_x_val : - _p = ((yamop *)(&((_p)->y_u.xx.next))); - break; - case _traced_get_y_val : - _p = ((yamop *)(&((_p)->y_u.yx.next))); - break; - case _traced_get_atom : - _p = ((yamop *)(&((_p)->y_u.xc.next))); - break; - case _traced_get_2atoms : - _p = ((yamop *)(&((_p)->y_u.cc.next))); - break; - case _traced_get_3atoms : - _p = ((yamop *)(&((_p)->y_u.ccc.next))); - break; - case _traced_get_4atoms : - _p = ((yamop *)(&((_p)->y_u.cccc.next))); - break; - case _traced_get_5atoms : - _p = ((yamop *)(&((_p)->y_u.ccccc.next))); - break; - case _traced_get_6atoms : - _p = ((yamop *)(&((_p)->y_u.cccccc.next))); - break; - case _traced_get_list : - _p = ((yamop *)(&((_p)->y_u.x.next))); - break; - case _traced_get_struct : - _p = ((yamop *)(&((_p)->y_u.xfa.next))); - break; - case _traced_get_float : - _p = ((yamop *)(&((_p)->y_u.xd.next))); - break; - case _traced_get_longint : - _p = ((yamop *)(&((_p)->y_u.xi.next))); - break; - case _traced_get_bigint : - _p = ((yamop *)(&((_p)->y_u.xN.next))); - break; - case _traced_get_dbterm : - _p = ((yamop *)(&((_p)->y_u.xD.next))); - break; - case _traced_glist_valx : - _p = ((yamop *)(&((_p)->y_u.xx.next))); - break; - case _traced_glist_valy : - _p = ((yamop *)(&((_p)->y_u.yx.next))); - break; - case _traced_gl_void_varx : - _p = ((yamop *)(&((_p)->y_u.xx.next))); - break; - case _traced_gl_void_vary : - _p = ((yamop *)(&((_p)->y_u.yx.next))); - break; - case _traced_gl_void_valx : - _p = ((yamop *)(&((_p)->y_u.xx.next))); - break; - case _traced_gl_void_valy : - _p = ((yamop *)(&((_p)->y_u.yx.next))); - break; - case _traced_unify_x_var : - _p = ((yamop *)(&((_p)->y_u.ox.next))); - break; - case _traced_unify_x_var_write : - _p = ((yamop *)(&((_p)->y_u.ox.next))); - break; - case _traced_unify_l_x_var : - _p = ((yamop *)(&((_p)->y_u.ox.next))); - break; - case _traced_unify_l_x_var_write : - _p = ((yamop *)(&((_p)->y_u.ox.next))); - break; - case _traced_unify_x_var2 : - _p = ((yamop *)(&((_p)->y_u.oxx.next))); - break; - case _traced_unify_x_var2_write : - _p = ((yamop *)(&((_p)->y_u.oxx.next))); - break; - case _traced_unify_l_x_var2 : - _p = ((yamop *)(&((_p)->y_u.oxx.next))); - break; - case _traced_unify_l_x_var2_write : - _p = ((yamop *)(&((_p)->y_u.oxx.next))); - break; - case _traced_unify_y_var : - _p = ((yamop *)(&((_p)->y_u.oy.next))); - break; - case _traced_unify_y_var_write : - _p = ((yamop *)(&((_p)->y_u.oy.next))); - break; - case _traced_unify_l_y_var : - _p = ((yamop *)(&((_p)->y_u.oy.next))); - break; - case _traced_unify_l_y_var_write : - _p = ((yamop *)(&((_p)->y_u.oy.next))); - break; - case _traced_unify_x_val : - _p = ((yamop *)(&((_p)->y_u.ox.next))); - break; - case _traced_unify_x_val_write : - _p = ((yamop *)(&((_p)->y_u.ox.next))); - break; - case _traced_unify_l_x_val : - _p = ((yamop *)(&((_p)->y_u.ox.next))); - break; - case _traced_unify_l_x_val_write : - _p = ((yamop *)(&((_p)->y_u.ox.next))); - break; - case _traced_unify_y_val : - _p = ((yamop *)(&((_p)->y_u.oy.next))); - break; - case _traced_unify_y_val_write : - _p = ((yamop *)(&((_p)->y_u.oy.next))); - break; - case _traced_unify_l_y_val : - _p = ((yamop *)(&((_p)->y_u.oy.next))); - break; - case _traced_unify_l_y_val_write : - _p = ((yamop *)(&((_p)->y_u.oy.next))); - break; - case _traced_unify_x_loc : - _p = ((yamop *)(&((_p)->y_u.ox.next))); - break; - case _traced_unify_x_loc_write : - _p = ((yamop *)(&((_p)->y_u.ox.next))); - break; - case _traced_unify_l_x_loc : - _p = ((yamop *)(&((_p)->y_u.ox.next))); - break; - case _traced_unify_l_x_loc_write : - _p = ((yamop *)(&((_p)->y_u.ox.next))); - break; - case _traced_unify_y_loc : - _p = ((yamop *)(&((_p)->y_u.oy.next))); - break; - case _traced_unify_y_loc_write : - _p = ((yamop *)(&((_p)->y_u.oy.next))); - break; - case _traced_unify_l_y_loc : - _p = ((yamop *)(&((_p)->y_u.oy.next))); - break; - case _traced_unify_l_y_loc_write : - _p = ((yamop *)(&((_p)->y_u.oy.next))); - break; - case _traced_unify_void : - _p = ((yamop *)(&((_p)->y_u.o.next))); - break; - case _traced_unify_void_write : - _p = ((yamop *)(&((_p)->y_u.o.next))); - break; - case _traced_unify_l_void : - _p = ((yamop *)(&((_p)->y_u.o.next))); - break; - case _traced_unify_l_void_write : - _p = ((yamop *)(&((_p)->y_u.o.next))); - break; - case _traced_unify_n_voids : - _p = ((yamop *)(&((_p)->y_u.os.next))); - break; - case _traced_unify_n_voids_write : - _p = ((yamop *)(&((_p)->y_u.os.next))); - break; - case _traced_unify_l_n_voids : - _p = ((yamop *)(&((_p)->y_u.os.next))); - break; - case _traced_unify_l_n_voids_write : - _p = ((yamop *)(&((_p)->y_u.os.next))); - break; - case _traced_unify_atom : - _p = ((yamop *)(&((_p)->y_u.oc.next))); - break; - case _traced_unify_atom_write : - _p = ((yamop *)(&((_p)->y_u.oc.next))); - break; - case _traced_unify_l_atom : - _p = ((yamop *)(&((_p)->y_u.oc.next))); - break; - case _traced_unify_l_atom_write : - _p = ((yamop *)(&((_p)->y_u.oc.next))); - break; - case _traced_unify_n_atoms : - _p = ((yamop *)(&((_p)->y_u.osc.next))); - break; - case _traced_unify_n_atoms_write : - _p = ((yamop *)(&((_p)->y_u.osc.next))); - break; - case _traced_unify_float : - _p = ((yamop *)(&((_p)->y_u.od.next))); - break; - case _traced_unify_float_write : - _p = ((yamop *)(&((_p)->y_u.od.next))); - break; - case _traced_unify_l_float : - _p = ((yamop *)(&((_p)->y_u.od.next))); - break; - case _traced_unify_l_float_write : - _p = ((yamop *)(&((_p)->y_u.od.next))); - break; - case _traced_unify_longint : - _p = ((yamop *)(&((_p)->y_u.oi.next))); - break; - case _traced_unify_longint_write : - _p = ((yamop *)(&((_p)->y_u.oi.next))); - break; - case _traced_unify_l_longint : - _p = ((yamop *)(&((_p)->y_u.oi.next))); - break; - case _traced_unify_l_longint_write : - _p = ((yamop *)(&((_p)->y_u.oi.next))); - break; - case _traced_unify_bigint : - _p = ((yamop *)(&((_p)->y_u.oN.next))); - break; - case _traced_unify_l_bigint : - _p = ((yamop *)(&((_p)->y_u.oN.next))); - break; - case _traced_unify_dbterm : - _p = ((yamop *)(&((_p)->y_u.oD.next))); - break; - case _traced_unify_l_dbterm : - _p = ((yamop *)(&((_p)->y_u.oD.next))); - break; - case _traced_unify_list : - _p = ((yamop *)(&((_p)->y_u.o.next))); - break; - case _traced_unify_list_write : - _p = ((yamop *)(&((_p)->y_u.o.next))); - break; - case _traced_unify_l_list : - _p = ((yamop *)(&((_p)->y_u.o.next))); - break; - case _traced_unify_l_list_write : - _p = ((yamop *)(&((_p)->y_u.o.next))); - break; - case _traced_unify_struct : - _p = ((yamop *)(&((_p)->y_u.ofa.next))); - break; - case _traced_unify_struct_write : - _p = ((yamop *)(&((_p)->y_u.ofa.next))); - break; - case _traced_unify_l_struc : - _p = ((yamop *)(&((_p)->y_u.ofa.next))); - break; - case _traced_unify_l_struc_write : - _p = ((yamop *)(&((_p)->y_u.ofa.next))); - break; - case _traced_put_x_var : - _p = ((yamop *)(&((_p)->y_u.xx.next))); - break; - case _traced_put_y_var : - _p = ((yamop *)(&((_p)->y_u.yx.next))); - break; - case _traced_put_x_val : - _p = ((yamop *)(&((_p)->y_u.xx.next))); - break; - case _traced_put_xx_val : - _p = ((yamop *)(&((_p)->y_u.xxxx.next))); - break; - case _traced_put_y_val : - _p = ((yamop *)(&((_p)->y_u.yx.next))); - break; - case _traced_put_y_vals : - _p = ((yamop *)(&((_p)->y_u.yyxx.next))); - break; - case _traced_put_unsafe : - _p = ((yamop *)(&((_p)->y_u.yx.next))); - break; - case _traced_put_atom : - _p = ((yamop *)(&((_p)->y_u.xc.next))); - break; - case _traced_put_dbterm : - _p = ((yamop *)(&((_p)->y_u.xD.next))); - break; - case _traced_put_bigint : - _p = ((yamop *)(&((_p)->y_u.xN.next))); - break; - case _traced_put_float : - _p = ((yamop *)(&((_p)->y_u.xd.next))); - break; - case _traced_put_longint : - _p = ((yamop *)(&((_p)->y_u.xi.next))); - break; - case _traced_put_list : - _p = ((yamop *)(&((_p)->y_u.x.next))); - break; - case _traced_put_struct : - _p = ((yamop *)(&((_p)->y_u.xfa.next))); - break; - case _traced_write_x_var : - _p = ((yamop *)(&((_p)->y_u.x.next))); - break; - case _traced_write_void : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_write_n_voids : - _p = ((yamop *)(&((_p)->y_u.s.next))); - break; - case _traced_write_y_var : - _p = ((yamop *)(&((_p)->y_u.y.next))); - break; - case _traced_write_x_val : - _p = ((yamop *)(&((_p)->y_u.x.next))); - break; - case _traced_write_x_loc : - _p = ((yamop *)(&((_p)->y_u.x.next))); - break; - case _traced_write_y_val : - _p = ((yamop *)(&((_p)->y_u.y.next))); - break; - case _traced_write_y_loc : - _p = ((yamop *)(&((_p)->y_u.y.next))); - break; - case _traced_write_atom : - _p = ((yamop *)(&((_p)->y_u.c.next))); - break; - case _traced_write_bigint : - _p = ((yamop *)(&((_p)->y_u.N.next))); - break; - case _traced_write_dbterm : - _p = ((yamop *)(&((_p)->y_u.D.next))); - break; - case _traced_write_float : - _p = ((yamop *)(&((_p)->y_u.d.next))); - break; - case _traced_write_longint : - _p = ((yamop *)(&((_p)->y_u.i.next))); - break; - case _traced_write_n_atoms : - _p = ((yamop *)(&((_p)->y_u.sc.next))); - break; - case _traced_write_list : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_write_l_list : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_write_struct : - _p = ((yamop *)(&((_p)->y_u.fa.next))); - break; - case _traced_write_l_struc : - _p = ((yamop *)(&((_p)->y_u.fa.next))); - break; - case _traced_save_pair_x : - _p = ((yamop *)(&((_p)->y_u.ox.next))); - break; - case _traced_save_pair_x_write : - _p = ((yamop *)(&((_p)->y_u.ox.next))); - break; - case _traced_save_pair_y : - _p = ((yamop *)(&((_p)->y_u.oy.next))); - break; - case _traced_save_pair_y_write : - _p = ((yamop *)(&((_p)->y_u.oy.next))); - break; - case _traced_save_appl_x : - _p = ((yamop *)(&((_p)->y_u.ox.next))); - break; - case _traced_save_appl_x_write : - _p = ((yamop *)(&((_p)->y_u.ox.next))); - break; - case _traced_save_appl_y : - _p = ((yamop *)(&((_p)->y_u.oy.next))); - break; - case _traced_save_appl_y_write : - _p = ((yamop *)(&((_p)->y_u.oy.next))); - break; - case _traced_jump : - _p = ((yamop *)(&((_p)->y_u.l.next))); - break; - case _traced_move_back : - _p = ((yamop *)(&((_p)->y_u.l.next))); - break; - case _traced_skip : - _p = ((yamop *)(&((_p)->y_u.l.next))); - break; - case _traced_either : - _p = ((yamop *)(&((_p)->y_u.Osblp.next))); - break; - case _traced_or_else : - _p = ((yamop *)(&((_p)->y_u.Osblp.next))); - break; - case _traced_pop_n : - _p = ((yamop *)(&((_p)->y_u.s.next))); - break; - case _traced_pop : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_call_cpred : - _p = ((yamop *)(&((_p)->y_u.Osbpp.next))); - break; - case _traced_execute_cpred : - _p = ((yamop *)(&((_p)->y_u.pp.next))); - break; - case _traced_call_usercpred : - _p = ((yamop *)(&((_p)->y_u.Osbpp.next))); - break; - case _traced_call_c_wfail : - _p = ((yamop *)(&((_p)->y_u.slp.next))); - break; - case _traced_try_c : - _p = ((yamop *)(&((_p)->y_u.OtapFs.next))); - break; - case _traced_retry_c : - _p = ((yamop *)(&((_p)->y_u.OtapFs.next))); - break; -#ifdef CUT_C - case _traced_cut_c : - _p = ((yamop *)(&((_p)->y_u.OtapFs.next))); - break; -#endif - case _traced_try_userc : - _p = ((yamop *)(&((_p)->y_u.OtapFs.next))); - break; - case _traced_retry_userc : - _p = ((yamop *)(&((_p)->y_u.OtapFs.next))); - break; -#ifdef CUT_C - case _traced_cut_userc : - _p = ((yamop *)(&((_p)->y_u.OtapFs.next))); - break; -#endif - case _traced_lock_pred : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_index_pred : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; -#ifdef THREADS - case _traced_thread_local : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; -#endif - case _traced_expand_index : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_expand_clauses : - _p = ((yamop *)(&((_p)->y_u.sssllp.next))); - break; - case _traced_undef_p : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_spy_pred : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_try_clause : - _p = ((yamop *)(&((_p)->y_u.Otapl.next))); - break; - case _traced_try_clause2 : - _p = ((yamop *)(&((_p)->y_u.l.next))); - break; - case _traced_try_clause3 : - _p = ((yamop *)(&((_p)->y_u.l.next))); - break; - case _traced_try_clause4 : - _p = ((yamop *)(&((_p)->y_u.l.next))); - break; - case _traced_retry : - _p = ((yamop *)(&((_p)->y_u.Otapl.next))); - break; - case _traced_retry2 : - _p = ((yamop *)(&((_p)->y_u.l.next))); - break; - case _traced_retry3 : - _p = ((yamop *)(&((_p)->y_u.l.next))); - break; - case _traced_retry4 : - _p = ((yamop *)(&((_p)->y_u.l.next))); - break; - case _traced_trust : - _p = ((yamop *)(&((_p)->y_u.Otapl.next))); - break; - case _traced_try_in : - _p = ((yamop *)(&((_p)->y_u.l.next))); - break; - case _traced_enter_lu_pred : - _p = ((yamop *)(&((_p)->y_u.Illss.next))); - break; - case _traced_try_logical : - _p = ((yamop *)(&((_p)->y_u.OtaLl.next))); - break; - case _traced_retry_logical : - _p = ((yamop *)(&((_p)->y_u.OtaLl.next))); - break; - case _traced_trust_logical : - _p = ((yamop *)(&((_p)->y_u.OtILl.next))); - break; - case _traced_user_switch : - _p = ((yamop *)(&((_p)->y_u.lp.next))); - break; - case _traced_switch_on_type : - _p = ((yamop *)(&((_p)->y_u.llll.next))); - break; - case _traced_switch_list_nl : - _p = ((yamop *)(&((_p)->y_u.ollll.next))); - break; - case _traced_switch_on_arg_type : - _p = ((yamop *)(&((_p)->y_u.xllll.next))); - break; - case _traced_switch_on_sub_arg_type : - _p = ((yamop *)(&((_p)->y_u.sllll.next))); - break; - case _traced_jump_if_var : - _p = ((yamop *)(&((_p)->y_u.l.next))); - break; - case _traced_jump_if_nonvar : - _p = ((yamop *)(&((_p)->y_u.xll.next))); - break; - case _traced_if_not_then : - _p = ((yamop *)(&((_p)->y_u.clll.next))); - break; - case _traced_switch_on_func : - _p = ((yamop *)(&((_p)->y_u.sssl.next))); - break; - case _traced_switch_on_cons : - _p = ((yamop *)(&((_p)->y_u.sssl.next))); - break; - case _traced_go_on_func : - _p = ((yamop *)(&((_p)->y_u.sssl.next))); - break; - case _traced_go_on_cons : - _p = ((yamop *)(&((_p)->y_u.sssl.next))); - break; - case _traced_if_func : - _p = ((yamop *)(&((_p)->y_u.sssl.next))); - break; - case _traced_if_cons : - _p = ((yamop *)(&((_p)->y_u.sssl.next))); - break; - case _traced_index_dbref : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_index_blob : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_index_long : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_jit_handler : - _p = ((yamop *)(&((_p)->y_u.J.next))); - break; - case _traced_p_atom_x : - _p = ((yamop *)(&((_p)->y_u.xl.next))); - break; - case _traced_p_atom_y : - _p = ((yamop *)(&((_p)->y_u.yl.next))); - break; - case _traced_p_atomic_x : - _p = ((yamop *)(&((_p)->y_u.xl.next))); - break; - case _traced_p_atomic_y : - _p = ((yamop *)(&((_p)->y_u.yl.next))); - break; - case _traced_p_integer_x : - _p = ((yamop *)(&((_p)->y_u.xl.next))); - break; - case _traced_p_integer_y : - _p = ((yamop *)(&((_p)->y_u.yl.next))); - break; - case _traced_p_nonvar_x : - _p = ((yamop *)(&((_p)->y_u.xl.next))); - break; - case _traced_p_nonvar_y : - _p = ((yamop *)(&((_p)->y_u.yl.next))); - break; - case _traced_p_number_x : - _p = ((yamop *)(&((_p)->y_u.xl.next))); - break; - case _traced_p_number_y : - _p = ((yamop *)(&((_p)->y_u.yl.next))); - break; - case _traced_p_var_x : - _p = ((yamop *)(&((_p)->y_u.xl.next))); - break; - case _traced_p_var_y : - _p = ((yamop *)(&((_p)->y_u.yl.next))); - break; - case _traced_p_db_ref_x : - _p = ((yamop *)(&((_p)->y_u.xl.next))); - break; - case _traced_p_db_ref_y : - _p = ((yamop *)(&((_p)->y_u.yl.next))); - break; - case _traced_p_primitive_x : - _p = ((yamop *)(&((_p)->y_u.xl.next))); - break; - case _traced_p_primitive_y : - _p = ((yamop *)(&((_p)->y_u.yl.next))); - break; - case _traced_p_compound_x : - _p = ((yamop *)(&((_p)->y_u.xl.next))); - break; - case _traced_p_compound_y : - _p = ((yamop *)(&((_p)->y_u.yl.next))); - break; - case _traced_p_float_x : - _p = ((yamop *)(&((_p)->y_u.xl.next))); - break; - case _traced_p_float_y : - _p = ((yamop *)(&((_p)->y_u.yl.next))); - break; - case _traced_p_plus_vv : - _p = ((yamop *)(&((_p)->y_u.xxx.next))); - break; - case _traced_p_plus_vc : - _p = ((yamop *)(&((_p)->y_u.xxn.next))); - break; - case _traced_p_plus_y_vv : - _p = ((yamop *)(&((_p)->y_u.yxx.next))); - break; - case _traced_p_plus_y_vc : - _p = ((yamop *)(&((_p)->y_u.yxn.next))); - break; - case _traced_p_minus_vv : - _p = ((yamop *)(&((_p)->y_u.xxx.next))); - break; - case _traced_p_minus_cv : - _p = ((yamop *)(&((_p)->y_u.xxn.next))); - break; - case _traced_p_minus_y_vv : - _p = ((yamop *)(&((_p)->y_u.yxx.next))); - break; - case _traced_p_minus_y_cv : - _p = ((yamop *)(&((_p)->y_u.yxn.next))); - break; - case _traced_p_times_vv : - _p = ((yamop *)(&((_p)->y_u.xxx.next))); - break; - case _traced_p_times_vc : - _p = ((yamop *)(&((_p)->y_u.xxn.next))); - break; - case _traced_p_times_y_vv : - _p = ((yamop *)(&((_p)->y_u.yxx.next))); - break; - case _traced_p_times_y_vc : - _p = ((yamop *)(&((_p)->y_u.yxn.next))); - break; - case _traced_p_div_vv : - _p = ((yamop *)(&((_p)->y_u.xxx.next))); - break; - case _traced_p_div_vc : - _p = ((yamop *)(&((_p)->y_u.xxn.next))); - break; - case _traced_p_div_cv : - _p = ((yamop *)(&((_p)->y_u.xxn.next))); - break; - case _traced_p_div_y_vv : - _p = ((yamop *)(&((_p)->y_u.yxx.next))); - break; - case _traced_p_div_y_vc : - _p = ((yamop *)(&((_p)->y_u.yxn.next))); - break; - case _traced_p_div_y_cv : - _p = ((yamop *)(&((_p)->y_u.yxn.next))); - break; - case _traced_p_and_vv : - _p = ((yamop *)(&((_p)->y_u.xxx.next))); - break; - case _traced_p_and_vc : - _p = ((yamop *)(&((_p)->y_u.xxn.next))); - break; - case _traced_p_and_y_vv : - _p = ((yamop *)(&((_p)->y_u.yxx.next))); - break; - case _traced_p_and_y_vc : - _p = ((yamop *)(&((_p)->y_u.yxn.next))); - break; - case _traced_p_or_vv : - _p = ((yamop *)(&((_p)->y_u.xxx.next))); - break; - case _traced_p_or_vc : - _p = ((yamop *)(&((_p)->y_u.xxn.next))); - break; - case _traced_p_or_y_vv : - _p = ((yamop *)(&((_p)->y_u.yxx.next))); - break; - case _traced_p_or_y_vc : - _p = ((yamop *)(&((_p)->y_u.yxn.next))); - break; - case _traced_p_sll_vv : - _p = ((yamop *)(&((_p)->y_u.xxx.next))); - break; - case _traced_p_sll_vc : - _p = ((yamop *)(&((_p)->y_u.xxn.next))); - break; - case _traced_p_sll_cv : - _p = ((yamop *)(&((_p)->y_u.xxn.next))); - break; - case _traced_p_sll_y_vv : - _p = ((yamop *)(&((_p)->y_u.yxx.next))); - break; - case _traced_p_sll_y_vc : - _p = ((yamop *)(&((_p)->y_u.yxn.next))); - break; - case _traced_p_sll_y_cv : - _p = ((yamop *)(&((_p)->y_u.yxn.next))); - break; - case _traced_p_slr_vv : - _p = ((yamop *)(&((_p)->y_u.xxx.next))); - break; - case _traced_p_slr_vc : - _p = ((yamop *)(&((_p)->y_u.xxn.next))); - break; - case _traced_p_slr_cv : - _p = ((yamop *)(&((_p)->y_u.xxn.next))); - break; - case _traced_p_slr_y_vv : - _p = ((yamop *)(&((_p)->y_u.yxx.next))); - break; - case _traced_p_slr_y_vc : - _p = ((yamop *)(&((_p)->y_u.yxn.next))); - break; - case _traced_p_slr_y_cv : - _p = ((yamop *)(&((_p)->y_u.yxn.next))); - break; - case _traced_call_bfunc_xx : - _p = ((yamop *)(&((_p)->y_u.plxxs.next))); - break; - case _traced_call_bfunc_yx : - _p = ((yamop *)(&((_p)->y_u.plxys.next))); - break; - case _traced_call_bfunc_xy : - _p = ((yamop *)(&((_p)->y_u.plxys.next))); - break; - case _traced_call_bfunc_yy : - _p = ((yamop *)(&((_p)->y_u.plyys.next))); - break; - case _traced_p_equal : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_p_dif : - _p = ((yamop *)(&((_p)->y_u.l.next))); - break; - case _traced_p_eq : - _p = ((yamop *)(&((_p)->y_u.l.next))); - break; - case _traced_p_arg_vv : - _p = ((yamop *)(&((_p)->y_u.xxx.next))); - break; - case _traced_p_arg_cv : - _p = ((yamop *)(&((_p)->y_u.xxn.next))); - break; - case _traced_p_arg_y_vv : - _p = ((yamop *)(&((_p)->y_u.yxx.next))); - break; - case _traced_p_arg_y_cv : - _p = ((yamop *)(&((_p)->y_u.yxn.next))); - break; - case _traced_p_func2s_vv : - _p = ((yamop *)(&((_p)->y_u.xxx.next))); - break; - case _traced_p_func2s_cv : - _p = ((yamop *)(&((_p)->y_u.xxc.next))); - break; - case _traced_p_func2s_vc : - _p = ((yamop *)(&((_p)->y_u.xxn.next))); - break; - case _traced_p_func2s_y_vv : - _p = ((yamop *)(&((_p)->y_u.yxx.next))); - break; - case _traced_p_func2s_y_cv : - _p = ((yamop *)(&((_p)->y_u.yxn.next))); - break; - case _traced_p_func2s_y_vc : - _p = ((yamop *)(&((_p)->y_u.yxn.next))); - break; - case _traced_p_func2f_xx : - _p = ((yamop *)(&((_p)->y_u.xxx.next))); - break; - case _traced_p_func2f_xy : - _p = ((yamop *)(&((_p)->y_u.xxy.next))); - break; - case _traced_p_func2f_yx : - _p = ((yamop *)(&((_p)->y_u.yxx.next))); - break; - case _traced_p_func2f_yy : - _p = ((yamop *)(&((_p)->y_u.yyx.next))); - break; - case _traced_p_functor : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_p_execute2 : - _p = ((yamop *)(&((_p)->y_u.Osbpp.next))); - break; - case _traced_p_execute : - _p = ((yamop *)(&((_p)->y_u.Osbmp.next))); - break; - case _traced_p_execute_tail : - _p = ((yamop *)(&((_p)->y_u.Osbpp.next))); - break; -#ifdef YAPOR - case _traced_getwork_first_time : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_getwork : - _p = ((yamop *)(&((_p)->y_u.Otapl.next))); - break; - case _traced_getwork_seq : - _p = ((yamop *)(&((_p)->y_u.Otapl.next))); - break; - case _traced_sync : - _p = ((yamop *)(&((_p)->y_u.Otapl.next))); - break; -#endif -#ifdef TABLING -#ifdef TABLING_INNER_CUTS - case _traced_clause_with_cut : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; -#endif - case _traced_table_load_answer : - _p = ((yamop *)(&((_p)->y_u.Otapl.next))); - break; - case _traced_table_try_answer : - _p = ((yamop *)(&((_p)->y_u.Otapl.next))); - break; - case _traced_table_try_single : - _p = ((yamop *)(&((_p)->y_u.Otapl.next))); - break; - case _traced_table_try_me : - _p = ((yamop *)(&((_p)->y_u.Otapl.next))); - break; - case _traced_table_try : - _p = ((yamop *)(&((_p)->y_u.Otapl.next))); - break; - case _traced_table_retry_me : - _p = ((yamop *)(&((_p)->y_u.Otapl.next))); - break; - case _traced_table_retry : - _p = ((yamop *)(&((_p)->y_u.Otapl.next))); - break; - case _traced_table_trust_me : - _p = ((yamop *)(&((_p)->y_u.Otapl.next))); - break; - case _traced_table_trust : - _p = ((yamop *)(&((_p)->y_u.Otapl.next))); - break; - case _traced_table_new_answer : - _p = ((yamop *)(&((_p)->y_u.s.next))); - break; - case _traced_table_answer_resolution : - _p = ((yamop *)(&((_p)->y_u.Otapl.next))); - break; - case _traced_table_completion : - _p = ((yamop *)(&((_p)->y_u.Otapl.next))); - break; -#ifdef THREADS_CONSUMER_SHARING - case _traced_table_answer_resolution_completion: - _p = ((yamop *)(&((_p)->y_u.Otapl.next))); - break; -#endif - case _traced_trie_do_var : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_trie_trust_var : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_trie_try_var : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_trie_retry_var : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_trie_do_var_in_pair : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_trie_trust_var_in_pair : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_trie_try_var_in_pair : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_trie_retry_var_in_pair : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_trie_do_val : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_trie_trust_val : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_trie_try_val : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_trie_retry_val : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_trie_do_val_in_pair : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_trie_trust_val_in_pair : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_trie_try_val_in_pair : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_trie_retry_val_in_pair : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_trie_do_atom : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_trie_trust_atom : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_trie_try_atom : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_trie_retry_atom : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_trie_do_atom_in_pair : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_trie_trust_atom_in_pair : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_trie_try_atom_in_pair : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_trie_retry_atom_in_pair : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_trie_do_null : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_trie_trust_null : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_trie_try_null : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_trie_retry_null : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_trie_do_null_in_pair : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_trie_trust_null_in_pair : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_trie_try_null_in_pair : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_trie_retry_null_in_pair : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_trie_do_pair : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_trie_trust_pair : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_trie_try_pair : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_trie_retry_pair : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_trie_do_appl : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_trie_trust_appl : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_trie_try_appl : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_trie_retry_appl : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_trie_do_appl_in_pair : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_trie_trust_appl_in_pair : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_trie_try_appl_in_pair : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_trie_retry_appl_in_pair : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_trie_do_extension : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_trie_trust_extension : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_trie_try_extension : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_trie_retry_extension : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_trie_do_double : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_trie_trust_double : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_trie_try_double : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_trie_retry_double : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_trie_do_longint : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_trie_trust_longint : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_trie_try_longint : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_trie_retry_longint : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_trie_do_gterm : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_trie_trust_gterm : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_trie_try_gterm : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; - case _traced_trie_retry_gterm : - _p = ((yamop *)(&((_p)->y_u.e.next))); - break; -#endif -#ifdef YAPOR - case _traced_or_last : - _p = ((yamop *)(&((_p)->y_u.sblp.next))); - break; -#else - case _traced_or_last : - _p = ((yamop *)(&((_p)->y_u.p.next))); - break; -#endif - default: + default: printf("Bad argument in lastop\n"); return NULL; } diff --git a/JIT/HPP/nextof.hpp b/JIT/HPP/nextof.hpp index 9e9ac3955..0b8b777ca 100644 --- a/JIT/HPP/nextof.hpp +++ b/JIT/HPP/nextof.hpp @@ -1192,1198 +1192,7 @@ NextOf(yamop** _p) { (*_p) = ((yamop *)(&((*_p)->y_u.p.next))); break; #endif - case _traced_Ystop : - (*_p) = ((yamop *)(&((*_p)->y_u.l.next))); - break; - case _traced_Nstop : - (*_p) = ((yamop *)(&((*_p)->y_u.e.next))); - break; - case _traced_try_me : - (*_p) = ((yamop *)(&((*_p)->y_u.Otapl.next))); - break; - case _traced_retry_me : - (*_p) = ((yamop *)(&((*_p)->y_u.Otapl.next))); - break; - case _traced_trust_me : - (*_p) = ((yamop *)(&((*_p)->y_u.Otapl.next))); - break; - case _traced_enter_profiling : - (*_p) = ((yamop *)(&((*_p)->y_u.p.next))); - break; - case _traced_retry_profiled : - (*_p) = ((yamop *)(&((*_p)->y_u.p.next))); - break; - case _traced_profiled_retry_me : - (*_p) = ((yamop *)(&((*_p)->y_u.Otapl.next))); - break; - case _traced_profiled_trust_me : - (*_p) = ((yamop *)(&((*_p)->y_u.Otapl.next))); - break; - case _traced_profiled_retry_logical : - (*_p) = ((yamop *)(&((*_p)->y_u.OtaLl.next))); - break; - case _traced_profiled_trust_logical : - (*_p) = ((yamop *)(&((*_p)->y_u.OtILl.next))); - break; - case _traced_count_call : - (*_p) = ((yamop *)(&((*_p)->y_u.p.next))); - break; - case _traced_count_retry : - (*_p) = ((yamop *)(&((*_p)->y_u.p.next))); - break; - case _traced_count_retry_me : - (*_p) = ((yamop *)(&((*_p)->y_u.Otapl.next))); - break; - case _traced_count_trust_me : - (*_p) = ((yamop *)(&((*_p)->y_u.Otapl.next))); - break; - case _traced_count_retry_logical : - (*_p) = ((yamop *)(&((*_p)->y_u.OtaLl.next))); - break; - case _traced_count_trust_logical : - (*_p) = ((yamop *)(&((*_p)->y_u.OtILl.next))); - break; - case _traced_lock_lu : - (*_p) = ((yamop *)(&((*_p)->y_u.p.next))); - break; - case _traced_unlock_lu : - (*_p) = ((yamop *)(&((*_p)->y_u.e.next))); - break; - case _traced_alloc_for_logical_pred : - (*_p) = ((yamop *)(&((*_p)->y_u.L.next))); - break; - case _traced_copy_idb_term : - (*_p) = ((yamop *)(&((*_p)->y_u.e.next))); - break; - case _traced_unify_idb_term : - (*_p) = ((yamop *)(&((*_p)->y_u.e.next))); - break; - case _traced_ensure_space : - (*_p) = ((yamop *)(&((*_p)->y_u.Osbpa.next))); - break; - case _traced_spy_or_trymark : - (*_p) = ((yamop *)(&((*_p)->y_u.Otapl.next))); - break; - case _traced_try_and_mark : - (*_p) = ((yamop *)(&((*_p)->y_u.Otapl.next))); - break; - case _traced_count_retry_and_mark : - (*_p) = ((yamop *)(&((*_p)->y_u.Otapl.next))); - break; - case _traced_profiled_retry_and_mark : - (*_p) = ((yamop *)(&((*_p)->y_u.Otapl.next))); - break; - case _traced_retry_and_mark : - (*_p) = ((yamop *)(&((*_p)->y_u.Otapl.next))); - break; - case _traced_trust_fail : - (*_p) = ((yamop *)(&((*_p)->y_u.e.next))); - break; - case _traced_op_fail : - (*_p) = ((yamop *)(&((*_p)->y_u.e.next))); - break; - case _traced_cut : - (*_p) = ((yamop *)(&((*_p)->y_u.s.next))); - break; - case _traced_cut_t : - (*_p) = ((yamop *)(&((*_p)->y_u.s.next))); - break; - case _traced_cut_e : - (*_p) = ((yamop *)(&((*_p)->y_u.s.next))); - break; - case _traced_save_b_x : - (*_p) = ((yamop *)(&((*_p)->y_u.x.next))); - break; - case _traced_save_b_y : - (*_p) = ((yamop *)(&((*_p)->y_u.y.next))); - break; - case _traced_commit_b_x : - (*_p) = ((yamop *)(&((*_p)->y_u.xps.next))); - break; - case _traced_commit_b_y : - (*_p) = ((yamop *)(&((*_p)->y_u.yps.next))); - break; - case _traced_execute : - (*_p) = ((yamop *)(&((*_p)->y_u.pp.next))); - break; - case _traced_dexecute : - (*_p) = ((yamop *)(&((*_p)->y_u.pp.next))); - break; - case _traced_fcall : - (*_p) = ((yamop *)(&((*_p)->y_u.Osbpp.next))); - break; - case _traced_call : - (*_p) = ((yamop *)(&((*_p)->y_u.Osbpp.next))); - break; - case _traced_procceed : - (*_p) = ((yamop *)(&((*_p)->y_u.p.next))); - break; - case _traced_allocate : - (*_p) = ((yamop *)(&((*_p)->y_u.e.next))); - break; - case _traced_deallocate : - (*_p) = ((yamop *)(&((*_p)->y_u.p.next))); - break; -#ifdef BEAM - case _traced_retry_eam : - (*_p) = ((yamop *)(&((*_p)->y_u.e.next))); - break; -#endif -#ifdef BEAM - case _traced_run_eam : - (*_p) = ((yamop *)(&((*_p)->y_u.os.next))); - break; -#endif - case _traced_get_x_var : - (*_p) = ((yamop *)(&((*_p)->y_u.xx.next))); - break; - case _traced_get_y_var : - (*_p) = ((yamop *)(&((*_p)->y_u.yx.next))); - break; - case _traced_get_yy_var : - (*_p) = ((yamop *)(&((*_p)->y_u.yyxx.next))); - break; - case _traced_get_x_val : - (*_p) = ((yamop *)(&((*_p)->y_u.xx.next))); - break; - case _traced_get_y_val : - (*_p) = ((yamop *)(&((*_p)->y_u.yx.next))); - break; - case _traced_get_atom : - (*_p) = ((yamop *)(&((*_p)->y_u.xc.next))); - break; - case _traced_get_2atoms : - (*_p) = ((yamop *)(&((*_p)->y_u.cc.next))); - break; - case _traced_get_3atoms : - (*_p) = ((yamop *)(&((*_p)->y_u.ccc.next))); - break; - case _traced_get_4atoms : - (*_p) = ((yamop *)(&((*_p)->y_u.cccc.next))); - break; - case _traced_get_5atoms : - (*_p) = ((yamop *)(&((*_p)->y_u.ccccc.next))); - break; - case _traced_get_6atoms : - (*_p) = ((yamop *)(&((*_p)->y_u.cccccc.next))); - break; - case _traced_get_list : - (*_p) = ((yamop *)(&((*_p)->y_u.x.next))); - break; - case _traced_get_struct : - (*_p) = ((yamop *)(&((*_p)->y_u.xfa.next))); - break; - case _traced_get_float : - (*_p) = ((yamop *)(&((*_p)->y_u.xd.next))); - break; - case _traced_get_longint : - (*_p) = ((yamop *)(&((*_p)->y_u.xi.next))); - break; - case _traced_get_bigint : - (*_p) = ((yamop *)(&((*_p)->y_u.xN.next))); - break; - case _traced_get_dbterm : - (*_p) = ((yamop *)(&((*_p)->y_u.xD.next))); - break; - case _traced_glist_valx : - (*_p) = ((yamop *)(&((*_p)->y_u.xx.next))); - break; - case _traced_glist_valy : - (*_p) = ((yamop *)(&((*_p)->y_u.yx.next))); - break; - case _traced_gl_void_varx : - (*_p) = ((yamop *)(&((*_p)->y_u.xx.next))); - break; - case _traced_gl_void_vary : - (*_p) = ((yamop *)(&((*_p)->y_u.yx.next))); - break; - case _traced_gl_void_valx : - (*_p) = ((yamop *)(&((*_p)->y_u.xx.next))); - break; - case _traced_gl_void_valy : - (*_p) = ((yamop *)(&((*_p)->y_u.yx.next))); - break; - case _traced_unify_x_var : - (*_p) = ((yamop *)(&((*_p)->y_u.ox.next))); - break; - case _traced_unify_x_var_write : - (*_p) = ((yamop *)(&((*_p)->y_u.ox.next))); - break; - case _traced_unify_l_x_var : - (*_p) = ((yamop *)(&((*_p)->y_u.ox.next))); - break; - case _traced_unify_l_x_var_write : - (*_p) = ((yamop *)(&((*_p)->y_u.ox.next))); - break; - case _traced_unify_x_var2 : - (*_p) = ((yamop *)(&((*_p)->y_u.oxx.next))); - break; - case _traced_unify_x_var2_write : - (*_p) = ((yamop *)(&((*_p)->y_u.oxx.next))); - break; - case _traced_unify_l_x_var2 : - (*_p) = ((yamop *)(&((*_p)->y_u.oxx.next))); - break; - case _traced_unify_l_x_var2_write : - (*_p) = ((yamop *)(&((*_p)->y_u.oxx.next))); - break; - case _traced_unify_y_var : - (*_p) = ((yamop *)(&((*_p)->y_u.oy.next))); - break; - case _traced_unify_y_var_write : - (*_p) = ((yamop *)(&((*_p)->y_u.oy.next))); - break; - case _traced_unify_l_y_var : - (*_p) = ((yamop *)(&((*_p)->y_u.oy.next))); - break; - case _traced_unify_l_y_var_write : - (*_p) = ((yamop *)(&((*_p)->y_u.oy.next))); - break; - case _traced_unify_x_val : - (*_p) = ((yamop *)(&((*_p)->y_u.ox.next))); - break; - case _traced_unify_x_val_write : - (*_p) = ((yamop *)(&((*_p)->y_u.ox.next))); - break; - case _traced_unify_l_x_val : - (*_p) = ((yamop *)(&((*_p)->y_u.ox.next))); - break; - case _traced_unify_l_x_val_write : - (*_p) = ((yamop *)(&((*_p)->y_u.ox.next))); - break; - case _traced_unify_y_val : - (*_p) = ((yamop *)(&((*_p)->y_u.oy.next))); - break; - case _traced_unify_y_val_write : - (*_p) = ((yamop *)(&((*_p)->y_u.oy.next))); - break; - case _traced_unify_l_y_val : - (*_p) = ((yamop *)(&((*_p)->y_u.oy.next))); - break; - case _traced_unify_l_y_val_write : - (*_p) = ((yamop *)(&((*_p)->y_u.oy.next))); - break; - case _traced_unify_x_loc : - (*_p) = ((yamop *)(&((*_p)->y_u.ox.next))); - break; - case _traced_unify_x_loc_write : - (*_p) = ((yamop *)(&((*_p)->y_u.ox.next))); - break; - case _traced_unify_l_x_loc : - (*_p) = ((yamop *)(&((*_p)->y_u.ox.next))); - break; - case _traced_unify_l_x_loc_write : - (*_p) = ((yamop *)(&((*_p)->y_u.ox.next))); - break; - case _traced_unify_y_loc : - (*_p) = ((yamop *)(&((*_p)->y_u.oy.next))); - break; - case _traced_unify_y_loc_write : - (*_p) = ((yamop *)(&((*_p)->y_u.oy.next))); - break; - case _traced_unify_l_y_loc : - (*_p) = ((yamop *)(&((*_p)->y_u.oy.next))); - break; - case _traced_unify_l_y_loc_write : - (*_p) = ((yamop *)(&((*_p)->y_u.oy.next))); - break; - case _traced_unify_void : - (*_p) = ((yamop *)(&((*_p)->y_u.o.next))); - break; - case _traced_unify_void_write : - (*_p) = ((yamop *)(&((*_p)->y_u.o.next))); - break; - case _traced_unify_l_void : - (*_p) = ((yamop *)(&((*_p)->y_u.o.next))); - break; - case _traced_unify_l_void_write : - (*_p) = ((yamop *)(&((*_p)->y_u.o.next))); - break; - case _traced_unify_n_voids : - (*_p) = ((yamop *)(&((*_p)->y_u.os.next))); - break; - case _traced_unify_n_voids_write : - (*_p) = ((yamop *)(&((*_p)->y_u.os.next))); - break; - case _traced_unify_l_n_voids : - (*_p) = ((yamop *)(&((*_p)->y_u.os.next))); - break; - case _traced_unify_l_n_voids_write : - (*_p) = ((yamop *)(&((*_p)->y_u.os.next))); - break; - case _traced_unify_atom : - (*_p) = ((yamop *)(&((*_p)->y_u.oc.next))); - break; - case _traced_unify_atom_write : - (*_p) = ((yamop *)(&((*_p)->y_u.oc.next))); - break; - case _traced_unify_l_atom : - (*_p) = ((yamop *)(&((*_p)->y_u.oc.next))); - break; - case _traced_unify_l_atom_write : - (*_p) = ((yamop *)(&((*_p)->y_u.oc.next))); - break; - case _traced_unify_n_atoms : - (*_p) = ((yamop *)(&((*_p)->y_u.osc.next))); - break; - case _traced_unify_n_atoms_write : - (*_p) = ((yamop *)(&((*_p)->y_u.osc.next))); - break; - case _traced_unify_float : - (*_p) = ((yamop *)(&((*_p)->y_u.od.next))); - break; - case _traced_unify_float_write : - (*_p) = ((yamop *)(&((*_p)->y_u.od.next))); - break; - case _traced_unify_l_float : - (*_p) = ((yamop *)(&((*_p)->y_u.od.next))); - break; - case _traced_unify_l_float_write : - (*_p) = ((yamop *)(&((*_p)->y_u.od.next))); - break; - case _traced_unify_longint : - (*_p) = ((yamop *)(&((*_p)->y_u.oi.next))); - break; - case _traced_unify_longint_write : - (*_p) = ((yamop *)(&((*_p)->y_u.oi.next))); - break; - case _traced_unify_l_longint : - (*_p) = ((yamop *)(&((*_p)->y_u.oi.next))); - break; - case _traced_unify_l_longint_write : - (*_p) = ((yamop *)(&((*_p)->y_u.oi.next))); - break; - case _traced_unify_bigint : - (*_p) = ((yamop *)(&((*_p)->y_u.oN.next))); - break; - case _traced_unify_l_bigint : - (*_p) = ((yamop *)(&((*_p)->y_u.oN.next))); - break; - case _traced_unify_dbterm : - (*_p) = ((yamop *)(&((*_p)->y_u.oD.next))); - break; - case _traced_unify_l_dbterm : - (*_p) = ((yamop *)(&((*_p)->y_u.oD.next))); - break; - case _traced_unify_list : - (*_p) = ((yamop *)(&((*_p)->y_u.o.next))); - break; - case _traced_unify_list_write : - (*_p) = ((yamop *)(&((*_p)->y_u.o.next))); - break; - case _traced_unify_l_list : - (*_p) = ((yamop *)(&((*_p)->y_u.o.next))); - break; - case _traced_unify_l_list_write : - (*_p) = ((yamop *)(&((*_p)->y_u.o.next))); - break; - case _traced_unify_struct : - (*_p) = ((yamop *)(&((*_p)->y_u.ofa.next))); - break; - case _traced_unify_struct_write : - (*_p) = ((yamop *)(&((*_p)->y_u.ofa.next))); - break; - case _traced_unify_l_struc : - (*_p) = ((yamop *)(&((*_p)->y_u.ofa.next))); - break; - case _traced_unify_l_struc_write : - (*_p) = ((yamop *)(&((*_p)->y_u.ofa.next))); - break; - case _traced_put_x_var : - (*_p) = ((yamop *)(&((*_p)->y_u.xx.next))); - break; - case _traced_put_y_var : - (*_p) = ((yamop *)(&((*_p)->y_u.yx.next))); - break; - case _traced_put_x_val : - (*_p) = ((yamop *)(&((*_p)->y_u.xx.next))); - break; - case _traced_put_xx_val : - (*_p) = ((yamop *)(&((*_p)->y_u.xxxx.next))); - break; - case _traced_put_y_val : - (*_p) = ((yamop *)(&((*_p)->y_u.yx.next))); - break; - case _traced_put_y_vals : - (*_p) = ((yamop *)(&((*_p)->y_u.yyxx.next))); - break; - case _traced_put_unsafe : - (*_p) = ((yamop *)(&((*_p)->y_u.yx.next))); - break; - case _traced_put_atom : - (*_p) = ((yamop *)(&((*_p)->y_u.xc.next))); - break; - case _traced_put_dbterm : - (*_p) = ((yamop *)(&((*_p)->y_u.xD.next))); - break; - case _traced_put_bigint : - (*_p) = ((yamop *)(&((*_p)->y_u.xN.next))); - break; - case _traced_put_float : - (*_p) = ((yamop *)(&((*_p)->y_u.xd.next))); - break; - case _traced_put_longint : - (*_p) = ((yamop *)(&((*_p)->y_u.xi.next))); - break; - case _traced_put_list : - (*_p) = ((yamop *)(&((*_p)->y_u.x.next))); - break; - case _traced_put_struct : - (*_p) = ((yamop *)(&((*_p)->y_u.xfa.next))); - break; - case _traced_write_x_var : - (*_p) = ((yamop *)(&((*_p)->y_u.x.next))); - break; - case _traced_write_void : - (*_p) = ((yamop *)(&((*_p)->y_u.e.next))); - break; - case _traced_write_n_voids : - (*_p) = ((yamop *)(&((*_p)->y_u.s.next))); - break; - case _traced_write_y_var : - (*_p) = ((yamop *)(&((*_p)->y_u.y.next))); - break; - case _traced_write_x_val : - (*_p) = ((yamop *)(&((*_p)->y_u.x.next))); - break; - case _traced_write_x_loc : - (*_p) = ((yamop *)(&((*_p)->y_u.x.next))); - break; - case _traced_write_y_val : - (*_p) = ((yamop *)(&((*_p)->y_u.y.next))); - break; - case _traced_write_y_loc : - (*_p) = ((yamop *)(&((*_p)->y_u.y.next))); - break; - case _traced_write_atom : - (*_p) = ((yamop *)(&((*_p)->y_u.c.next))); - break; - case _traced_write_bigint : - (*_p) = ((yamop *)(&((*_p)->y_u.N.next))); - break; - case _traced_write_dbterm : - (*_p) = ((yamop *)(&((*_p)->y_u.D.next))); - break; - case _traced_write_float : - (*_p) = ((yamop *)(&((*_p)->y_u.d.next))); - break; - case _traced_write_longint : - (*_p) = ((yamop *)(&((*_p)->y_u.i.next))); - break; - case _traced_write_n_atoms : - (*_p) = ((yamop *)(&((*_p)->y_u.sc.next))); - break; - case _traced_write_list : - (*_p) = ((yamop *)(&((*_p)->y_u.e.next))); - break; - case _traced_write_l_list : - (*_p) = ((yamop *)(&((*_p)->y_u.e.next))); - break; - case _traced_write_struct : - (*_p) = ((yamop *)(&((*_p)->y_u.fa.next))); - break; - case _traced_write_l_struc : - (*_p) = ((yamop *)(&((*_p)->y_u.fa.next))); - break; - case _traced_save_pair_x : - (*_p) = ((yamop *)(&((*_p)->y_u.ox.next))); - break; - case _traced_save_pair_x_write : - (*_p) = ((yamop *)(&((*_p)->y_u.ox.next))); - break; - case _traced_save_pair_y : - (*_p) = ((yamop *)(&((*_p)->y_u.oy.next))); - break; - case _traced_save_pair_y_write : - (*_p) = ((yamop *)(&((*_p)->y_u.oy.next))); - break; - case _traced_save_appl_x : - (*_p) = ((yamop *)(&((*_p)->y_u.ox.next))); - break; - case _traced_save_appl_x_write : - (*_p) = ((yamop *)(&((*_p)->y_u.ox.next))); - break; - case _traced_save_appl_y : - (*_p) = ((yamop *)(&((*_p)->y_u.oy.next))); - break; - case _traced_save_appl_y_write : - (*_p) = ((yamop *)(&((*_p)->y_u.oy.next))); - break; - case _traced_jump : - (*_p) = ((yamop *)(&((*_p)->y_u.l.next))); - break; - case _traced_move_back : - (*_p) = ((yamop *)(&((*_p)->y_u.l.next))); - break; - case _traced_skip : - (*_p) = ((yamop *)(&((*_p)->y_u.l.next))); - break; - case _traced_either : - (*_p) = ((yamop *)(&((*_p)->y_u.Osblp.next))); - break; - case _traced_or_else : - (*_p) = ((yamop *)(&((*_p)->y_u.Osblp.next))); - break; - case _traced_pop_n : - (*_p) = ((yamop *)(&((*_p)->y_u.s.next))); - break; - case _traced_pop : - (*_p) = ((yamop *)(&((*_p)->y_u.e.next))); - break; - case _traced_call_cpred : - (*_p) = ((yamop *)(&((*_p)->y_u.Osbpp.next))); - break; - case _traced_execute_cpred : - (*_p) = ((yamop *)(&((*_p)->y_u.pp.next))); - break; - case _traced_call_usercpred : - (*_p) = ((yamop *)(&((*_p)->y_u.Osbpp.next))); - break; - case _traced_call_c_wfail : - (*_p) = ((yamop *)(&((*_p)->y_u.slp.next))); - break; - case _traced_try_c : - (*_p) = ((yamop *)(&((*_p)->y_u.OtapFs.next))); - break; - case _traced_retry_c : - (*_p) = ((yamop *)(&((*_p)->y_u.OtapFs.next))); - break; -#ifdef CUT_C - case _traced_cut_c : - (*_p) = ((yamop *)(&((*_p)->y_u.OtapFs.next))); - break; -#endif - case _traced_try_userc : - (*_p) = ((yamop *)(&((*_p)->y_u.OtapFs.next))); - break; - case _traced_retry_userc : - (*_p) = ((yamop *)(&((*_p)->y_u.OtapFs.next))); - break; -#ifdef CUT_C - case _traced_cut_userc : - (*_p) = ((yamop *)(&((*_p)->y_u.OtapFs.next))); - break; -#endif - case _traced_lock_pred : - (*_p) = ((yamop *)(&((*_p)->y_u.e.next))); - break; - case _traced_index_pred : - (*_p) = ((yamop *)(&((*_p)->y_u.e.next))); - break; -#ifdef THREADS - case _traced_thread_local : - (*_p) = ((yamop *)(&((*_p)->y_u.e.next))); - break; -#endif - case _traced_expand_index : - (*_p) = ((yamop *)(&((*_p)->y_u.e.next))); - break; - case _traced_expand_clauses : - (*_p) = ((yamop *)(&((*_p)->y_u.sssllp.next))); - break; - case _traced_undef_p : - (*_p) = ((yamop *)(&((*_p)->y_u.e.next))); - break; - case _traced_spy_pred : - (*_p) = ((yamop *)(&((*_p)->y_u.e.next))); - break; - case _traced_try_clause : - (*_p) = ((yamop *)(&((*_p)->y_u.Otapl.next))); - break; - case _traced_try_clause2 : - (*_p) = ((yamop *)(&((*_p)->y_u.l.next))); - break; - case _traced_try_clause3 : - (*_p) = ((yamop *)(&((*_p)->y_u.l.next))); - break; - case _traced_try_clause4 : - (*_p) = ((yamop *)(&((*_p)->y_u.l.next))); - break; - case _traced_retry : - (*_p) = ((yamop *)(&((*_p)->y_u.Otapl.next))); - break; - case _traced_retry2 : - (*_p) = ((yamop *)(&((*_p)->y_u.l.next))); - break; - case _traced_retry3 : - (*_p) = ((yamop *)(&((*_p)->y_u.l.next))); - break; - case _traced_retry4 : - (*_p) = ((yamop *)(&((*_p)->y_u.l.next))); - break; - case _traced_trust : - (*_p) = ((yamop *)(&((*_p)->y_u.Otapl.next))); - break; - case _traced_try_in : - (*_p) = ((yamop *)(&((*_p)->y_u.l.next))); - break; - case _traced_enter_lu_pred : - (*_p) = ((yamop *)(&((*_p)->y_u.Illss.next))); - break; - case _traced_try_logical : - (*_p) = ((yamop *)(&((*_p)->y_u.OtaLl.next))); - break; - case _traced_retry_logical : - (*_p) = ((yamop *)(&((*_p)->y_u.OtaLl.next))); - break; - case _traced_trust_logical : - (*_p) = ((yamop *)(&((*_p)->y_u.OtILl.next))); - break; - case _traced_user_switch : - (*_p) = ((yamop *)(&((*_p)->y_u.lp.next))); - break; - case _traced_switch_on_type : - (*_p) = ((yamop *)(&((*_p)->y_u.llll.next))); - break; - case _traced_switch_list_nl : - (*_p) = ((yamop *)(&((*_p)->y_u.ollll.next))); - break; - case _traced_switch_on_arg_type : - (*_p) = ((yamop *)(&((*_p)->y_u.xllll.next))); - break; - case _traced_switch_on_sub_arg_type : - (*_p) = ((yamop *)(&((*_p)->y_u.sllll.next))); - break; - case _traced_jump_if_var : - (*_p) = ((yamop *)(&((*_p)->y_u.l.next))); - break; - case _traced_jump_if_nonvar : - (*_p) = ((yamop *)(&((*_p)->y_u.xll.next))); - break; - case _traced_if_not_then : - (*_p) = ((yamop *)(&((*_p)->y_u.clll.next))); - break; - case _traced_switch_on_func : - (*_p) = ((yamop *)(&((*_p)->y_u.sssl.next))); - break; - case _traced_switch_on_cons : - (*_p) = ((yamop *)(&((*_p)->y_u.sssl.next))); - break; - case _traced_go_on_func : - (*_p) = ((yamop *)(&((*_p)->y_u.sssl.next))); - break; - case _traced_go_on_cons : - (*_p) = ((yamop *)(&((*_p)->y_u.sssl.next))); - break; - case _traced_if_func : - (*_p) = ((yamop *)(&((*_p)->y_u.sssl.next))); - break; - case _traced_if_cons : - (*_p) = ((yamop *)(&((*_p)->y_u.sssl.next))); - break; - case _traced_index_dbref : - (*_p) = ((yamop *)(&((*_p)->y_u.e.next))); - break; - case _traced_index_blob : - (*_p) = ((yamop *)(&((*_p)->y_u.e.next))); - break; - case _traced_index_long : - (*_p) = ((yamop *)(&((*_p)->y_u.e.next))); - break; - case _traced_jit_handler : - (*_p) = ((yamop *)(&((*_p)->y_u.J.next))); - break; - case _traced_p_atom_x : - (*_p) = ((yamop *)(&((*_p)->y_u.xl.next))); - break; - case _traced_p_atom_y : - (*_p) = ((yamop *)(&((*_p)->y_u.yl.next))); - break; - case _traced_p_atomic_x : - (*_p) = ((yamop *)(&((*_p)->y_u.xl.next))); - break; - case _traced_p_atomic_y : - (*_p) = ((yamop *)(&((*_p)->y_u.yl.next))); - break; - case _traced_p_integer_x : - (*_p) = ((yamop *)(&((*_p)->y_u.xl.next))); - break; - case _traced_p_integer_y : - (*_p) = ((yamop *)(&((*_p)->y_u.yl.next))); - break; - case _traced_p_nonvar_x : - (*_p) = ((yamop *)(&((*_p)->y_u.xl.next))); - break; - case _traced_p_nonvar_y : - (*_p) = ((yamop *)(&((*_p)->y_u.yl.next))); - break; - case _traced_p_number_x : - (*_p) = ((yamop *)(&((*_p)->y_u.xl.next))); - break; - case _traced_p_number_y : - (*_p) = ((yamop *)(&((*_p)->y_u.yl.next))); - break; - case _traced_p_var_x : - (*_p) = ((yamop *)(&((*_p)->y_u.xl.next))); - break; - case _traced_p_var_y : - (*_p) = ((yamop *)(&((*_p)->y_u.yl.next))); - break; - case _traced_p_db_ref_x : - (*_p) = ((yamop *)(&((*_p)->y_u.xl.next))); - break; - case _traced_p_db_ref_y : - (*_p) = ((yamop *)(&((*_p)->y_u.yl.next))); - break; - case _traced_p_primitive_x : - (*_p) = ((yamop *)(&((*_p)->y_u.xl.next))); - break; - case _traced_p_primitive_y : - (*_p) = ((yamop *)(&((*_p)->y_u.yl.next))); - break; - case _traced_p_compound_x : - (*_p) = ((yamop *)(&((*_p)->y_u.xl.next))); - break; - case _traced_p_compound_y : - (*_p) = ((yamop *)(&((*_p)->y_u.yl.next))); - break; - case _traced_p_float_x : - (*_p) = ((yamop *)(&((*_p)->y_u.xl.next))); - break; - case _traced_p_float_y : - (*_p) = ((yamop *)(&((*_p)->y_u.yl.next))); - break; - case _traced_p_plus_vv : - (*_p) = ((yamop *)(&((*_p)->y_u.xxx.next))); - break; - case _traced_p_plus_vc : - (*_p) = ((yamop *)(&((*_p)->y_u.xxn.next))); - break; - case _traced_p_plus_y_vv : - (*_p) = ((yamop *)(&((*_p)->y_u.yxx.next))); - break; - case _traced_p_plus_y_vc : - (*_p) = ((yamop *)(&((*_p)->y_u.yxn.next))); - break; - case _traced_p_minus_vv : - (*_p) = ((yamop *)(&((*_p)->y_u.xxx.next))); - break; - case _traced_p_minus_cv : - (*_p) = ((yamop *)(&((*_p)->y_u.xxn.next))); - break; - case _traced_p_minus_y_vv : - (*_p) = ((yamop *)(&((*_p)->y_u.yxx.next))); - break; - case _traced_p_minus_y_cv : - (*_p) = ((yamop *)(&((*_p)->y_u.yxn.next))); - break; - case _traced_p_times_vv : - (*_p) = ((yamop *)(&((*_p)->y_u.xxx.next))); - break; - case _traced_p_times_vc : - (*_p) = ((yamop *)(&((*_p)->y_u.xxn.next))); - break; - case _traced_p_times_y_vv : - (*_p) = ((yamop *)(&((*_p)->y_u.yxx.next))); - break; - case _traced_p_times_y_vc : - (*_p) = ((yamop *)(&((*_p)->y_u.yxn.next))); - break; - case _traced_p_div_vv : - (*_p) = ((yamop *)(&((*_p)->y_u.xxx.next))); - break; - case _traced_p_div_vc : - (*_p) = ((yamop *)(&((*_p)->y_u.xxn.next))); - break; - case _traced_p_div_cv : - (*_p) = ((yamop *)(&((*_p)->y_u.xxn.next))); - break; - case _traced_p_div_y_vv : - (*_p) = ((yamop *)(&((*_p)->y_u.yxx.next))); - break; - case _traced_p_div_y_vc : - (*_p) = ((yamop *)(&((*_p)->y_u.yxn.next))); - break; - case _traced_p_div_y_cv : - (*_p) = ((yamop *)(&((*_p)->y_u.yxn.next))); - break; - case _traced_p_and_vv : - (*_p) = ((yamop *)(&((*_p)->y_u.xxx.next))); - break; - case _traced_p_and_vc : - (*_p) = ((yamop *)(&((*_p)->y_u.xxn.next))); - break; - case _traced_p_and_y_vv : - (*_p) = ((yamop *)(&((*_p)->y_u.yxx.next))); - break; - case _traced_p_and_y_vc : - (*_p) = ((yamop *)(&((*_p)->y_u.yxn.next))); - break; - case _traced_p_or_vv : - (*_p) = ((yamop *)(&((*_p)->y_u.xxx.next))); - break; - case _traced_p_or_vc : - (*_p) = ((yamop *)(&((*_p)->y_u.xxn.next))); - break; - case _traced_p_or_y_vv : - (*_p) = ((yamop *)(&((*_p)->y_u.yxx.next))); - break; - case _traced_p_or_y_vc : - (*_p) = ((yamop *)(&((*_p)->y_u.yxn.next))); - break; - case _traced_p_sll_vv : - (*_p) = ((yamop *)(&((*_p)->y_u.xxx.next))); - break; - case _traced_p_sll_vc : - (*_p) = ((yamop *)(&((*_p)->y_u.xxn.next))); - break; - case _traced_p_sll_cv : - (*_p) = ((yamop *)(&((*_p)->y_u.xxn.next))); - break; - case _traced_p_sll_y_vv : - (*_p) = ((yamop *)(&((*_p)->y_u.yxx.next))); - break; - case _traced_p_sll_y_vc : - (*_p) = ((yamop *)(&((*_p)->y_u.yxn.next))); - break; - case _traced_p_sll_y_cv : - (*_p) = ((yamop *)(&((*_p)->y_u.yxn.next))); - break; - case _traced_p_slr_vv : - (*_p) = ((yamop *)(&((*_p)->y_u.xxx.next))); - break; - case _traced_p_slr_vc : - (*_p) = ((yamop *)(&((*_p)->y_u.xxn.next))); - break; - case _traced_p_slr_cv : - (*_p) = ((yamop *)(&((*_p)->y_u.xxn.next))); - break; - case _traced_p_slr_y_vv : - (*_p) = ((yamop *)(&((*_p)->y_u.yxx.next))); - break; - case _traced_p_slr_y_vc : - (*_p) = ((yamop *)(&((*_p)->y_u.yxn.next))); - break; - case _traced_p_slr_y_cv : - (*_p) = ((yamop *)(&((*_p)->y_u.yxn.next))); - break; - case _traced_call_bfunc_xx : - (*_p) = ((yamop *)(&((*_p)->y_u.plxxs.next))); - break; - case _traced_call_bfunc_yx : - (*_p) = ((yamop *)(&((*_p)->y_u.plxys.next))); - break; - case _traced_call_bfunc_xy : - (*_p) = ((yamop *)(&((*_p)->y_u.plxys.next))); - break; - case _traced_call_bfunc_yy : - (*_p) = ((yamop *)(&((*_p)->y_u.plyys.next))); - break; - case _traced_p_equal : - (*_p) = ((yamop *)(&((*_p)->y_u.e.next))); - break; - case _traced_p_dif : - (*_p) = ((yamop *)(&((*_p)->y_u.l.next))); - break; - case _traced_p_eq : - (*_p) = ((yamop *)(&((*_p)->y_u.l.next))); - break; - case _traced_p_arg_vv : - (*_p) = ((yamop *)(&((*_p)->y_u.xxx.next))); - break; - case _traced_p_arg_cv : - (*_p) = ((yamop *)(&((*_p)->y_u.xxn.next))); - break; - case _traced_p_arg_y_vv : - (*_p) = ((yamop *)(&((*_p)->y_u.yxx.next))); - break; - case _traced_p_arg_y_cv : - (*_p) = ((yamop *)(&((*_p)->y_u.yxn.next))); - break; - case _traced_p_func2s_vv : - (*_p) = ((yamop *)(&((*_p)->y_u.xxx.next))); - break; - case _traced_p_func2s_cv : - (*_p) = ((yamop *)(&((*_p)->y_u.xxc.next))); - break; - case _traced_p_func2s_vc : - (*_p) = ((yamop *)(&((*_p)->y_u.xxn.next))); - break; - case _traced_p_func2s_y_vv : - (*_p) = ((yamop *)(&((*_p)->y_u.yxx.next))); - break; - case _traced_p_func2s_y_cv : - (*_p) = ((yamop *)(&((*_p)->y_u.yxn.next))); - break; - case _traced_p_func2s_y_vc : - (*_p) = ((yamop *)(&((*_p)->y_u.yxn.next))); - break; - case _traced_p_func2f_xx : - (*_p) = ((yamop *)(&((*_p)->y_u.xxx.next))); - break; - case _traced_p_func2f_xy : - (*_p) = ((yamop *)(&((*_p)->y_u.xxy.next))); - break; - case _traced_p_func2f_yx : - (*_p) = ((yamop *)(&((*_p)->y_u.yxx.next))); - break; - case _traced_p_func2f_yy : - (*_p) = ((yamop *)(&((*_p)->y_u.yyx.next))); - break; - case _traced_p_functor : - (*_p) = ((yamop *)(&((*_p)->y_u.e.next))); - break; - case _traced_p_execute2 : - (*_p) = ((yamop *)(&((*_p)->y_u.Osbpp.next))); - break; - case _traced_p_execute : - (*_p) = ((yamop *)(&((*_p)->y_u.Osbmp.next))); - break; - case _traced_p_execute_tail : - (*_p) = ((yamop *)(&((*_p)->y_u.Osbpp.next))); - break; -#ifdef YAPOR - case _traced_getwork_first_time : - (*_p) = ((yamop *)(&((*_p)->y_u.e.next))); - break; - case _traced_getwork : - (*_p) = ((yamop *)(&((*_p)->y_u.Otapl.next))); - break; - case _traced_getwork_seq : - (*_p) = ((yamop *)(&((*_p)->y_u.Otapl.next))); - break; - case _traced_sync : - (*_p) = ((yamop *)(&((*_p)->y_u.Otapl.next))); - break; -#endif -#ifdef TABLING -#ifdef TABLING_INNER_CUTS - case _traced_clause_with_cut : - (*_p) = ((yamop *)(&((*_p)->y_u.e.next))); - break; -#endif - case _traced_table_load_answer : - (*_p) = ((yamop *)(&((*_p)->y_u.Otapl.next))); - break; - case _traced_table_try_answer : - (*_p) = ((yamop *)(&((*_p)->y_u.Otapl.next))); - break; - case _traced_table_try_single : - (*_p) = ((yamop *)(&((*_p)->y_u.Otapl.next))); - break; - case _traced_table_try_me : - (*_p) = ((yamop *)(&((*_p)->y_u.Otapl.next))); - break; - case _traced_table_try : - (*_p) = ((yamop *)(&((*_p)->y_u.Otapl.next))); - break; - case _traced_table_retry_me : - (*_p) = ((yamop *)(&((*_p)->y_u.Otapl.next))); - break; - case _traced_table_retry : - (*_p) = ((yamop *)(&((*_p)->y_u.Otapl.next))); - break; - case _traced_table_trust_me : - (*_p) = ((yamop *)(&((*_p)->y_u.Otapl.next))); - break; - case _traced_table_trust : - (*_p) = ((yamop *)(&((*_p)->y_u.Otapl.next))); - break; - case _traced_table_new_answer : - (*_p) = ((yamop *)(&((*_p)->y_u.s.next))); - break; - case _traced_table_answer_resolution : - (*_p) = ((yamop *)(&((*_p)->y_u.Otapl.next))); - break; - case _traced_table_completion : - (*_p) = ((yamop *)(&((*_p)->y_u.Otapl.next))); - break; -#ifdef THREADS_CONSUMER_SHARING - case _traced_table_answer_resolution_completion: - (*_p) = ((yamop *)(&((*_p)->y_u.Otapl.next))); - break; -#endif - case _traced_trie_do_var : - (*_p) = ((yamop *)(&((*_p)->y_u.e.next))); - break; - case _traced_trie_trust_var : - (*_p) = ((yamop *)(&((*_p)->y_u.e.next))); - break; - case _traced_trie_try_var : - (*_p) = ((yamop *)(&((*_p)->y_u.e.next))); - break; - case _traced_trie_retry_var : - (*_p) = ((yamop *)(&((*_p)->y_u.e.next))); - break; - case _traced_trie_do_var_in_pair : - (*_p) = ((yamop *)(&((*_p)->y_u.e.next))); - break; - case _traced_trie_trust_var_in_pair : - (*_p) = ((yamop *)(&((*_p)->y_u.e.next))); - break; - case _traced_trie_try_var_in_pair : - (*_p) = ((yamop *)(&((*_p)->y_u.e.next))); - break; - case _traced_trie_retry_var_in_pair : - (*_p) = ((yamop *)(&((*_p)->y_u.e.next))); - break; - case _traced_trie_do_val : - (*_p) = ((yamop *)(&((*_p)->y_u.e.next))); - break; - case _traced_trie_trust_val : - (*_p) = ((yamop *)(&((*_p)->y_u.e.next))); - break; - case _traced_trie_try_val : - (*_p) = ((yamop *)(&((*_p)->y_u.e.next))); - break; - case _traced_trie_retry_val : - (*_p) = ((yamop *)(&((*_p)->y_u.e.next))); - break; - case _traced_trie_do_val_in_pair : - (*_p) = ((yamop *)(&((*_p)->y_u.e.next))); - break; - case _traced_trie_trust_val_in_pair : - (*_p) = ((yamop *)(&((*_p)->y_u.e.next))); - break; - case _traced_trie_try_val_in_pair : - (*_p) = ((yamop *)(&((*_p)->y_u.e.next))); - break; - case _traced_trie_retry_val_in_pair : - (*_p) = ((yamop *)(&((*_p)->y_u.e.next))); - break; - case _traced_trie_do_atom : - (*_p) = ((yamop *)(&((*_p)->y_u.e.next))); - break; - case _traced_trie_trust_atom : - (*_p) = ((yamop *)(&((*_p)->y_u.e.next))); - break; - case _traced_trie_try_atom : - (*_p) = ((yamop *)(&((*_p)->y_u.e.next))); - break; - case _traced_trie_retry_atom : - (*_p) = ((yamop *)(&((*_p)->y_u.e.next))); - break; - case _traced_trie_do_atom_in_pair : - (*_p) = ((yamop *)(&((*_p)->y_u.e.next))); - break; - case _traced_trie_trust_atom_in_pair : - (*_p) = ((yamop *)(&((*_p)->y_u.e.next))); - break; - case _traced_trie_try_atom_in_pair : - (*_p) = ((yamop *)(&((*_p)->y_u.e.next))); - break; - case _traced_trie_retry_atom_in_pair : - (*_p) = ((yamop *)(&((*_p)->y_u.e.next))); - break; - case _traced_trie_do_null : - (*_p) = ((yamop *)(&((*_p)->y_u.e.next))); - break; - case _traced_trie_trust_null : - (*_p) = ((yamop *)(&((*_p)->y_u.e.next))); - break; - case _traced_trie_try_null : - (*_p) = ((yamop *)(&((*_p)->y_u.e.next))); - break; - case _traced_trie_retry_null : - (*_p) = ((yamop *)(&((*_p)->y_u.e.next))); - break; - case _traced_trie_do_null_in_pair : - (*_p) = ((yamop *)(&((*_p)->y_u.e.next))); - break; - case _traced_trie_trust_null_in_pair : - (*_p) = ((yamop *)(&((*_p)->y_u.e.next))); - break; - case _traced_trie_try_null_in_pair : - (*_p) = ((yamop *)(&((*_p)->y_u.e.next))); - break; - case _traced_trie_retry_null_in_pair : - (*_p) = ((yamop *)(&((*_p)->y_u.e.next))); - break; - case _traced_trie_do_pair : - (*_p) = ((yamop *)(&((*_p)->y_u.e.next))); - break; - case _traced_trie_trust_pair : - (*_p) = ((yamop *)(&((*_p)->y_u.e.next))); - break; - case _traced_trie_try_pair : - (*_p) = ((yamop *)(&((*_p)->y_u.e.next))); - break; - case _traced_trie_retry_pair : - (*_p) = ((yamop *)(&((*_p)->y_u.e.next))); - break; - case _traced_trie_do_appl : - (*_p) = ((yamop *)(&((*_p)->y_u.e.next))); - break; - case _traced_trie_trust_appl : - (*_p) = ((yamop *)(&((*_p)->y_u.e.next))); - break; - case _traced_trie_try_appl : - (*_p) = ((yamop *)(&((*_p)->y_u.e.next))); - break; - case _traced_trie_retry_appl : - (*_p) = ((yamop *)(&((*_p)->y_u.e.next))); - break; - case _traced_trie_do_appl_in_pair : - (*_p) = ((yamop *)(&((*_p)->y_u.e.next))); - break; - case _traced_trie_trust_appl_in_pair : - (*_p) = ((yamop *)(&((*_p)->y_u.e.next))); - break; - case _traced_trie_try_appl_in_pair : - (*_p) = ((yamop *)(&((*_p)->y_u.e.next))); - break; - case _traced_trie_retry_appl_in_pair : - (*_p) = ((yamop *)(&((*_p)->y_u.e.next))); - break; - case _traced_trie_do_extension : - (*_p) = ((yamop *)(&((*_p)->y_u.e.next))); - break; - case _traced_trie_trust_extension : - (*_p) = ((yamop *)(&((*_p)->y_u.e.next))); - break; - case _traced_trie_try_extension : - (*_p) = ((yamop *)(&((*_p)->y_u.e.next))); - break; - case _traced_trie_retry_extension : - (*_p) = ((yamop *)(&((*_p)->y_u.e.next))); - break; - case _traced_trie_do_double : - (*_p) = ((yamop *)(&((*_p)->y_u.e.next))); - break; - case _traced_trie_trust_double : - (*_p) = ((yamop *)(&((*_p)->y_u.e.next))); - break; - case _traced_trie_try_double : - (*_p) = ((yamop *)(&((*_p)->y_u.e.next))); - break; - case _traced_trie_retry_double : - (*_p) = ((yamop *)(&((*_p)->y_u.e.next))); - break; - case _traced_trie_do_longint : - (*_p) = ((yamop *)(&((*_p)->y_u.e.next))); - break; - case _traced_trie_trust_longint : - (*_p) = ((yamop *)(&((*_p)->y_u.e.next))); - break; - case _traced_trie_try_longint : - (*_p) = ((yamop *)(&((*_p)->y_u.e.next))); - break; - case _traced_trie_retry_longint : - (*_p) = ((yamop *)(&((*_p)->y_u.e.next))); - break; - case _traced_trie_do_gterm : - (*_p) = ((yamop *)(&((*_p)->y_u.e.next))); - break; - case _traced_trie_trust_gterm : - (*_p) = ((yamop *)(&((*_p)->y_u.e.next))); - break; - case _traced_trie_try_gterm : - (*_p) = ((yamop *)(&((*_p)->y_u.e.next))); - break; - case _traced_trie_retry_gterm : - (*_p) = ((yamop *)(&((*_p)->y_u.e.next))); - break; -#endif -#ifdef YAPOR - case _traced_or_last : - (*_p) = ((yamop *)(&((*_p)->y_u.sblp.next))); - break; -#else - case _traced_or_last : - (*_p) = ((yamop *)(&((*_p)->y_u.p.next))); - break; -#endif - default: + default: printf("Bad argument in lastop\n"); return; } diff --git a/JIT/HPP/sprint_op.hpp b/JIT/HPP/sprint_op.hpp index 1d1cc4e9b..cb682d25a 100644 --- a/JIT/HPP/sprint_op.hpp +++ b/JIT/HPP/sprint_op.hpp @@ -1583,1595 +1583,10 @@ sprint_op(char *out, char* prepend_term, op_numbers op, char* append_term) { sprintf(tmp, "_or_last"); break; -#endif - -#ifdef YAP_JIT - case _traced_Ystop : - sprintf(tmp, "_traced_Ystop"); - break; - - case _traced_Nstop : - sprintf(tmp, "_traced_Nstop"); - break; - - case _traced_try_me : - sprintf(tmp, "_traced_try_me"); - break; - - case _traced_retry_me : - sprintf(tmp, "_traced_retry_me"); - break; - - case _traced_trust_me : - sprintf(tmp, "_traced_trust_me"); - break; - - case _traced_enter_profiling : - sprintf(tmp, "_traced_enter_profiling"); - break; - - case _traced_retry_profiled : - sprintf(tmp, "_traced_retry_profiled"); - break; - - case _traced_profiled_retry_me : - sprintf(tmp, "_traced_profiled_retry_me"); - break; - - case _traced_profiled_trust_me : - sprintf(tmp, "_traced_profiled_trust_me"); - break; - - case _traced_profiled_retry_logical : - sprintf(tmp, "_traced_profiled_retry_logical"); - break; - - case _traced_profiled_trust_logical : - sprintf(tmp, "_traced_profiled_trust_logical"); - break; - - case _traced_count_call : - sprintf(tmp, "_traced_count_call"); - break; - - case _traced_count_retry : - sprintf(tmp, "_traced_count_retry"); - break; - - case _traced_count_retry_me : - sprintf(tmp, "_traced_count_retry_me"); - break; - - case _traced_count_trust_me : - sprintf(tmp, "_traced_count_trust_me"); - break; - - case _traced_count_retry_logical : - sprintf(tmp, "_traced_count_retry_logical"); - break; - - case _traced_count_trust_logical : - sprintf(tmp, "_traced_count_trust_logical"); - break; - - case _traced_lock_lu : - sprintf(tmp, "_traced_lock_lu"); - break; - - case _traced_unlock_lu : - sprintf(tmp, "_traced_unlock_lu"); - break; - - case _traced_alloc_for_logical_pred : - sprintf(tmp, "_traced_alloc_for_logical_pred"); - break; - - case _traced_copy_idb_term : - sprintf(tmp, "_traced_copy_idb_term"); - break; - - case _traced_unify_idb_term : - sprintf(tmp, "_traced_unify_idb_term"); - break; - - case _traced_ensure_space : - sprintf(tmp, "_traced_ensure_space"); - break; - - case _traced_spy_or_trymark : - sprintf(tmp, "_traced_spy_or_trymark"); - break; - - case _traced_try_and_mark : - sprintf(tmp, "_traced_try_and_mark"); - break; - - case _traced_count_retry_and_mark : - sprintf(tmp, "_traced_count_retry_and_mark"); - break; - - case _traced_profiled_retry_and_mark : - sprintf(tmp, "_traced_profiled_retry_and_mark"); - break; - - case _traced_retry_and_mark : - sprintf(tmp, "_traced_retry_and_mark"); - break; - - case _traced_trust_fail : - sprintf(tmp, "_traced_trust_fail"); - break; - - case _traced_op_fail : - sprintf(tmp, "_traced_op_fail"); - break; - - case _traced_cut : - sprintf(tmp, "_traced_cut"); - break; - - case _traced_cut_t : - sprintf(tmp, "_traced_cut_t"); - break; - - case _traced_cut_e : - sprintf(tmp, "_traced_cut_e"); - break; - - case _traced_save_b_x : - sprintf(tmp, "_traced_save_b_x"); - break; - - case _traced_save_b_y : - sprintf(tmp, "_traced_save_b_y"); - break; - - case _traced_commit_b_x : - sprintf(tmp, "_traced_commit_b_x"); - break; - - case _traced_commit_b_y : - sprintf(tmp, "_traced_commit_b_y"); - break; - - case _traced_execute : - sprintf(tmp, "_traced_execute"); - break; - - case _traced_dexecute : - sprintf(tmp, "_traced_dexecute"); - break; - - case _traced_fcall : - sprintf(tmp, "_traced_fcall"); - break; - - case _traced_call : - sprintf(tmp, "_traced_call"); - break; - - case _traced_procceed : - sprintf(tmp, "_traced_procceed"); - break; - - case _traced_allocate : - sprintf(tmp, "_traced_allocate"); - break; - - case _traced_deallocate : - sprintf(tmp, "_traced_deallocate"); - break; - -#ifdef BEAM - case _traced_retry_eam : - sprintf(tmp, "_traced_retry_eam"); - break; - -#endif -#ifdef BEAM - case _traced_run_eam : - sprintf(tmp, "_traced_run_eam"); - break; - -#endif - case _traced_get_x_var : - sprintf(tmp, "_traced_get_x_var"); - break; - - case _traced_get_y_var : - sprintf(tmp, "_traced_get_y_var"); - break; - - case _traced_get_yy_var : - sprintf(tmp, "_traced_get_yy_var"); - break; - - case _traced_get_x_val : - sprintf(tmp, "_traced_get_x_val"); - break; - - case _traced_get_y_val : - sprintf(tmp, "_traced_get_y_val"); - break; - - case _traced_get_atom : - sprintf(tmp, "_traced_get_atom"); - break; - - case _traced_get_2atoms : - sprintf(tmp, "_traced_get_2atoms"); - break; - - case _traced_get_3atoms : - sprintf(tmp, "_traced_get_3atoms"); - break; - - case _traced_get_4atoms : - sprintf(tmp, "_traced_get_4atoms"); - break; - - case _traced_get_5atoms : - sprintf(tmp, "_traced_get_5atoms"); - break; - - case _traced_get_6atoms : - sprintf(tmp, "_traced_get_6atoms"); - break; - - case _traced_get_list : - sprintf(tmp, "_traced_get_list"); - break; - - case _traced_get_struct : - sprintf(tmp, "_traced_get_struct"); - break; - - case _traced_get_float : - sprintf(tmp, "_traced_get_float"); - break; - - case _traced_get_longint : - sprintf(tmp, "_traced_get_longint"); - break; - - case _traced_get_bigint : - sprintf(tmp, "_traced_get_bigint"); - break; - - case _traced_get_dbterm : - sprintf(tmp, "_traced_get_dbterm"); - break; - - case _traced_glist_valx : - sprintf(tmp, "_traced_glist_valx"); - break; - - case _traced_glist_valy : - sprintf(tmp, "_traced_glist_valy"); - break; - - case _traced_gl_void_varx : - sprintf(tmp, "_traced_gl_void_varx"); - break; - - case _traced_gl_void_vary : - sprintf(tmp, "_traced_gl_void_vary"); - break; - - case _traced_gl_void_valx : - sprintf(tmp, "_traced_gl_void_valx"); - break; - - case _traced_gl_void_valy : - sprintf(tmp, "_traced_gl_void_valy"); - break; - - case _traced_unify_x_var : - sprintf(tmp, "_traced_unify_x_var"); - break; - - case _traced_unify_x_var_write : - sprintf(tmp, "_traced_unify_x_var_write"); - break; - - case _traced_unify_l_x_var : - sprintf(tmp, "_traced_unify_l_x_var"); - break; - - case _traced_unify_l_x_var_write : - sprintf(tmp, "_traced_unify_l_x_var_write"); - break; - - case _traced_unify_x_var2 : - sprintf(tmp, "_traced_unify_x_var2"); - break; - - case _traced_unify_x_var2_write : - sprintf(tmp, "_traced_unify_x_var2_write"); - break; - - case _traced_unify_l_x_var2 : - sprintf(tmp, "_traced_unify_l_x_var2"); - break; - - case _traced_unify_l_x_var2_write : - sprintf(tmp, "_traced_unify_l_x_var2_write"); - break; - - case _traced_unify_y_var : - sprintf(tmp, "_traced_unify_y_var"); - break; - - case _traced_unify_y_var_write : - sprintf(tmp, "_traced_unify_y_var_write"); - break; - - case _traced_unify_l_y_var : - sprintf(tmp, "_traced_unify_l_y_var"); - break; - - case _traced_unify_l_y_var_write : - sprintf(tmp, "_traced_unify_l_y_var_write"); - break; - - case _traced_unify_x_val : - sprintf(tmp, "_traced_unify_x_val"); - break; - - case _traced_unify_x_val_write : - sprintf(tmp, "_traced_unify_x_val_write"); - break; - - case _traced_unify_l_x_val : - sprintf(tmp, "_traced_unify_l_x_val"); - break; - - case _traced_unify_l_x_val_write : - sprintf(tmp, "_traced_uify_l_x_val_write"); - break; - - case _traced_unify_y_val : - sprintf(tmp, "_traced_unify_y_val"); - break; - - case _traced_unify_y_val_write : - sprintf(tmp, "_traced_unify_y_val_write"); - break; - - case _traced_unify_l_y_val : - sprintf(tmp, "_traced_unify_l_y_val"); - break; - - case _traced_unify_l_y_val_write : - sprintf(tmp, "_traced_unify_l_y_val_write"); - break; - - case _traced_unify_x_loc : - sprintf(tmp, "_traced_unify_x_loc"); - break; - - case _traced_unify_x_loc_write : - sprintf(tmp, "_traced_unify_x_loc_write"); - break; - - case _traced_unify_l_x_loc : - sprintf(tmp, "_traced_unify_l_x_loc"); - break; - - case _traced_unify_l_x_loc_write : - sprintf(tmp, "_traced_unify_l_x_loc_write"); - break; - - case _traced_unify_y_loc : - sprintf(tmp, "_traced_unify_y_loc"); - break; - - case _traced_unify_y_loc_write : - sprintf(tmp, "_traced_unify_y_loc_write"); - break; - - case _traced_unify_l_y_loc : - sprintf(tmp, "_traced_unify_l_y_loc"); - break; - - case _traced_unify_l_y_loc_write : - sprintf(tmp, "_traced_unify_l_y_loc_write"); - break; - - case _traced_unify_void : - sprintf(tmp, "_traced_unify_void"); - break; - - case _traced_unify_void_write : - sprintf(tmp, "_traced_unify_void_write"); - break; - - case _traced_unify_l_void : - sprintf(tmp, "_traced_unify_l_void"); - break; - - case _traced_unify_l_void_write : - sprintf(tmp, "_traced_unify_l_void_write"); - break; - - case _traced_unify_n_voids : - sprintf(tmp, "_traced_unify_n_voids"); - break; - - case _traced_unify_n_voids_write : - sprintf(tmp, "_traced_unify_n_voids_write"); - break; - - case _traced_unify_l_n_voids : - sprintf(tmp, "_traced_unify_l_n_voids"); - break; - - case _traced_unify_l_n_voids_write : - sprintf(tmp, "_traced_unify_l_n_voids_write"); - break; - - case _traced_unify_atom : - sprintf(tmp, "_traced_unify_atom"); - break; - - case _traced_unify_atom_write : - sprintf(tmp, "_traced_unify_atom_write"); - break; - - case _traced_unify_l_atom : - sprintf(tmp, "_traced_unify_l_atom"); - break; - - case _traced_unify_l_atom_write : - sprintf(tmp, "_traced_unify_l_atom_write"); - break; - - case _traced_unify_n_atoms : - sprintf(tmp, "_traced_unify_n_atoms"); - break; - - case _traced_unify_n_atoms_write : - sprintf(tmp, "_traced_unify_n_atoms_write"); - break; - - case _traced_unify_float : - sprintf(tmp, "_traced_unify_float"); - break; - - case _traced_unify_float_write : - sprintf(tmp, "_traced_unify_float_write"); - break; - - case _traced_unify_l_float : - sprintf(tmp, "_traced_unify_l_float"); - break; - - case _traced_unify_l_float_write : - sprintf(tmp, "_traced_unify_l_float_write"); - break; - - case _traced_unify_longint : - sprintf(tmp, "_traced_unify_longint"); - break; - - case _traced_unify_longint_write : - sprintf(tmp, "_traced_unify_longint_write"); - break; - - case _traced_unify_l_longint : - sprintf(tmp, "_traced_unify_l_longint"); - break; - - case _traced_unify_l_longint_write : - sprintf(tmp, "_traced_unify_l_longint_write"); - break; - - case _traced_unify_bigint : - sprintf(tmp, "_traced_unify_bigint"); - break; - - case _traced_unify_l_bigint : - sprintf(tmp, "_traced_unify_l_bigint"); - break; - - case _traced_unify_dbterm : - sprintf(tmp, "_traced_unify_dbterm"); - break; - - case _traced_unify_l_dbterm : - sprintf(tmp, "_traced_unify_l_dbterm"); - break; - - case _traced_unify_list : - sprintf(tmp, "_traced_unify_list"); - break; - - case _traced_unify_list_write : - sprintf(tmp, "_traced_unify_list_write"); - break; - - case _traced_unify_l_list : - sprintf(tmp, "_traced_unify_l_list"); - break; - - case _traced_unify_l_list_write : - sprintf(tmp, "_traced_unify_l_list_write"); - break; - - case _traced_unify_struct : - sprintf(tmp, "_traced_unify_struct"); - break; - - case _traced_unify_struct_write : - sprintf(tmp, "_traced_unify_struct_write"); - break; - - case _traced_unify_l_struc : - sprintf(tmp, "_traced_unify_l_struc"); - break; - - case _traced_unify_l_struc_write : - sprintf(tmp, "_traced_unify_l_struc_write"); - break; - - case _traced_put_x_var : - sprintf(tmp, "_traced_put_x_var"); - break; - - case _traced_put_y_var : - sprintf(tmp, "_traced_put_y_var"); - break; - - case _traced_put_x_val : - sprintf(tmp, "_traced_put_x_val"); - break; - - case _traced_put_xx_val : - sprintf(tmp, "_traced_put_xx_val"); - break; - - case _traced_put_y_val : - sprintf(tmp, "_traced_put_y_val"); - break; - - case _traced_put_y_vals : - sprintf(tmp, "_traced_put_y_vals"); - break; - - case _traced_put_unsafe : - sprintf(tmp, "_traced_put_unsafe"); - break; - - case _traced_put_atom : - sprintf(tmp, "_traced_put_atom"); - break; - - case _traced_put_dbterm : - sprintf(tmp, "_traced_put_dbterm"); - break; - - case _traced_put_bigint : - sprintf(tmp, "_traced_put_bigint"); - break; - - case _traced_put_float : - sprintf(tmp, "_traced_put_float"); - break; - - case _traced_put_longint : - sprintf(tmp, "_traced_put_longint"); - break; - - case _traced_put_list : - sprintf(tmp, "_traced_put_list"); - break; - - case _traced_put_struct : - sprintf(tmp, "_traced_put_struct"); - break; - - case _traced_write_x_var : - sprintf(tmp, "_traced_write_x_var"); - break; - - case _traced_write_void : - sprintf(tmp, "_traced_write_void"); - break; - - case _traced_write_n_voids : - sprintf(tmp, "_traced_write_n_voids"); - break; - - case _traced_write_y_var : - sprintf(tmp, "_traced_write_y_var"); - break; - - case _traced_write_x_val : - sprintf(tmp, "_traced_write_x_val"); - break; - - case _traced_write_x_loc : - sprintf(tmp, "_traced_write_x_loc"); - break; - - case _traced_write_y_val : - sprintf(tmp, "_traced_write_y_val"); - break; - - case _traced_write_y_loc : - sprintf(tmp, "_traced_write_y_loc"); - break; - - case _traced_write_atom : - sprintf(tmp, "_traced_write_atom"); - break; - - case _traced_write_bigint : - sprintf(tmp, "_traced_write_bigint"); - break; - - case _traced_write_dbterm : - sprintf(tmp, "_traced_write_dbterm"); - break; - - case _traced_write_float : - sprintf(tmp, "_traced_write_float"); - break; - - case _traced_write_longint : - sprintf(tmp, "_traced_write_longint"); - break; - - case _traced_write_n_atoms : - sprintf(tmp, "_traced_write_n_atoms"); - break; - - case _traced_write_list : - sprintf(tmp, "_traced_write_list"); - break; - - case _traced_write_l_list : - sprintf(tmp, "_traced_write_l_list"); - break; - - case _traced_write_struct : - sprintf(tmp, "_traced_write_struct"); - break; - - case _traced_write_l_struc : - sprintf(tmp, "_traced_write_l_struc"); - break; - - case _traced_save_pair_x : - sprintf(tmp, "_traced_save_pair_x"); - break; - - case _traced_save_pair_x_write : - sprintf(tmp, "_traced_save_pair_x_write"); - break; - - case _traced_save_pair_y : - sprintf(tmp, "_traced_save_pair_y"); - break; - - case _traced_save_pair_y_write : - sprintf(tmp, "_traced_save_pair_y_write"); - break; - - case _traced_save_appl_x : - sprintf(tmp, "_traced_save_appl_x"); - break; - - case _traced_save_appl_x_write : - sprintf(tmp, "_traced_save_appl_x_write"); - break; - - case _traced_save_appl_y : - sprintf(tmp, "_traced_save_appl_y"); - break; - - case _traced_save_appl_y_write : - sprintf(tmp, "_traced_save_appl_y_write"); - break; - - case _traced_jump : - sprintf(tmp, "_traced_jump"); - break; - - case _traced_move_back : - sprintf(tmp, "_traced_move_back"); - break; - - case _traced_skip : - sprintf(tmp, "_traced_skip"); - break; - - case _traced_either : - sprintf(tmp, "_traced_either"); - break; - - case _traced_or_else : - sprintf(tmp, "_traced_or_else"); - break; - - case _traced_pop_n : - sprintf(tmp, "_traced_pop_n"); - break; - - case _traced_pop : - sprintf(tmp, "_traced_pop"); - break; - - case _traced_call_cpred : - sprintf(tmp, "_traced_call_cpred"); - break; - - case _traced_execute_cpred : - sprintf(tmp, "_traced_execute_cpred"); - break; - - case _traced_call_usercpred : - sprintf(tmp, "_traced_call_usercpred"); - break; - - case _traced_call_c_wfail : - sprintf(tmp, "_traced_call_x_wfail"); - break; - - case _traced_try_c : - sprintf(tmp, "_traced_try_c"); - break; - - case _traced_retry_c : - sprintf(tmp, "_traced_retry_c"); - break; - -#ifdef CUT_C - case _traced_cut_c : - sprintf(tmp, "_traced_cut_c"); - break; - -#endif - case _traced_try_userc : - sprintf(tmp, "_traced_try_userc"); - break; - - case _traced_retry_userc : - sprintf(tmp, "_traced_retry_userc"); - break; - -#ifdef CUT_C - case _traced_cut_userc : - sprintf(tmp, "_traced_cut_userc"); - break; - -#endif - case _traced_lock_pred : - sprintf(tmp, "_traced_lock_pred"); - break; - - case _traced_index_pred : - sprintf(tmp, "_traced_index_pred"); - break; - -#ifdef THREADS - case _traced_thread_local : - sprintf(tmp, "_traced_thread_local"); - break; - -#endif - case _traced_expand_index : - sprintf(tmp, "_traced_expand_index"); - break; - - case _traced_expand_clauses : - sprintf(tmp, "_traced_expand_clauses"); - break; - - case _traced_undef_p : - sprintf(tmp, "_traced_undef_p"); - break; - - case _traced_spy_pred : - sprintf(tmp, "_traced_spy_pred"); - break; - - case _traced_try_clause : - sprintf(tmp, "_traced_try_clause"); - break; - - case _traced_try_clause2 : - sprintf(tmp, "_traced_try_clause2"); - break; - - case _traced_try_clause3 : - sprintf(tmp, "_traced_try_clause3"); - break; - - case _traced_try_clause4 : - sprintf(tmp, "_traced_try_clause4"); - break; - - case _traced_retry : - sprintf(tmp, "_traced_retry"); - break; - - case _traced_retry2 : - sprintf(tmp, "_traced_retry2"); - break; - - case _traced_retry3 : - sprintf(tmp, "_traced_retry3"); - break; - - case _traced_retry4 : - sprintf(tmp, "_traced_retry4"); - break; - - case _traced_trust : - sprintf(tmp, "_traced_trust"); - break; - - case _traced_try_in : - sprintf(tmp, "_traced_try_in"); - break; - - case _traced_enter_lu_pred : - sprintf(tmp, "_traced_enter_lu_pred"); - break; - - case _traced_try_logical : - sprintf(tmp, "_traced_try_logical"); - break; - - case _traced_retry_logical : - sprintf(tmp, "_traced_retry_logical"); - break; - - case _traced_trust_logical : - sprintf(tmp, "_traced_trust_logical"); - break; - - case _traced_user_switch : - sprintf(tmp, "_traced_user_switch"); - break; - - case _traced_switch_on_type : - sprintf(tmp, "_traced_switch_on_type"); - break; - - case _traced_switch_list_nl : - sprintf(tmp, "_traced_switch_list_nl"); - break; - - case _traced_switch_on_arg_type : - sprintf(tmp, "_traced_switch_on_arg_type"); - break; - - case _traced_switch_on_sub_arg_type : - sprintf(tmp, "_traced_switch_on_sub_arg_type"); - break; - - case _traced_jump_if_var : - sprintf(tmp, "_traced_jump_if_var"); - break; - - case _traced_jump_if_nonvar : - sprintf(tmp, "_traced_jump_if_nonvar"); - break; - - case _traced_if_not_then : - sprintf(tmp, "_traced_if_not_then"); - break; - - case _traced_switch_on_func : - sprintf(tmp, "_traced_switch_on_func"); - break; - - case _traced_switch_on_cons : - sprintf(tmp, "_traced_switch_on_cons"); - break; - - case _traced_go_on_func : - sprintf(tmp, "_traced_go_on_func"); - break; - - case _traced_go_on_cons : - sprintf(tmp, "_traced_go_on_cons"); - break; - - case _traced_if_func : - sprintf(tmp, "_traced_if_func"); - break; - - case _traced_if_cons : - sprintf(tmp, "_traced_if_cons"); - break; - - case _traced_index_dbref : - sprintf(tmp, "_traced_index_dbref"); - break; - - case _traced_index_blob : - sprintf(tmp, "_traced_index_blob"); - break; - - case _traced_index_long : - sprintf(tmp, "_traced_index_long"); - break; - - case _traced_jit_handler : - sprintf(tmp, "_traced_jit_handler"); - break; - - case _traced_p_atom_x : - sprintf(tmp, "_traced_p_atom_x"); - break; - - case _traced_p_atom_y : - sprintf(tmp, "_traced_p_atom_y"); - break; - - case _traced_p_atomic_x : - sprintf(tmp, "_traced_p_atomic_x"); - break; - - case _traced_p_atomic_y : - sprintf(tmp, "_traced_p_atomic_y"); - break; - - case _traced_p_integer_x : - sprintf(tmp, "_traced_p_integer_x"); - break; - - case _traced_p_integer_y : - sprintf(tmp, "_traced_p_integer_y"); - break; - - case _traced_p_nonvar_x : - sprintf(tmp, "_traced_p_nonvar_x"); - break; - - case _traced_p_nonvar_y : - sprintf(tmp, "_traced_p_nonvar_y"); - break; - - case _traced_p_number_x : - sprintf(tmp, "_traced_p_number_x"); - break; - - case _traced_p_number_y : - sprintf(tmp, "_traced_p_number_y"); - break; - - case _traced_p_var_x : - sprintf(tmp, "_traced_p_var_x"); - break; - - case _traced_p_var_y : - sprintf(tmp, "_traced_p_var_y"); - break; - - case _traced_p_db_ref_x : - sprintf(tmp, "_traced_p_db_ref_x"); - break; - - case _traced_p_db_ref_y : - sprintf(tmp, "_traced_p_db_ref_y"); - break; - - case _traced_p_primitive_x : - sprintf(tmp, "_traced_p_primitive_x"); - break; - - case _traced_p_primitive_y : - sprintf(tmp, "_traced_p_primitive_y"); - break; - - case _traced_p_compound_x : - sprintf(tmp, "_traced_p_compound_x"); - break; - - case _traced_p_compound_y : - sprintf(tmp, "_traced_p_compound_y"); - break; - - case _traced_p_float_x : - sprintf(tmp, "_traced_p_float_x"); - break; - - case _traced_p_float_y : - sprintf(tmp, "_traced_p_float_y"); - break; - - case _traced_p_plus_vv : - sprintf(tmp, "_traced_p_plus_vv"); - break; - - case _traced_p_plus_vc : - sprintf(tmp, "_traced_p_plus_vc"); - break; - - case _traced_p_plus_y_vv : - sprintf(tmp, "_traced_p_plus_y_vv"); - break; - - case _traced_p_plus_y_vc : - sprintf(tmp, "_traced_p_plus_y_vc"); - break; - - case _traced_p_minus_vv : - sprintf(tmp, "_traced_p_minus_vv"); - break; - - case _traced_p_minus_cv : - sprintf(tmp, "_traced_p_minus_cv"); - break; - - case _traced_p_minus_y_vv : - sprintf(tmp, "_traced_p_minus_y_vv"); - break; - - case _traced_p_minus_y_cv : - sprintf(tmp, "_traced_p_minus_y_cv"); - break; - - case _traced_p_times_vv : - sprintf(tmp, "_traced_p_times_vv"); - break; - - case _traced_p_times_vc : - sprintf(tmp, "_traced_p_times_vc"); - break; - - case _traced_p_times_y_vv : - sprintf(tmp, "_traced_p_times_y_vv"); - break; - - case _traced_p_times_y_vc : - sprintf(tmp, "_traced_p_times_y_vc"); - break; - - case _traced_p_div_vv : - sprintf(tmp, "_traced_p_div_vv"); - break; - - case _traced_p_div_vc : - sprintf(tmp, "_traced_p_div_vc"); - break; - - case _traced_p_div_cv : - sprintf(tmp, "_traced_p_div_cv"); - break; - - case _traced_p_div_y_vv : - sprintf(tmp, "_traced_p_div_y_vv"); - break; - - case _traced_p_div_y_vc : - sprintf(tmp, "_traced_p_div_y_vc"); - break; - - case _traced_p_div_y_cv : - sprintf(tmp, "_traced_p_div_y_cv"); - break; - - case _traced_p_and_vv : - sprintf(tmp, "_traced_p_and_vv"); - break; - - case _traced_p_and_vc : - sprintf(tmp, "_traced_p_and_vc"); - break; - - case _traced_p_and_y_vv : - sprintf(tmp, "_traced_p_and_y_vv"); - break; - - case _traced_p_and_y_vc : - sprintf(tmp, "_traced_p_and_y_vc"); - break; - - case _traced_p_or_vv : - sprintf(tmp, "_traced_p_or_vv"); - break; - - case _traced_p_or_vc : - sprintf(tmp, "_traced_p_or_vc"); - break; - - case _traced_p_or_y_vv : - sprintf(tmp, "_traced_p_or_y_vv"); - break; - - case _traced_p_or_y_vc : - sprintf(tmp, "_traced_p_or_y_vc"); - break; - - case _traced_p_sll_vv : - sprintf(tmp, "_traced_p_sll_vv"); - break; - - case _traced_p_sll_vc : - sprintf(tmp, "_traced_p_sll_vc"); - break; - - case _traced_p_sll_cv : - sprintf(tmp, "_traced_p_sll_cv"); - break; - - case _traced_p_sll_y_vv : - sprintf(tmp, "_traced_p_sll_y_vv"); - break; - - case _traced_p_sll_y_vc : - sprintf(tmp, "_traced_p_sll_y_vc"); - break; - - case _traced_p_sll_y_cv : - sprintf(tmp, "_traced_p_sll_y_cv"); - break; - - case _traced_p_slr_vv : - sprintf(tmp, "_traced_p_slr_vv"); - break; - - case _traced_p_slr_vc : - sprintf(tmp, "_traced_p_slr_vc"); - break; - - case _traced_p_slr_cv : - sprintf(tmp, "_traced_p_slr_cv"); - break; - - case _traced_p_slr_y_vv : - sprintf(tmp, "_traced_p_slr_y_vv"); - break; - - case _traced_p_slr_y_vc : - sprintf(tmp, "_traced_p_slr_y_vc"); - break; - - case _traced_p_slr_y_cv : - sprintf(tmp, "_traced_p_slr_y_cv"); - break; - - case _traced_call_bfunc_xx : - sprintf(tmp, "_traced_call_bfunc_xx"); - break; - - case _traced_call_bfunc_yx : - sprintf(tmp, "_traced_call_bfunc_yx"); - break; - - case _traced_call_bfunc_xy : - sprintf(tmp, "_traced_call_bfunc_xy"); - break; - - case _traced_call_bfunc_yy : - sprintf(tmp, "_traced_call_bfunc_yy"); - break; - - case _traced_p_equal : - sprintf(tmp, "_traced_p_equal"); - break; - - case _traced_p_dif : - sprintf(tmp, "_traced_p_dif"); - break; - - case _traced_p_eq : - sprintf(tmp, "_traced_p_eq"); - break; - - case _traced_p_arg_vv : - sprintf(tmp, "_traced_p_arg_vv"); - break; - - case _traced_p_arg_cv : - sprintf(tmp, "_traced_p_arg_cv"); - break; - - case _traced_p_arg_y_vv : - sprintf(tmp, "_traced_p_arg_y_vv"); - break; - - case _traced_p_arg_y_cv : - sprintf(tmp, "_traced_p_arg_y_cv"); - break; - - case _traced_p_func2s_vv : - sprintf(tmp, "_traced_p_func2s_vv"); - break; - - case _traced_p_func2s_cv : - sprintf(tmp, "_traced_p_func2s_cv"); - break; - - case _traced_p_func2s_vc : - sprintf(tmp, "_traced_p_func2s_vc"); - break; - - case _traced_p_func2s_y_vv : - sprintf(tmp, "_traced_p_func2s_y_vv"); - break; - - case _traced_p_func2s_y_cv : - sprintf(tmp, "_traced_p_func2s_y_cv"); - break; - - case _traced_p_func2s_y_vc : - sprintf(tmp, "_traced_p_func2s_y_vc"); - break; - - case _traced_p_func2f_xx : - sprintf(tmp, "_traced_p_func2f_xx"); - break; - - case _traced_p_func2f_xy : - sprintf(tmp, "_traced_p_func2f_xy"); - break; - - case _traced_p_func2f_yx : - sprintf(tmp, "_traced_p_func2f_yx"); - break; - - case _traced_p_func2f_yy : - sprintf(tmp, "_traced_p_func2f_yy"); - break; - - case _traced_p_functor : - sprintf(tmp, "_traced_p_functor"); - break; - - case _traced_p_execute2 : - sprintf(tmp, "_traced_p_execute2"); - break; - - case _traced_p_execute : - sprintf(tmp, "_traced_p_execute"); - break; - - case _traced_p_execute_tail : - sprintf(tmp, "_traced_p_execute_tail"); - break; - -#ifdef YAPOR - case _traced_getwork_first_time : - sprintf(tmp, "_traced_getwork_first_time"); - break; - - case _traced_getwork : - sprintf(tmp, "_traced_getwork"); - break; - - case _traced_getwork_seq : - sprintf(tmp, "_traced_getwork_seq"); - break; - - case _traced_sync : - sprintf(tmp, "_traced_sync"); - break; - -#endif -#ifdef TABLING -#ifdef TABLING_INNER_CUTS - case _traced_clause_with_cut : - sprintf(tmp, "_traced_clause_with_cut"); - break; - -#endif - case _traced_table_load_answer : - sprintf(tmp, "_traced_table_load_answer"); - break; - - case _traced_table_try_answer : - sprintf(tmp, "_traced_table_try_answer"); - break; - - case _traced_table_try_single : - sprintf(tmp, "_traced_table_try_single"); - break; - - case _traced_table_try_me : - sprintf(tmp, "_traced_table_try_me"); - break; - - case _traced_table_try : - sprintf(tmp, "_traced_table_try"); - break; - - case _traced_table_retry_me : - sprintf(tmp, "_traced_table_retry_me"); - break; - - case _traced_table_retry : - sprintf(tmp, "_traced_table_retry"); - break; - - case _traced_table_trust_me : - sprintf(tmp, "_traced_table_trust_me"); - break; - - case _traced_table_trust : - sprintf(tmp, "_traced_table_trust"); - break; - - case _traced_table_new_answer : - sprintf(tmp, "_traced_table_new_answer"); - break; - - case _traced_table_answer_resolution : - sprintf(tmp, "_traced_table_answer_resolution"); - break; - - case _traced_table_completion : - sprintf(tmp, "_traced_table_completion"); - break; - -#ifdef THREADS_CONSUMER_SHARING - case _traced_table_answer_resolution_completion: - sprintf(tmp, "_traced_table_answer_resolution_completion"); - break; - -#endif - case _traced_trie_do_var : - sprintf(tmp, "_traced_trie_do_var"); - break; - - case _traced_trie_trust_var : - sprintf(tmp, "_traced_trie_trust_var"); - break; - - case _traced_trie_try_var : - sprintf(tmp, "_traced_trie_try_var"); - break; - - case _traced_trie_retry_var : - sprintf(tmp, "_traced_trie_retry_var"); - break; - - case _traced_trie_do_var_in_pair : - sprintf(tmp, "_traced_trie_do_var_in_pair"); - break; - - case _traced_trie_trust_var_in_pair : - sprintf(tmp, "_traced_trie_trust_var_in_pair"); - break; - - case _traced_trie_try_var_in_pair : - sprintf(tmp, "_traced_trie_try_var_in_pair"); - break; - - case _traced_trie_retry_var_in_pair : - sprintf(tmp, "_traced_trie_retry_var_in_pair"); - break; - - case _traced_trie_do_val : - sprintf(tmp, "_traced_trie_do_val"); - break; - - case _traced_trie_trust_val : - sprintf(tmp, "_traced_trie_trust_val"); - break; - - case _traced_trie_try_val : - sprintf(tmp, "_traced_trie_try_val"); - break; - - case _traced_trie_retry_val : - sprintf(tmp, "_traced_trie_retry_val"); - break; - - case _traced_trie_do_val_in_pair : - sprintf(tmp, "_traced_trie_do_val_in_pair"); - break; - - case _traced_trie_trust_val_in_pair : - sprintf(tmp, "_traced_trie_trust_val_in_pair"); - break; - - case _traced_trie_try_val_in_pair : - sprintf(tmp, "_traced_trie_try_val_in_pair"); - break; - - case _traced_trie_retry_val_in_pair : - sprintf(tmp, "_traced_trie_retry_val_in_pair"); - break; - - case _traced_trie_do_atom : - sprintf(tmp, "_traced_trie_do_atom"); - break; - - case _traced_trie_trust_atom : - sprintf(tmp, "_traced_trie_trust_atom"); - break; - - case _traced_trie_try_atom : - sprintf(tmp, "_traced_trie_try_atom"); - break; - - case _traced_trie_retry_atom : - sprintf(tmp, "_traced_trie_retry_atom"); - break; - - case _traced_trie_do_atom_in_pair : - sprintf(tmp, "_traced_trie_do_atom_in_pair"); - break; - - case _traced_trie_trust_atom_in_pair : - sprintf(tmp, "_traced_trie_trust_atom_in_pair"); - break; - - case _traced_trie_try_atom_in_pair : - sprintf(tmp, "_traced_trie_try_atom_in_pair"); - break; - - case _traced_trie_retry_atom_in_pair : - sprintf(tmp, "_traced_trie_retry_atom_in_pair"); - break; - - case _traced_trie_do_null : - sprintf(tmp, "_traced_trie_do_null"); - break; - - case _traced_trie_trust_null : - sprintf(tmp, "_traced_trie_trust_null"); - break; - - case _traced_trie_try_null : - sprintf(tmp, "_traced_trie_try_null"); - break; - - case _traced_trie_retry_null : - sprintf(tmp, "_traced_trie_retry_null"); - break; - - case _traced_trie_do_null_in_pair : - sprintf(tmp, "_traced_trie_do_null_in_pair"); - break; - - case _traced_trie_trust_null_in_pair : - sprintf(tmp, "_traced_trie_trust_null_in_pair"); - break; - - case _traced_trie_try_null_in_pair : - sprintf(tmp, "_traced_tri_try_null_in_paire"); - break; - - case _traced_trie_retry_null_in_pair : - sprintf(tmp, "_traced_trie_retry_null_in_pair"); - break; - - case _traced_trie_do_pair : - sprintf(tmp, "_traced_trie_do_pair"); - break; - - case _traced_trie_trust_pair : - sprintf(tmp, "_traced_trie_trust_pair"); - break; - - case _traced_trie_try_pair : - sprintf(tmp, "_traced_trie_try_pair"); - break; - - case _traced_trie_retry_pair : - sprintf(tmp, "_traced_trie_retry_pair"); - break; - - case _traced_trie_do_appl : - sprintf(tmp, "_traced_trie_do_appl"); - break; - - case _traced_trie_trust_appl : - sprintf(tmp, "_traced_trie_trust_appl"); - break; - - case _traced_trie_try_appl : - sprintf(tmp, "_traced_trie_try_appl"); - break; - - case _traced_trie_retry_appl : - sprintf(tmp, "_traced_trie_retry_appl"); - break; - - case _traced_trie_do_appl_in_pair : - sprintf(tmp, "_traced_trie_do_appl_in_pair"); - break; - - case _traced_trie_trust_appl_in_pair : - sprintf(tmp, "_traced_trie_trust_appl_in_pair"); - break; - - case _traced_trie_try_appl_in_pair : - sprintf(tmp, "_traced_trie_trty_appkl_in_pair"); - break; - - case _traced_trie_retry_appl_in_pair : - sprintf(tmp, "_traced_trie_retry_appl_in_pair"); - break; - - case _traced_trie_do_extension : - sprintf(tmp, "_traced_trie_do_extension"); - break; - - case _traced_trie_trust_extension : - sprintf(tmp, "_traced_trie_trust_extension"); - break; - - case _traced_trie_try_extension : - sprintf(tmp, "_traced_trie_try_extension"); - break; - - case _traced_trie_retry_extension : - sprintf(tmp, "_traced_trie_retry_extension"); - break; - - case _traced_trie_do_double : - sprintf(tmp, "_traced_trie_do_double"); - break; - - case _traced_trie_trust_double : - sprintf(tmp, "_traced_trie_trust_double"); - break; - - case _traced_trie_try_double : - sprintf(tmp, "_traced_trie_try_double"); - break; - - case _traced_trie_retry_double : - sprintf(tmp, "_traced_trie_retry_double"); - break; - - case _traced_trie_do_longint : - sprintf(tmp, "_traced_trie_do_longint"); - break; - - case _traced_trie_trust_longint : - sprintf(tmp, "_traced_trie_trust_longint"); - break; - - case _traced_trie_try_longint : - sprintf(tmp, "_traced_trie_try_longint"); - break; - - case _traced_trie_retry_longint : - sprintf(tmp, "_traced_trie_retry_longint"); - break; - - case _traced_trie_do_gterm : - sprintf(tmp, "_traced_trie_do_gterm"); - break; - - case _traced_trie_trust_gterm : - sprintf(tmp, "_traced_trie_trust_gterm"); - break; - - case _traced_trie_try_gterm : - sprintf(tmp, "_traced_trie_try_gterm"); - break; - - case _traced_trie_retry_gterm : - sprintf(tmp, "_traced_trie_retry_gterm"); - break; - -#endif - /* this instruction is hardwired */ -#ifdef YAPOR - case _traced_or_last : - sprintf(tmp, "_traced_or_last"); - break; - -#else - case _traced_or_last : - sprintf(tmp, "_traced_or_last"); - break; - #endif default: tmp[0] = '\0'; -#endif /* YAP_JIT */ - + } strcpy(out, prepend_term); strcat(out, tmp); diff --git a/JIT/JIT_Init.cpp b/JIT/JIT_Init.cpp new file mode 100644 index 000000000..73f36d312 --- /dev/null +++ b/JIT/JIT_Init.cpp @@ -0,0 +1,58 @@ + +#include "JIT_Compiler.hpp" + +using namespace std; + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wimplicit-function-declaration" + +extern "C" void Yap_InitJitAnalysisPreds(void); +extern "C" void Yap_InitJitTransformPreds(void); +extern "C" void Yap_InitJitCodegenPreds(void); +extern "C" void Yap_InitJitConfigPreds(void); +#if YAP_STAT_PREDS +extern "C" void Yap_InitJitStatisticPreds(void); +#endif +#if YAP_DBG_PREDS +extern "C" void Yap_InitJitDebugPreds(void); +#endif + +// global variables with intercae +extern "C" void* (*Yap_JitCall)(JIT_Compiler* jc, yamop* p); +extern "C" void (* Yap_llvmShutdown)( ) ; +extern "C" Int (* Yap_traced_absmi)( ) ; + +void init_jit(); + +extern "C" void* call_JIT_Compiler(JIT_Compiler* jc, yamop* p) { + return jc->compile(p); } + +extern "C" void shutdown_llvm() { llvm_shutdown(); } + +extern "C" Int traced_absmi(); + +static void +initJit(void) +{ + Yap_InitJitAnalysisPreds(); + Yap_InitJitTransformPreds(); + Yap_InitJitCodegenPreds(); + Yap_InitJitConfigPreds(); +#if YAP_STAT_PREDS + Yap_InitJitStatisticPreds(); +#endif +#if YAP_DBG_PREDS + Yap_InitJitDebugPreds(); +#endif + Yap_JitCall = call_JIT_Compiler; + Yap_llvmShutdown = llvm_shutdown; + Yap_traced_absmi = traced_absmi; +} + +// export JIT as DLL +void +init_jit() { + initJit(); +} +#pragma GCC diagnostic pop + diff --git a/JIT/JIT_interface.cpp b/JIT/JIT_interface.cpp new file mode 100644 index 000000000..250962662 --- /dev/null +++ b/JIT/JIT_interface.cpp @@ -0,0 +1,38 @@ +#if YAP_JIT +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wimplicit-function-declaration" + +typedef void *(*call_jitc_t)(struct JIT_Compiler*, yamop *); + +void *call_JIT_Compiler(struct JIT_Compiler*, yamop *); + +static void +initJit(void) +{ + extern void shutdown_llvm(void); + extern call_jitc_t Yap_JITCall; + + Yap_InitJitAnalysisPreds(); + Yap_InitJitTransformPreds(); + Yap_InitJitCodegenPreds(); + Yap_InitJitConfigPreds(); +#if YAP_STAT_PREDS + Yap_InitJitStatisticPreds(); +#endif +#if YAP_DBG_PREDS + Yap_InitJitDebugPreds(); +#endif + GLOBAL_JIT_finalizer = shutdown_llvm; + Yap_JITCall = call_JIT_Compiler; + Yap_llvmShutdown = llvm_shutdown; + +} + +// export JIT as DLL +void +init_jit(void) { + initJit(); +} +#pragma GCC diagnostic pop +#endif /* YAP_JIT */ + diff --git a/JIT/jit_analysispreds.c b/JIT/jit_analysispreds.c index 39559ce24..e69d96c5a 100644 --- a/JIT/jit_analysispreds.c +++ b/JIT/jit_analysispreds.c @@ -590,7 +590,7 @@ p_analysis_output_file( USES_REGS1 ) #pragma GCC diagnostic pop - void +void Yap_InitJitAnalysisPreds(void) { Yap_InitCPred("disable_analysis_pass", 1, p_disable_analysis_pass, SafePredFlag); diff --git a/JIT/jit_traced.c b/JIT/jit_traced.c new file mode 100644 index 000000000..47f4e11e4 --- /dev/null +++ b/JIT/jit_traced.c @@ -0,0 +1,267 @@ +/************************************************************************* +* * + * Yap Prolog * +* * +* Yap Prolog was developed at NCCUP - Universidade do Porto * +* * +* Copyright L.Damas, V.S.Costa and Universidade do Porto 1985-1997 * +* * +************************************************************************** +* * +* File: jit_traced.c * +* comments: Portable abstract machine interpreter * +* Last rev: $Date: 2008-08-13 01:16:26 $,$Author: vsc $ * +* * +*************************************************************************/ + + +/** + +@file jit_traced.c + +@defgroup JIT_Impl Just-In-Time Compiler Implementation +@ingroup + +We next discuss several issues on trying to make Prolog programs run +fast in YAP. We assume two different programming styles: + ++ Execution of deterministic programs ofte +n +boils down to a recursive loop of the form: + +~~~~~ +loop(Env) :- + do_something(Env,NewEnv), + loop(NewEnv). +~~~~~ + */ + + + +#if YAP_JIT + +#define YAP_TRACED 1 +#define IN_ABSMI_C 1 +#define HAS_CACHE_REGS 1 + +#include "absmi.h" +#include "heapgc.h" + +#include "cut_c.h" + +Int traced_absmi(void); + +#ifdef PUSH_X +#else + +/* keep X as a global variable */ + +Term Yap_XREGS[MaxTemps]; /* 29 */ + +#endif + + +// #include "print_preg.h" +//#include "sprint_op.hpp" +//#include "print_op.hpp" + +static Term +interrupt_pexecute( PredEntry *pen USES_REGS ) { + return 0; +} + +#include "IsGround.h" +#include "yaam_macros.hpp" +#include "fprintblock.h" + +#if YAP_DBG_PREDS +#include "debug_printers.h" +#endif + +// ref to JIT compiler +JIT_Compiler *J; + + +extern NativeContext *NativeArea; +extern IntermediatecodeContext *IntermediatecodeArea; + +extern CELL l; + +CELL nnexec; + +void shutdown_llvm(void); + +short global; +yamop* HEADPREG; +CELL BLOCK; +CELL BLOCKADDRESS; +CELL FAILED; + +#undef SHADOW_P +#undef SHADOW_CP +#undef SHADOW_HB +#undef SHADOW_Y +#undef SHADOW_S + +#undef PREG +#define PREG P + +#undef CPREG +#define CPREG CP + +#undef SREG +#define SREG S + +#undef YREG +#define YREG YENV + +#undef setregs +#define setregs() + +#undef saveregs +#define saveregs() + +#include "arith2.h" + +Int +traced_absmi(void) +{ + CACHE_REGS + + static void *OpAddress[] = + { +#define OPCODE(OP,TYPE) && OP +#include "YapOpcodes.h" +#undef OPCODE +}; + + /* The indexing register so that we will not destroy ARG1 without + * reason */ +#define I_R (XREGS[0]) + + static void *control_labels[] = { &&fail, &&NoStackCut, &&NoStackCommitY, &&NoStackCutE, &&NoStackCutT, &&NoStackEither, &&NoStackExecute, &&NoStackCall, &&NoStackDExecute, &&NoStackDeallocate, &¬railleft, &&NoStackFail, &&NoStackCommitX }; + +#if YAP_STAT_PREDS + struct timeval timstart, timend; +struct rusage rustart, ruend; +#endif +curtrace = NULL; +curpreg = NULL; +globalcurblock = NULL; +ineedredefinedest = 0; +NativeArea = (NativeContext*)malloc(sizeof(NativeContext)); +NativeArea->area.p = NULL; +NativeArea->area.ok = NULL; +NativeArea->area.pc = NULL; +#if YAP_STAT_PREDS +NativeArea->area.nrecomp = NULL; +NativeArea->area.compilation_time = NULL; +NativeArea->area.native_size_bytes = NULL; +NativeArea->area.trace_size_bytes = NULL; +NativeArea->success = NULL; +NativeArea->runs = NULL; +NativeArea->t_runs = NULL; +#endif +NativeArea->n = 0; +IntermediatecodeArea = (IntermediatecodeContext*)malloc(sizeof(IntermediatecodeContext)); +IntermediatecodeArea->area.t = NULL; +IntermediatecodeArea->area.ok = NULL; +IntermediatecodeArea->area.isactive = NULL; +IntermediatecodeArea->area.lastblock = NULL; +#if YAP_STAT_PREDS +IntermediatecodeArea->area.profiling_time = NULL; +#endif +IntermediatecodeArea->n = 0; +nnexec = 0; +l = 0; + + + +setregs(); + +CACHE_A1(); + + reset_absmi: + + SP = SP0; + + /* when we start we are not in write mode */ + + { + op_numbers opcode = _Ystop; + goto critical_lbl; + + nextop_write: + + opcode = Yap_op_from_opcode( PREG->y_u.o.opcw ); + goto op_switch; + + nextop: + + opcode = Yap_op_from_opcode( PREG->opc ); + + op_switch: + + + switch (opcode) { + +#if !OS_HANDLES_TR_OVERFLOW + notrailleft: + /* if we are within indexing code, the system may have to + * update a S */ + { + CELL cut_b; + +#ifdef SHADOW_S + S = SREG; +#endif + /* YREG was pointing to where we were going to build the + * next choice-point. The stack shifter will need to know this + * to move the local stack */ + SET_ASP(YREG, E_CB*sizeof(CELL)); + cut_b = LCL0-(CELL *)(ASP[E_CB]); + saveregs(); + if(!Yap_growtrail (0, false)) { + Yap_NilError(OUT_OF_TRAIL_ERROR,"YAP failed to reserve %ld bytes in growtrail",sizeof(CELL) * K16); + setregs(); + FAIL(); + } + setregs(); +#ifdef SHADOW_S + SREG = S; +#endif + if (SREG == ASP) { + SREG[E_CB] = (CELL)(LCL0-cut_b); + } + } + goto reset_absmi; + +#endif /* OS_HANDLES_TR_OVERFLOW */ + + // move instructions to separate file + // so that they are easier to analyse. +#if YAP_JIT +#include "../C/traced_absmi_insts.h" +#if YAPOR +#include "../OPTYap/traced_or.insts.h" +#endif +#if TABLING +#include "../OPTYap/traced_tab.insts.h" +#include "../OPTYap/traced_tab.tries.insts.h" +#endif +#endif + + default: + saveregs(); + Yap_Error(SYSTEM_ERROR, MkIntegerTerm(opcode), "trying to execute invalid YAAM instruction %d", opcode); + setregs(); + FAIL(); + } + } + + return (0); + +} + +#endif /* YAP_JIT */ + diff --git a/OPTYap/tab.tries.insts.h b/OPTYap/tab.tries.insts.h index d8d32e1cb..4ffde41b4 100644 --- a/OPTYap/tab.tries.insts.h +++ b/OPTYap/tab.tries.insts.h @@ -79,9 +79,7 @@ TOP_STACK -= size; \ memcpy(TOP_STACK, aux_stack, size * sizeof(CELL *)); \ aux_stack = TOP_STACK; \ - } - -/* macros 'store_trie_node', 'restore_trie_node' and 'pop_trie_node' ** + }/* macros 'store_trie_node', 'restore_trie_node' and 'pop_trie_node' ** ** do not include 'set_cut' because trie instructions are cut safe */ #define store_trie_node(AP) \ diff --git a/OPTYap/traced_or.insts.h b/OPTYap/traced_or.insts.h index c282b3ad9..26a7ef25e 100644 --- a/OPTYap/traced_or.insts.h +++ b/OPTYap/traced_or.insts.h @@ -15,14 +15,14 @@ ** Scheduler instructions ** ** -------------------------------- */ -PBOp(traced_getwork_first_time,e) +PBOp(getwork_first_time,e) { printf("Or-parallelism not supported by JIT!!\n"); exit(1); } ENDPBOp(); - PBOp(traced_getwork,Otapl) + PBOp(getwork,Otapl) { printf("Or-parallelism not supported by JIT!!\n"); exit(1); } ENDPBOp(); @@ -30,12 +30,12 @@ PBOp(traced_getwork_first_time,e) /* The idea is to check whether we are the last worker in the node. If we are, we can go ahead, otherwise we should call the scheduler. */ -PBOp(traced_getwork_seq,Otapl) +PBOp(getwork_seq,Otapl) { printf("Or-parallelism not supported by JIT!!\n"); exit(1); } ENDPBOp(); - PBOp(traced_sync,Otapl) + PBOp(sync,Otapl) { printf("Or-parallelism not supported by JIT!!\n"); exit(1); } ENDPBOp(); diff --git a/OPTYap/traced_tab.insts.h b/OPTYap/traced_tab.insts.h index ccd15e04f..a17a5cc7f 100644 --- a/OPTYap/traced_tab.insts.h +++ b/OPTYap/traced_tab.insts.h @@ -11,13 +11,23 @@ ** ** ************************************************************************/ +#define TOP_STACK YENV +#define HEAP_ARITY_ENTRY (0) +#define VARS_ARITY_ENTRY (1 + heap_arity) +#define SUBS_ARITY_ENTRY (1 + heap_arity + 1 + vars_arity) + +/* macros 'HEAP_ENTRY', 'VARS_ENTRY' and 'SUBS_ENTRY' ** +** assume that INDEX starts at 1 (and not at 0 !!!) */ +#define HEAP_ENTRY(INDEX) (HEAP_ARITY_ENTRY + (INDEX)) +#define VARS_ENTRY(INDEX) (VARS_ARITY_ENTRY + 1 + vars_arity - (INDEX)) +#define SUBS_ENTRY(INDEX) (SUBS_ARITY_ENTRY + 1 + subs_arity - (INDEX)) /************************************************************************ ** clause_with_cut ** ************************************************************************/ -Op(traced_clause_with_cut, e) +Op(clause_with_cut, e) { printf("Tabling not supported by JIT!!\n"); exit(1); } ENDOp(); @@ -27,7 +37,7 @@ ENDOp(); ** table_load_answer ** ************************************************************************/ -PBOp(traced_table_load_answer, Otapl) +PBOp(table_load_answer, Otapl) { printf("Or-parallelism not supported by JIT!!\n"); exit(1); } ENDPBOp(); @@ -37,7 +47,7 @@ PBOp(traced_table_load_answer, Otapl) ** table_try_answer ** ************************************************************************/ - PBOp(traced_table_try_answer, Otapl) + PBOp(table_try_answer, Otapl) { printf("Or-parallelism not supported by JIT!!\n"); exit(1); } ENDPBOp(); @@ -47,7 +57,7 @@ PBOp(traced_table_load_answer, Otapl) ** table_try_single ** ************************************************************************/ - PBOp(traced_table_try_single, Otapl) + PBOp(table_try_single, Otapl) { printf("Or-parallelism not supported by JIT!!\n"); exit(1); } ENDPBOp(); @@ -57,7 +67,7 @@ PBOp(traced_table_load_answer, Otapl) ** table_try_me ** ************************************************************************/ - PBOp(traced_table_try_me, Otapl) + PBOp(table_try_me, Otapl) { printf("Or-parallelism not supported by JIT!!\n"); exit(1); } ENDPBOp(); @@ -67,7 +77,7 @@ PBOp(traced_table_load_answer, Otapl) ** table_try ** ************************************************************************/ - PBOp(traced_table_try, Otapl) + PBOp(table_try, Otapl) { printf("Or-parallelism not supported by JIT!!\n"); exit(1); } ENDPBOp(); @@ -78,7 +88,7 @@ PBOp(traced_table_load_answer, Otapl) ** table_retry_me ** ************************************************************************/ - Op(traced_table_retry_me, Otapl) + Op(table_retry_me, Otapl) { printf("Or-parallelism not supported by JIT!!\n"); exit(1); } ENDOp(); @@ -88,7 +98,7 @@ PBOp(traced_table_load_answer, Otapl) ** table_retry ** ************************************************************************/ - Op(traced_table_retry, Otapl) + Op(table_retry, Otapl) { printf("Or-parallelism not supported by JIT!!\n"); exit(1); } ENDOp(); @@ -98,7 +108,7 @@ PBOp(traced_table_load_answer, Otapl) ** table_trust_me ** ************************************************************************/ - Op(traced_table_trust_me, Otapl) + Op(table_trust_me, Otapl) { printf("Or-parallelism not supported by JIT!!\n"); exit(1); } ENDOp(); @@ -108,7 +118,7 @@ PBOp(traced_table_load_answer, Otapl) ** table_trust ** ************************************************************************/ - Op(traced_table_trust, Otapl) + Op(table_trust, Otapl) { printf("Or-parallelism not supported by JIT!!\n"); exit(1); } ENDOp(); @@ -118,7 +128,7 @@ PBOp(traced_table_load_answer, Otapl) ** table_new_answer ** ************************************************************************/ - PBOp(traced_table_new_answer, s) + PBOp(table_new_answer, s) { printf("Or-parallelism not supported by JIT!!\n"); exit(1); } ENDPBOp(); @@ -128,7 +138,7 @@ PBOp(traced_table_load_answer, Otapl) ** table_answer_resolution ** ************************************************************************/ - BOp(traced_table_answer_resolution, Otapl) + BOp(table_answer_resolution, Otapl) { printf("Or-parallelism not supported by JIT!!\n"); exit(1); } ENDBOp(); @@ -138,7 +148,7 @@ PBOp(traced_table_load_answer, Otapl) ** table_completion ** ************************************************************************/ - BOp(traced_table_completion, Otapl) + BOp(table_completion, Otapl) ENDBOp(); @@ -147,7 +157,7 @@ PBOp(traced_table_load_answer, Otapl) ** table_answer_resolution_completion ** ************************************************************************/ - BOp(traced_table_answer_resolution_completion, Otapl) + BOp(table_answer_resolution_completion, Otapl) #ifdef THREADS_CONSUMER_SHARING { printf("Or-parallelism not supported by JIT!!\n"); exit(1); } #endif /* THREADS_CONSUMER_SHARING */ diff --git a/OPTYap/traced_tab.tries.insts.h b/OPTYap/traced_tab.tries.insts.h index 2c8b8437a..8931d7bb6 100644 --- a/OPTYap/traced_tab.tries.insts.h +++ b/OPTYap/traced_tab.tries.insts.h @@ -11,253 +11,645 @@ ** ** ************************************************************************/ +/************************************************************************ + ** Trie instructions: auxiliary stack organization ** + ************************************************************************* + ------------------- + | ha = heap_arity | + ------------------- -- + | heap ptr 1 | | + ------------------- | + | ... | -- heap_arity (0 if in global trie) + ------------------- | + | heap ptr ha | | + ------------------- -- + | va = vars_arity | + ------------------- -- + | var ptr va | | + ------------------- | + | ... | -- vars_arity + ------------------- | + | var ptr 1 | | + ------------------- -- + | sa = subs_arity | + ------------------- -- + | subs ptr sa | | + ------------------- | + | ... | -- subs_arity + ------------------- | + | subs ptr 1 | | + ------------------- -- +************************************************************************/ + + + +/************************************************************************ + ** Trie instructions: macros ** + ************************************************************************/ + +#define TOP_STACK YENV + +#define HEAP_ARITY_ENTRY (0) +#define VARS_ARITY_ENTRY (1 + heap_arity) +#define SUBS_ARITY_ENTRY (1 + heap_arity + 1 + vars_arity) + +/* macros 'HEAP_ENTRY', 'VARS_ENTRY' and 'SUBS_ENTRY' ** +** assume that INDEX starts at 1 (and not at 0 !!!) */ +#define HEAP_ENTRY(INDEX) (HEAP_ARITY_ENTRY + (INDEX)) +#define VARS_ENTRY(INDEX) (VARS_ARITY_ENTRY + 1 + vars_arity - (INDEX)) +#define SUBS_ENTRY(INDEX) (SUBS_ARITY_ENTRY + 1 + subs_arity - (INDEX)) + +#define next_trie_instruction(NODE) \ + PREG = (yamop *) TrNode_child(NODE); \ + PREFETCH_OP(PREG); \ + GONext() + +#define next_instruction(CONDITION, NODE) \ + if (CONDITION) { \ + PREG = (yamop *) TrNode_child(NODE); \ + } else { /* procceed */ \ + PREG = (yamop *) CPREG; \ + TOP_STACK = ENV; \ + } \ + PREFETCH_OP(PREG); \ + GONext() + +#define copy_aux_stack() \ + { int size = 3 + heap_arity + subs_arity + vars_arity; \ + TOP_STACK -= size; \ + memcpy(TOP_STACK, aux_stack, size * sizeof(CELL *)); \ + aux_stack = TOP_STACK; \ + }/* macros 'store_trie_node', 'restore_trie_node' and 'pop_trie_node' ** + ** do not include 'set_cut' because trie instructions are cut safe */ + +#define store_trie_node(AP) \ + { register choiceptr cp; \ + TOP_STACK = (CELL *) (NORM_CP(TOP_STACK) - 1); \ + cp = NORM_CP(TOP_STACK); \ + HBREG = HR; \ + store_yaam_reg_cpdepth(cp); \ + cp->cp_tr = TR; \ + cp->cp_h = HR; \ + cp->cp_b = B; \ + cp->cp_cp = CPREG; \ + cp->cp_ap = (yamop *) AP; \ + cp->cp_env= ENV; \ + B = cp; \ + YAPOR_SET_LOAD(B); \ + SET_BB(B); \ + TABLING_ERROR_CHECKING_STACK; \ + } \ + copy_aux_stack() + +#define restore_trie_node(AP) \ + HR = HBREG = PROTECT_FROZEN_H(B); \ + restore_yaam_reg_cpdepth(B); \ + CPREG = B->cp_cp; \ + ENV = B->cp_env; \ + YAPOR_update_alternative(PREG, (yamop *) AP) \ + B->cp_ap = (yamop *) AP; \ + TOP_STACK = (CELL *) PROTECT_FROZEN_B(B); \ + SET_BB(NORM_CP(TOP_STACK)); \ + copy_aux_stack() + +#define really_pop_trie_node() \ + TOP_STACK = (CELL *) PROTECT_FROZEN_B((B + 1)); \ + HR = PROTECT_FROZEN_H(B); \ + pop_yaam_reg_cpdepth(B); \ + CPREG = B->cp_cp; \ + TABLING_close_alt(B); \ + ENV = B->cp_env; \ + B = B->cp_b; \ + HBREG = PROTECT_FROZEN_H(B); \ + SET_BB(PROTECT_FROZEN_B(B)); \ + if ((choiceptr) TOP_STACK == B_FZ) { \ + copy_aux_stack(); \ + } + +#ifdef YAPOR +#define pop_trie_node() \ + if (SCH_top_shared_cp(B)) { \ + restore_trie_node(NULL); \ + } else { \ + really_pop_trie_node(); \ + } +#else +#define pop_trie_node() \ + really_pop_trie_node() +#endif /* YAPOR */ + + + +/************************************************************************ + ** aux_stack_null_instr ** + ************************************************************************/ + +#define aux_stack_null_instr() \ + next_trie_instruction(node) + + + +/************************************************************************ + ** aux_stack_extension_instr ** + ************************************************************************/ + +#define aux_stack_extension_instr() \ + TOP_STACK = &aux_stack[-2]; \ + TOP_STACK[HEAP_ARITY_ENTRY] = heap_arity + 2; \ + TOP_STACK[HEAP_ENTRY(1)] = TrNode_entry(node); \ + TOP_STACK[HEAP_ENTRY(2)] = 0; /* extension mark */ \ + next_trie_instruction(node) + + + +/************************************************************************ + ** aux_stack_term_(in_pair_)instr ** + ************************************************************************/ + +#define aux_stack_term_instr() \ + if (heap_arity) { \ + Bind_Global((CELL *) aux_stack[HEAP_ENTRY(1)], t); \ + TOP_STACK = &aux_stack[1]; \ + TOP_STACK[HEAP_ARITY_ENTRY] = heap_arity - 1; \ + next_instruction(heap_arity - 1 || subs_arity, node); \ + } else { \ + YapBind((CELL *) aux_stack[SUBS_ENTRY(1)], t); \ + aux_stack[SUBS_ARITY_ENTRY] = subs_arity - 1; \ + next_instruction(subs_arity - 1, node); \ + } + +#define aux_stack_term_in_pair_instr() \ + if (heap_arity) { \ + Bind_Global((CELL *) aux_stack[HEAP_ENTRY(1)], AbsPair(HR)); \ + } else { \ + YapBind((CELL *) aux_stack[SUBS_ENTRY(1)], AbsPair(HR)); \ + aux_stack[SUBS_ARITY_ENTRY] = subs_arity - 1; \ + TOP_STACK = &aux_stack[-1]; \ + TOP_STACK[HEAP_ARITY_ENTRY] = 1; \ + } \ + Bind_Global(HR, TrNode_entry(node)); \ + TOP_STACK[HEAP_ENTRY(1)] = (CELL) (HR + 1); \ + HR += 2; \ + next_trie_instruction(node) + + + +/************************************************************************ + ** aux_stack_(new_)pair_instr ** + ************************************************************************/ + +#define aux_stack_new_pair_instr() /* for term 'CompactPairInit' */ \ + if (heap_arity) { \ + Bind_Global((CELL *) aux_stack[HEAP_ENTRY(1)], AbsPair(HR)); \ + TOP_STACK = &aux_stack[-1]; \ + TOP_STACK[HEAP_ARITY_ENTRY] = heap_arity + 1; \ + } else { \ + YapBind((CELL *) aux_stack[SUBS_ENTRY(1)], AbsPair(HR)); \ + aux_stack[SUBS_ARITY_ENTRY] = subs_arity - 1; \ + TOP_STACK = &aux_stack[-2]; \ + TOP_STACK[HEAP_ARITY_ENTRY] = 2; \ + } \ + TOP_STACK[HEAP_ENTRY(1)] = (CELL) HR; \ + TOP_STACK[HEAP_ENTRY(2)] = (CELL) (HR + 1); \ + HR += 2; \ + next_trie_instruction(node) + +#ifdef TRIE_COMPACT_PAIRS +#define aux_stack_pair_instr() /* for term 'CompactPairEndList' */ \ + if (heap_arity) { \ + Bind_Global((CELL *) aux_stack[HEAP_ENTRY(1)], AbsPair(HR)); \ + } else { \ + YapBind((CELL *) aux_stack[SUBS_ENTRY(1)], AbsPair(HR)); \ + aux_stack[SUBS_ARITY_ENTRY] = subs_arity - 1; \ + TOP_STACK = &aux_stack[-1]; \ + TOP_STACK[HEAP_ARITY_ENTRY] = 1; \ + } \ + TOP_STACK[HEAP_ENTRY(1)] = (CELL) HR; \ + Bind_Global(HR + 1, TermNil); \ + HR += 2; \ + next_trie_instruction(node) +#else +#define aux_stack_pair_instr() \ + aux_stack_new_pair_instr() +#endif /* TRIE_COMPACT_PAIRS */ + + + +/************************************************************************ + ** aux_stack_appl_(in_pair_)instr ** + ************************************************************************/ + +#define aux_stack_appl_instr() \ + if (heap_arity) { \ + Bind_Global((CELL *) aux_stack[HEAP_ENTRY(1)], AbsAppl(HR)); \ + TOP_STACK = &aux_stack[-func_arity + 1]; \ + TOP_STACK[HEAP_ARITY_ENTRY] = heap_arity + func_arity - 1; \ + } else { \ + YapBind((CELL *) aux_stack[SUBS_ENTRY(1)], AbsAppl(HR)); \ + aux_stack[SUBS_ARITY_ENTRY] = subs_arity - 1; \ + TOP_STACK = &aux_stack[-func_arity]; \ + TOP_STACK[HEAP_ARITY_ENTRY] = func_arity; \ + } \ + *HR = (CELL) func; \ + { int i; \ + for (i = 1; i <= func_arity; i++) \ + TOP_STACK[HEAP_ENTRY(i)] = (CELL) (HR + i); \ + } \ + HR += 1 + func_arity; \ + next_trie_instruction(node) + +#define aux_stack_appl_in_pair_instr() \ + if (heap_arity) { \ + Bind_Global((CELL *) aux_stack[HEAP_ENTRY(1)], AbsPair(HR)); \ + TOP_STACK = &aux_stack[-func_arity]; \ + TOP_STACK[HEAP_ARITY_ENTRY] = heap_arity + func_arity; \ + } else { \ + YapBind((CELL *) aux_stack[SUBS_ENTRY(1)], AbsPair(HR)); \ + aux_stack[SUBS_ARITY_ENTRY] = subs_arity - 1; \ + TOP_STACK = &aux_stack[-func_arity - 1]; \ + TOP_STACK[HEAP_ARITY_ENTRY] = func_arity + 1; \ + } \ + TOP_STACK[HEAP_ENTRY(func_arity + 1)] = (CELL) (HR + 1); \ + Bind_Global(HR, AbsAppl(HR + 2)); \ + HR += 2; \ + *HR = (CELL) func; \ + { int i; \ + for (i = 1; i <= func_arity; i++) \ + TOP_STACK[HEAP_ENTRY(i)] = (CELL) (HR + i); \ + } \ + HR += 1 + func_arity; \ + next_trie_instruction(node) + + + +/************************************************************************ + ** aux_stack_var_(in_pair_)instr ** + ************************************************************************/ + +#define aux_stack_var_instr() \ + if (heap_arity) { \ + int i; \ + CELL var = aux_stack[HEAP_ENTRY(1)]; \ + RESET_VARIABLE(var); \ + TOP_STACK[HEAP_ARITY_ENTRY] = heap_arity - 1; \ + for (i = 2; i <= heap_arity; i++) \ + TOP_STACK[HEAP_ENTRY(i - 1)] = aux_stack[HEAP_ENTRY(i)]; \ + aux_stack[VARS_ARITY_ENTRY - 1] = vars_arity + 1; \ + aux_stack[VARS_ENTRY(vars_arity + 1)] = var; \ + next_instruction(heap_arity - 1 || subs_arity, node); \ + } else { \ + CELL var = aux_stack[SUBS_ENTRY(1)]; \ + aux_stack[SUBS_ARITY_ENTRY] = subs_arity - 1; \ + TOP_STACK = &aux_stack[-1]; \ + TOP_STACK[HEAP_ARITY_ENTRY] = 0; \ + aux_stack[VARS_ARITY_ENTRY - 1] = vars_arity + 1; \ + aux_stack[VARS_ENTRY(vars_arity + 1)] = var; \ + next_instruction(subs_arity - 1, node); \ + } + +#define aux_stack_var_in_pair_instr() \ + if (heap_arity) { \ + int i; \ + Bind_Global((CELL *) aux_stack[HEAP_ENTRY(1)], AbsPair(HR)); \ + TOP_STACK = &aux_stack[-1]; \ + TOP_STACK[HEAP_ARITY_ENTRY] = heap_arity; \ + TOP_STACK[HEAP_ENTRY(1)] = (CELL) (HR + 1); \ + for (i = 2; i <= heap_arity; i++) \ + TOP_STACK[HEAP_ENTRY(i)] = aux_stack[HEAP_ENTRY(i)]; \ + } else { \ + YapBind((CELL *) aux_stack[SUBS_ENTRY(1)], AbsPair(HR)); \ + aux_stack[SUBS_ARITY_ENTRY] = subs_arity - 1; \ + TOP_STACK = &aux_stack[-2]; \ + TOP_STACK[HEAP_ARITY_ENTRY] = 1; \ + TOP_STACK[HEAP_ENTRY(1)] = (CELL) (HR + 1); \ + } \ + aux_stack[VARS_ARITY_ENTRY - 1] = vars_arity + 1; \ + aux_stack[VARS_ENTRY(vars_arity + 1)] = (CELL) HR; \ + RESET_VARIABLE((CELL) HR); \ + HR += 2; \ + next_trie_instruction(node) + + + +/************************************************************************ + ** aux_stack_val_(in_pair_)instr ** + ************************************************************************/ + +#define aux_stack_val_instr() \ + if (heap_arity) { \ + CELL aux_sub, aux_var; \ + aux_sub = aux_stack[HEAP_ENTRY(1)]; \ + aux_var = aux_stack[VARS_ENTRY(var_index + 1)]; \ + if (aux_sub > aux_var) { \ + Bind_Global((CELL *) aux_sub, aux_var); \ + } else { \ + RESET_VARIABLE(aux_sub); \ + Bind_Local((CELL *) aux_var, aux_sub); \ + aux_stack[VARS_ENTRY(var_index + 1)] = aux_sub; \ + } \ + TOP_STACK = &aux_stack[1]; \ + TOP_STACK[HEAP_ARITY_ENTRY] = heap_arity - 1; \ + next_instruction(heap_arity - 1 || subs_arity, node); \ + } else { \ + CELL aux_sub, aux_var; \ + aux_sub = aux_stack[SUBS_ENTRY(1)]; \ + aux_stack[SUBS_ARITY_ENTRY] = subs_arity - 1; \ + aux_var = aux_stack[VARS_ENTRY(var_index + 1)]; \ + if (aux_sub > aux_var) { \ + if ((CELL *) aux_sub <= HR) { \ + Bind_Global((CELL *) aux_sub, aux_var); \ + } else if ((CELL *) aux_var <= HR) { \ + Bind_Local((CELL *) aux_sub, aux_var); \ + } else { \ + Bind_Local((CELL *) aux_var, aux_sub); \ + aux_stack[VARS_ENTRY(var_index + 1)] = aux_sub; \ + } \ + } else { \ + if ((CELL *) aux_var <= HR) { \ + Bind_Global((CELL *) aux_var, aux_sub); \ + aux_stack[VARS_ENTRY(var_index + 1)] = aux_sub; \ + } else if ((CELL *) aux_sub <= HR) { \ + Bind_Local((CELL *) aux_var, aux_sub); \ + aux_stack[VARS_ENTRY(var_index + 1)] = aux_sub; \ + } else { \ + Bind_Local((CELL *) aux_sub, aux_var); \ + } \ + } \ + next_instruction(subs_arity - 1, node); \ + } + +#define aux_stack_val_in_pair_instr() \ + if (heap_arity) { \ + Bind_Global((CELL *) aux_stack[HEAP_ENTRY(1)], AbsPair(HR)); \ + } else { \ + YapBind((CELL *) aux_stack[SUBS_ENTRY(1)], AbsPair(HR)); \ + aux_stack[SUBS_ARITY_ENTRY] = subs_arity - 1; \ + TOP_STACK = &aux_stack[-1]; \ + TOP_STACK[HEAP_ARITY_ENTRY] = 1; \ + } \ + { CELL aux_sub, aux_var; \ + aux_sub = (CELL) HR; \ + aux_var = aux_stack[VARS_ENTRY(var_index + 1)]; \ + if (aux_sub > aux_var) { \ + Bind_Global((CELL *) aux_sub, aux_var); \ + } else { \ + RESET_VARIABLE(aux_sub); \ + Bind_Local((CELL *) aux_var, aux_sub); \ + aux_stack[VARS_ENTRY(var_index + 1)] = aux_sub; \ + } \ + } \ + TOP_STACK[HEAP_ENTRY(1)] = (CELL) (HR + 1); \ + HR += 2; \ + next_trie_instruction(node) + + /************************************************************************ ** Trie instructions ** ************************************************************************/ -PBOp(traced_trie_do_var, e) +PBOp(trie_do_var, e) { printf("Tries not supported by JIT!!\n"); exit(1); } ENDPBOp(); -PBOp(traced_trie_trust_var, e) +PBOp(trie_trust_var, e) { printf("Tries not supported by JIT!!\n"); exit(1); } ENDPBOp(); -PBOp(traced_trie_try_var, e) +PBOp(trie_try_var, e) { printf("Tries not supported by JIT!!\n"); exit(1); } ENDPBOp(); -PBOp(traced_trie_retry_var, e) +PBOp(trie_retry_var, e) { printf("Tries not supported by JIT!!\n"); exit(1); } ENDPBOp(); - PBOp(traced_trie_do_var_in_pair, e) + PBOp(trie_do_var_in_pair, e) { printf("Tries not supported by JIT!!\n"); exit(1); } ENDPBOp(); - PBOp(traced_trie_trust_var_in_pair, e) + PBOp(trie_trust_var_in_pair, e) { printf("Tries not supported by JIT!!\n"); exit(1); } ENDPBOp(); - PBOp(traced_trie_try_var_in_pair, e) + PBOp(trie_try_var_in_pair, e) { printf("Tries not supported by JIT!!\n"); exit(1); } ENDPBOp(); - PBOp(traced_trie_retry_var_in_pair, e) + PBOp(trie_retry_var_in_pair, e) { printf("Tries not supported by JIT!!\n"); exit(1); } ENDPBOp(); - PBOp(traced_trie_do_val, e) + PBOp(trie_do_val, e) { printf("Tries not supported by JIT!!\n"); exit(1); } ENDPBOp(); - PBOp(traced_trie_trust_val, e) + PBOp(trie_trust_val, e) { printf("Tries not supported by JIT!!\n"); exit(1); } ENDPBOp(); - PBOp(traced_trie_try_val, e) + PBOp(trie_try_val, e) { printf("Tries not supported by JIT!!\n"); exit(1); } ENDPBOp(); - PBOp(traced_trie_retry_val, e) + PBOp(trie_retry_val, e) { printf("Tries not supported by JIT!!\n"); exit(1); } ENDPBOp(); - PBOp(traced_trie_do_val_in_pair, e) + PBOp(trie_do_val_in_pair, e) { printf("Tries not supported by JIT!!\n"); exit(1); } ENDPBOp(); - PBOp(traced_trie_trust_val_in_pair, e) + PBOp(trie_trust_val_in_pair, e) { printf("Tries not supported by JIT!!\n"); exit(1); } ENDPBOp(); - PBOp(traced_trie_try_val_in_pair, e) + PBOp(trie_try_val_in_pair, e) { printf("Tries not supported by JIT!!\n"); exit(1); } ENDPBOp(); - PBOp(traced_trie_retry_val_in_pair, e) + PBOp(trie_retry_val_in_pair, e) { printf("Tries not supported by JIT!!\n"); exit(1); } ENDPBOp(); - PBOp(traced_trie_do_atom, e) + PBOp(trie_do_atom, e) { printf("Tries not supported by JIT!!\n"); exit(1); } ENDPBOp(); - PBOp(traced_trie_trust_atom, e) + PBOp(trie_trust_atom, e) { printf("Tries not supported by JIT!!\n"); exit(1); } ENDPBOp(); - PBOp(traced_trie_try_atom, e) + PBOp(trie_try_atom, e) { printf("Tries not supported by JIT!!\n"); exit(1); } ENDPBOp(); - PBOp(traced_trie_retry_atom, e) + PBOp(trie_retry_atom, e) { printf("Tries not supported by JIT!!\n"); exit(1); } ENDPBOp(); - PBOp(traced_trie_do_atom_in_pair, e) + PBOp(trie_do_atom_in_pair, e) { printf("Tries not supported by JIT!!\n"); exit(1); } ENDPBOp(); - PBOp(traced_trie_trust_atom_in_pair, e) + PBOp(trie_trust_atom_in_pair, e) { printf("Tries not supported by JIT!!\n"); exit(1); } ENDPBOp(); - PBOp(traced_trie_try_atom_in_pair, e) + PBOp(trie_try_atom_in_pair, e) { printf("Tries not supported by JIT!!\n"); exit(1); } ENDPBOp(); - PBOp(traced_trie_retry_atom_in_pair, e) + PBOp(trie_retry_atom_in_pair, e) { printf("Tries not supported by JIT!!\n"); exit(1); } ENDPBOp(); - PBOp(traced_trie_do_null, e) + PBOp(trie_do_null, e) { printf("Tries not supported by JIT!!\n"); exit(1); } ENDPBOp(); - PBOp(traced_trie_trust_null, e) + PBOp(trie_trust_null, e) { printf("Tries not supported by JIT!!\n"); exit(1); } ENDPBOp(); - PBOp(traced_trie_try_null, e) + PBOp(trie_try_null, e) { printf("Tries not supported by JIT!!\n"); exit(1); } ENDPBOp(); - PBOp(traced_trie_retry_null, e) + PBOp(trie_retry_null, e) { printf("Tries not supported by JIT!!\n"); exit(1); } ENDPBOp(); - PBOp(traced_trie_do_null_in_pair, e) + PBOp(trie_do_null_in_pair, e) { printf("Tries not supported by JIT!!\n"); exit(1); } ENDPBOp(); - PBOp(traced_trie_trust_null_in_pair, e) + PBOp(trie_trust_null_in_pair, e) { printf("Tries not supported by JIT!!\n"); exit(1); } ENDPBOp(); -PBOp(traced_trie_try_null_in_pair, e) +PBOp(trie_try_null_in_pair, e) { printf("Tries not supported by JIT!!\n"); exit(1); } ENDPBOp(); - PBOp(traced_trie_retry_null_in_pair, e) + PBOp(trie_retry_null_in_pair, e) { printf("Tries not supported by JIT!!\n"); exit(1); } ENDPBOp(); -PBOp(traced_trie_do_pair, e) +PBOp(trie_do_pair, e) { printf("Tries not supported by JIT!!\n"); exit(1); } ENDPBOp(); - PBOp(traced_trie_trust_pair, e) + PBOp(trie_trust_pair, e) { printf("Tries not supported by JIT!!\n"); exit(1); } ENDPBOp(); - PBOp(traced_trie_try_pair, e) + PBOp(trie_try_pair, e) { printf("Tries not supported by JIT!!\n"); exit(1); } ENDPBOp(); - PBOp(traced_trie_retry_pair, e) + PBOp(trie_retry_pair, e) { printf("Tries not supported by JIT!!\n"); exit(1); } ENDPBOp(); - PBOp(traced_trie_do_appl, e) + PBOp(trie_do_appl, e) { printf("Tries not supported by JIT!!\n"); exit(1); } ENDPBOp(); - PBOp(traced_trie_trust_appl, e) + PBOp(trie_trust_appl, e) { printf("Tries not supported by JIT!!\n"); exit(1); } ENDPBOp(); - PBOp(traced_trie_try_appl, e) + PBOp(trie_try_appl, e) { printf("Tries not supported by JIT!!\n"); exit(1); } ENDPBOp(); - PBOp(traced_trie_retry_appl, e) + PBOp(trie_retry_appl, e) { printf("Tries not supported by JIT!!\n"); exit(1); } ENDPBOp(); - PBOp(traced_trie_do_appl_in_pair, e) + PBOp(trie_do_appl_in_pair, e) { printf("Tries not supported by JIT!!\n"); exit(1); } ENDPBOp(); - PBOp(traced_trie_trust_appl_in_pair, e) + PBOp(trie_trust_appl_in_pair, e) { printf("Tries not supported by JIT!!\n"); exit(1); } ENDPBOp(); - PBOp(traced_trie_try_appl_in_pair, e) + PBOp(trie_try_appl_in_pair, e) { printf("Tries not supported by JIT!!\n"); exit(1); } ENDPBOp(); - PBOp(traced_trie_retry_appl_in_pair, e) + PBOp(trie_retry_appl_in_pair, e) { printf("Tries not supported by JIT!!\n"); exit(1); } ENDPBOp(); - PBOp(traced_trie_do_extension, e) + PBOp(trie_do_extension, e) { printf("Tries not supported by JIT!!\n"); exit(1); } ENDPBOp(); - PBOp(traced_trie_trust_extension, e) + PBOp(trie_trust_extension, e) { printf("Tries not supported by JIT!!\n"); exit(1); } ENDPBOp(); - PBOp(traced_trie_try_extension, e) + PBOp(trie_try_extension, e) { printf("Tries not supported by JIT!!\n"); exit(1); } ENDPBOp(); - PBOp(traced_trie_retry_extension, e) + PBOp(trie_retry_extension, e) { printf("Tries not supported by JIT!!\n"); exit(1); } ENDPBOp(); - PBOp(traced_trie_do_double, e) + PBOp(trie_do_double, e) register ans_node_ptr node = (ans_node_ptr) PREG; register CELL *aux_stack = TOP_STACK; int heap_arity = aux_stack[HEAP_ARITY_ENTRY]; @@ -286,22 +678,22 @@ ENDPBOp(); ENDPBOp(); - BOp(traced_trie_trust_double, e) + BOp(trie_trust_double, e) Yap_Error(INTERNAL_ERROR, TermNil, "trie_trust_double: invalid instruction"); ENDBOp(); - BOp(traced_trie_try_double, e) + BOp(trie_try_double, e) Yap_Error(INTERNAL_ERROR, TermNil, "trie_try_double: invalid instruction"); ENDBOp(); - BOp(traced_trie_retry_double, e) + BOp(trie_retry_double, e) Yap_Error(INTERNAL_ERROR, TermNil, "trie_retry_double: invalid instruction"); ENDBOp(); - PBOp(traced_trie_do_longint, e) + PBOp(trie_do_longint, e) register ans_node_ptr node = (ans_node_ptr) PREG; register CELL *aux_stack = TOP_STACK; int heap_arity = aux_stack[HEAP_ARITY_ENTRY]; @@ -317,54 +709,54 @@ ENDPBOp(); ENDPBOp(); - BOp(traced_trie_trust_longint, e) + BOp(trie_trust_longint, e) Yap_Error(INTERNAL_ERROR, TermNil, "trie_trust_longint: invalid instruction"); ENDBOp(); - BOp(traced_trie_try_longint, e) - Yap_Error(INTERNAL_ERROR, TermNil, "traced_trie_try_longint: invalid instruction"); + BOp(trie_try_longint, e) + Yap_Error(INTERNAL_ERROR, TermNil, "trie_try_longint: invalid instruction"); ENDBOp(); - BOp(traced_trie_retry_longint, e) + BOp(trie_retry_longint, e) ENDBOp(); - PBOp(traced_trie_do_bigint, e) - { printf("Traced_Tries not supported by JIT!!\n"); exit(1); } + PBOp(trie_do_bigint, e) + { printf("Tries not supported by JIT!!\n"); exit(1); } ENDPBOp(); - BOp(traced_trie_trust_bigint, e) + BOp(trie_trust_bigint, e) ENDBOp(); - BOp(traced_trie_try_bigint, e) + BOp(trie_try_bigint, e) ENDBOp(); - BOp(traced_trie_retry_bigint, e) + BOp(trie_retry_bigint, e) ENDBOp(); - PBOp(traced_trie_do_gterm, e) + PBOp(trie_do_gterm, e) - { printf("Traced_Tries not supported by JIT!!\n"); exit(1); } + { printf("Tries not supported by JIT!!\n"); exit(1); } ENDPBOp(); - PBOp(traced_trie_trust_gterm, e) - { printf("Traced_Tries not supported by JIT!!\n"); exit(1); } + PBOp(trie_trust_gterm, e) + { printf("Tries not supported by JIT!!\n"); exit(1); } ENDPBOp(); - PBOp(traced_trie_try_gterm, e) - { printf("Traced_Tries not supported by JIT!!\n"); exit(1); } + PBOp(trie_try_gterm, e) + { printf("Tries not supported by JIT!!\n"); exit(1); } ENDPBOp(); - PBOp(traced_trie_retry_gterm, e) - { printf("Traced_Tries not supported by JIT!!\n"); exit(1); } + PBOp(trie_retry_gterm, e) + { printf("Tries not supported by JIT!!\n"); exit(1); } ENDPBOp(); diff --git a/library/rltree/range_list.c b/library/rltree/range_list.c index da15eddfb..abfeb7f7a 100644 --- a/library/rltree/range_list.c +++ b/library/rltree/range_list.c @@ -177,7 +177,7 @@ RL_Tree* set_in_rl(RL_Tree* tree,NUM number,STATUS status) { if ( number >0 && number <=tree->range_max) set_in(number,ROOT(tree),1,ROOT_INTERVAL(tree),tree->range_max,tree,status); #ifdef DEBUG - printf("Setting: %d size=%d\n",number,tree->size); + printf("Setting: %ul size=%ul\n",number,tree->size); #endif /*if (status==IN && !in_rl(tree,number)) { fprintf(stderr,"Error adding %lu to tree: size=%lu max=%lu\n",number,tree->size,tree->range_max); diff --git a/misc/buildops b/misc/buildops index 48323b5f9..ce93d4463 100644 --- a/misc/buildops +++ b/misc/buildops @@ -47,17 +47,17 @@ main :- retractall(op(_,_)), file('OPTYap/tab.tries.insts.h', W, C, L, F, H, S), end_ifdef(W, C, L, F, H, S), - start_ifdef("YAP_JIT", W, C, L, F, H, S), - file('C/traced_absmi_insts.h', W, C, L, F, H, S), - start_ifdef("YAPOR", W, C, L, F, H, S), - file('OPTYap/traced_or.insts.h',W, C, L, F, H, S), - end_ifdef(W, C, L, F, H, S), - start_ifdef("TABLING", W, C, L, F, H, S), - file('OPTYap/traced_tab.insts.h',W,C,L, F, H, S), - retractall(op(_,_)), - file('OPTYap/traced_tab.tries.insts.h', W, C, L, F, H, S), - end_ifdef(W, C, L, F, H, S), - end_ifdef(W, C, L, F, H, S), + %start_ifdef("YAP_JIT", W, C, L, F, H, S), + %file('C/traced_absmi_insts.h', W, C, L, F, H, S), + %start_ifdef("YAPOR", W, C, L, F, H, S), + %file('OPTYap/traced_or.insts.h',W, C, L, F, H, S), + %end_ifdef(W, C, L, F, H, S), + %start_ifdef("TABLING", W, C, L, F, H, S), + %file('OPTYap/traced_tab.insts.h',W,C,L, F, H, S), + %retractall(op(_,_)), + %file('OPTYap/traced_tab.tries.insts.h', W, C, L, F, H, S), + %end_ifdef(W, C, L, F, H, S), + %end_ifdef(W, C, L, F, H, S), footer(W), footer_rclause(C), footer_walk_clause(L), @@ -744,13 +744,6 @@ dump_head_action(logical, _, _, L) :- footer(W) :- format(W,' /* this instruction is hardwired */~n',[]), format(W,' /* or_last must be the last instruction. */~n',[]), - format(W,'#ifdef YAP_JIT~n',[]), - format(W,'#ifdef YAPOR~n',[]), - format(W,' OPCODE(~s~36+,~s),~n',["traced_or_last","sblp"]), - format(W,'#else~n',[]), - format(W,' OPCODE(~s~36+,~s),~n',["traced_or_last","p"]), - format(W,'#endif~n',[]), - format(W,'#endif~n',[]), format(W,'#ifdef YAPOR~n',[]), format(W,' OPCODE(~s~36+,~s),~n',["or_last","sblp"]), format(W,'#else~n',[]), @@ -760,14 +753,6 @@ footer(W) :- footer_rclause(W) :- format(W,' /* this instruction is hardwired */~n',[]), - format(W,'#ifdef YAP_JIT~n',[]), - dump_ops(W,["traced_or_last"]), - format(W,'#ifdef YAPOR~n',[]), - output_typeinfo(W,"Osblp"), - format(W,'#else~n',[]), - output_typeinfo(W,"p"), - format(W,'#endif~n',[]), - format(W,'#endif~n',[]), dump_ops(W,["or_last"]), format(W,'#ifdef YAPOR~n',[]), output_typeinfo(W,"Osblp"), @@ -781,15 +766,7 @@ footer_rclause(W) :- footer_walk_clause(W) :- format(W,' /* this instruction is hardwired */~n',[]), - format(W,'#ifdef YAP_JIT~n',[]), - dump_ops(W,["traced_or_last"]), - format(W,'#ifdef YAPOR~n',[]), - add_pp(W,"Osblp","p0"), - format(W,'#else~n',[]), - add_pp(W,"p","p"), - format(W,'#endif~n',[]), - format(W,'#endif~n',[]), - dump_ops(W,["or_last"]), + dump_ops(W,["or_last"]), format(W,'#ifdef YAPOR~n',[]), add_pp(W,"Osblp","p0"), format(W,'#else~n',[]), From 4dd8ee803fd65afa0e2d579b80167ba9d55bfccf Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?V=C3=ADtor=20Santos=20Costa?= Date: Sat, 7 Feb 2015 01:08:32 +0000 Subject: [PATCH 6/9] fix bad JIT ifdefs --- C/absmi.c | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/C/absmi.c b/C/absmi.c index bb5e39502..df400e4cc 100755 --- a/C/absmi.c +++ b/C/absmi.c @@ -1684,8 +1684,10 @@ Yap_absmi(int inp) #if USE_THREADED_CODE /* absmadr */ if (inp > 0) { - Yap_ABSMI_OPCODES = OpAddress; - Yap_ABSMI_ControlLabels = control_labels; + Yap_ABSMI_OPCODES = OpAddress; +#if YAP_JIT + Yap_ABSMI_ControlLabels = control_labels; +#endif #if BP_FREE P1REG = PCBACKUP; #endif From bdcd06cf042a3e9a79771bb31a2d1f146a24e819 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?V=C3=ADtor=20Santos=20Costa?= Date: Sat, 7 Feb 2015 01:11:52 +0000 Subject: [PATCH 7/9] enable swig --- packages/swig/Makefile.in | 13 +++++++------ packages/swig/yap.i | 4 ++-- 2 files changed, 9 insertions(+), 8 deletions(-) diff --git a/packages/swig/Makefile.in b/packages/swig/Makefile.in index 0ea480b25..5474f1cd1 100644 --- a/packages/swig/Makefile.in +++ b/packages/swig/Makefile.in @@ -2,6 +2,7 @@ PACKAGE=swig DOC=swig PKGCFLAGS= SWIG=@SWIG@ +LIBS=@LIBS@ JAVAC=@JAVAC@ JAR=@JAR@ include ../Makefile.defs @@ -64,7 +65,7 @@ jni/yap_wrap.cpp java/yap.java: $(srcdir)/yap.i jni/yap_wrap.o: jni/yap_wrap.cpp $(CXX) -c @SHLIB_CXXFLAGS@ $(CXXFLAGS) @JPLCFLAGS@ $< -o $@ - + # depends on make install on top-level # also, should have an android device running, say # emulator -avd first & @@ -74,13 +75,13 @@ jni/yap_wrap.o: jni/yap_wrap.cpp # # android: JavaYap-debug.apk - + JavaYap-debug.apk: android/libs/armeabi/libexample.so ( cd android && ant debug ) - + android/libs/armeabi/libexample.so: android/jni/Android.mk android/jni/Application.mk android/jni/yap_wrap.cpp ( cd android/jni && NDK_DEBUG=1 ndk-build ) - + android/jni/Application.mk: android/jni/Android.mk cp $(srcdir)/android/jni/Application.mk android/jni @@ -93,7 +94,7 @@ android/jni/Android.mk: android/AndroidManifest.xml cp -r $(JNI_SQLITE) android/jni cp -r $(JAVA_SQLITE) android/src cp Android.mk android/jni - + android/AndroidManifest.xml: $(ANDROID_PKG) android create project --target 1 --name JavaYap --path ./android --activity JavaYap --package pt.up.fc.dcc.yap mkdir -p android/assets @@ -102,7 +103,7 @@ android/AndroidManifest.xml: $(ANDROID_PKG) mkdir -p android/assets/lib mkdir -p android/assets/lib/Yap mkdir -p android/jni - + android/jni/yap_wrap.cpp: $(srcdir)/yap.i $(srcdir)/../../CXX/yapi.hh $(srcdir)/../../CXX/yapi.cpp android/AndroidManifest.xml $(SWIG) -c++ -java -I$(srcdir)/../../CXX -package pt.up.fc.dcc.yap -outdir android/src/pt/up/fc/dcc/yap -o android/jni/yap_wrap.cpp $< diff --git a/packages/swig/yap.i b/packages/swig/yap.i index 723ce6a0b..7b2ca1da5 100644 --- a/packages/swig/yap.i +++ b/packages/swig/yap.i @@ -46,10 +46,10 @@ #define YAP_CPP_INTERFACE 1 -extern "C" { - #include "yapi.hh" + extern "C" { + extern Term Yap_StringToTerm(const char *s, size_t len, term_t bindings); #if THREADS From a8a63a31ca5c6a1ff20b2be120acc46daae0c5c5 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?V=C3=ADtor=20Santos=20Costa?= Date: Mon, 9 Feb 2015 01:52:10 +0000 Subject: [PATCH 8/9] improv C++ interface. --- CXX/yapa.hh | 96 ++++++++++ CXX/yapdb.hh | 318 +++++++++++++++++++++++++++++++ CXX/yapi.cpp | 240 ++++++++++++++++-------- CXX/yapi.hh | 513 +-------------------------------------------------- CXX/yapq.hh | 127 +++++++++++++ CXX/yapt.hh | 202 ++++++++++++++++++++ 6 files changed, 912 insertions(+), 584 deletions(-) create mode 100644 CXX/yapa.hh create mode 100644 CXX/yapdb.hh create mode 100644 CXX/yapq.hh create mode 100644 CXX/yapt.hh diff --git a/CXX/yapa.hh b/CXX/yapa.hh new file mode 100644 index 000000000..a4660cfb0 --- /dev/null +++ b/CXX/yapa.hh @@ -0,0 +1,96 @@ +#ifndef YAPA_HH +#define YAPA_HH 1 + +/** + Prolog operates over constants, called atoms + YAP, like lisp, associates properties with atoms. +*/ +enum PropTag { + /// predicate + PRED_TAG = PEProp, // 0x0000, + /// db key, may be associated with a functor + DB_TAG = DBProperty, // 0x8000, + /// generic functor, may include sub-properties + FUNCTOR_TAG = FunctorProperty, // 0xBB00, + // SPARSE_FUNCTOR_TAG = 0xFFDF, + /// arithmetic function + ARITHMETIC_PROPERTY_TAG = ExpProperty, // 0xFFE3, + /// map the atom to an integer + TRANSLATION_TAG = TranslationProperty, // 0xFFF4, + /// SWI-STYLE ATOM Extension + BLOB_TAG = BlobProperty, // 0xFFF5, + /// named mutEX + MUTEX_TAG = MutexProperty, // 0xFFF6, + /// A typed array, may be in-db or in-stack deped + ARRAY_TAG = ArrayProperty, // 0xFFF7, + /// atom does not fit ISO-LATIN-1 + WIDE_TAG = WideAtomProperty, // 0xFFF8, + /// module + MODULE_TAG = ModProperty, // 0xFFFA, + /// the original SICStus blackboard + BLACKBOARD_TAG = BBProperty, // 0xFFFB, + /// asociate an atomic value with the atom + VALUE_TAG = ValProperty, // 0xFFFC, + /// Demoen's proposal for gkobal variables + GLOBAL_VAR_TAG = GlobalProperty, // 0xFFFD + /// ensure the atom may not be garbafe colected + HOLD_TAG = HoldProperty, // 0xFFF + /// Prolog operator, + OPERATOR_TAG = OpProperty, // 0xFFFF, + }; + +/** + * @brief Atom + * A YAP data-base is a collection of atoms, where each atom has a name + * and a set of Properties. Examples of properties include functors, + * predicates, operators, modules, almost everything. + * + */ +class YAPAtom { + friend class YAPModuleProp; + friend class YAPPredicate; + friend class YAPFunctor; + friend class YAPAtomTerm; + friend class YAProp; + friend class YAPModule; + Atom a; + /// construct new YAPAtom from Atom + YAPAtom( Atom at ) { a = at; } +public: + /// construct new YAPAtom from string + YAPAtom( const char * s) { a = Yap_LookupAtom( s ); } + /// construct new YAPAtom from wide string +YAPAtom( const wchar_t * s) { a = Yap_LookupMaybeWideAtom( s ); } + /// construct new YAPAtom from max-length string +YAPAtom( const char * s, size_t len) { a = Yap_LookupAtomWithLength( s, len ); } + /// construct new YAPAtom from max-length wide string + YAPAtom( const wchar_t * s, size_t len) { a = Yap_LookupMaybeWideAtomWithLength( s, len ); } + /// get name of atom + char *getName(void); + /// get prop of type + Prop getProp( PropTag tag ) { return Yap_GetAProp( a , (PropFlags)tag ); } +}; + +/** + * @brief Prop + * A YAP Propery is ameta-class for everything one can in a atom. + * Examples of properties include functors, + * predicates, operators, modules, almost everything. + * + */ +class YAPProp { + friend class YAPModuleProp; + friend class YAPFunctor; + /// does nothing, p is defined by the subclass + YAPProp() { } + /// get type of prop + PropTag tag( Prop p ) { return (PropTag)(p->KindOfPE); } +public: + /// get name of property + virtual YAPAtom name() = 0; +virtual ~YAPProp() {}; + +}; + + +#endif /* YAPA_HH */ diff --git a/CXX/yapdb.hh b/CXX/yapdb.hh new file mode 100644 index 000000000..f028c97ec --- /dev/null +++ b/CXX/yapdb.hh @@ -0,0 +1,318 @@ + +#define YAP_CPP_DB_INTERFACE 1 + +//! @{ + +/** + * + * @defgroup yap-cplus-db-interface Data-Base Component of YAP interface. + * + * @ingroup yap-cplus-interface + * @tableofcontents + * + * + * Data-base component of C++ interface to YAP. It manipulates sets of + * atoms, each one containing a number of props. + */ + +class YAPTerm; + +class YAPError; + +class YAPModule; + +extern "C" { + static inline Term + Yap_CurrentModule( void ) + { + CACHE_REGS + return CurrentModule; + } +} + +/** + * @brief YAPModule + * A YAPModule describes a bare module, which in YAP is just a name. + * + * Info about the module is in YAPModuleProp + * + */ +class YAPModule : protected YAPAtomTerm { + friend class YAPPredicate; + YAPModule( Term t ): YAPAtomTerm( t ) {}; + Term t() { return gt(); } +public: + ~YAPModule( ) {}; + YAPModule( ): YAPAtomTerm( Yap_CurrentModule() ) {}; + YAPModule( YAPAtom t ): YAPAtomTerm( t ) {}; +}; + +/** + * @brief YAPModuleProp + * A YAPModuleProp controls access to a module property. + * + */ +class YAPModuleProp: public YAPProp { + friend class YAPPredicate; + ModEntry *m; + + YAPModuleProp(ModEntry *mod) {m = mod;}; + YAPModuleProp(Term tmod) { m = Yap_GetModuleEntry(tmod); }; +public: + YAPModuleProp() { m = Yap_GetModuleEntry(Yap_CurrentModule()); }; + YAPModuleProp(YAPModule tmod) ; + virtual YAPModule module() { return YAPModule(m->AtomOfME); }; +}; + +/** + * @brief YAPFunctor represents Prolog functors Name/Arity + */ + class YAPFunctor: public YAPProp { + friend class YAPApplTerm; + friend class YAPPredicate; + Functor f; + /// Constructor: receives Prolog functor and casts it to YAPFunctor + /// + /// Notice that this is designed for internal use only. + YAPFunctor( Functor ff) { f = ff; } + public: + ~YAPFunctor( ) { }; + /// Constructor: receives name as a string plus arity + /// + /// Notice that this is designed for ISO-LATIN-1 right now + YAPFunctor( char * s, arity_t arity) { f = Yap_MkFunctor( Yap_LookupAtom( s ), arity ); } + /// Constructor: receives name as a wide string plus arity + /// + /// Notice that this is designed for UNICODE right now + YAPFunctor( wchar_t * s, arity_t arity) { f = Yap_MkFunctor( Yap_LookupWideAtom( s ), arity ) ; } + /// Constructor: receives name as an atom, plus arity + /// + /// This is the default method, and the most popi;at + YAPFunctor( YAPAtom at, arity_t arity) { f = Yap_MkFunctor( at.a, arity ); } + + /// Getter: extract name of functor as an atom + /// + /// this is for external usage. + YAPAtom name(void) { + return YAPAtom( NameOfFunctor( f ) ); + } + + /// Getter: extract arity of functor as an unsigned integer + /// + /// this is for external usage. + arity_t arity(void) { + return ArityOfFunctor( f ); + } + + }; + +/** + * @brief Predicates + * + * This class interfaces with PredEntry in Yatom. + */ +class YAPPredicate: public YAPModuleProp { + friend class YAPQuery; + +protected: + PredEntry *ap; + + /// auxiliary routine to find a predicate in the current module. + PredEntry *getPred( Term t, Term* &outp ) ; + + /// String constructor for predicates + /// + /// It also communicates the array of arguments t[] + /// and the array of variables + /// back to yapquery + YAPPredicate(const char *s, Term* &out, Term& vnames ) throw (int); + + /// Term constructor for predicates + /// + /// It is just a call to getPred + inline YAPPredicate(Term t) { + CELL * v = NULL; + ap = getPred( t , v ); + } + + /// Cast constructor for predicates, + /// if we have the implementation data. + /// + inline YAPPredicate(PredEntry *pe) { + ap = pe; + } + +public: + ~YAPPredicate() {}; + + /// Functor constructor for predicates + /// + /// Asssumes that we use the current module. + YAPPredicate(YAPFunctor f) { + ap = RepPredProp(PredPropByFunc(f.f,Yap_CurrentModule())); + }; + + /// Functor constructor for predicates, is given a specific module. + /// + inline YAPPredicate(YAPFunctor f, YAPTerm mod) { + ap = RepPredProp(PredPropByFunc(f.f,mod.t)); + } + + /// Name/arity constructor for predicates. + /// + inline YAPPredicate(YAPAtom at, YAPTerm mod) { + ap = RepPredProp(PredPropByAtom(at.a,mod.t)); + } + + + /// Name/0 constructor for predicates. + /// + YAPPredicate(YAPAtom at); + + /// Mod:Name/Arity constructor for predicates. + /// + inline YAPPredicate(YAPAtom at, arity_t arity, YAPModule mod) { + if (arity) { + Functor f = Yap_MkFunctor(at.a, arity); + ap = RepPredProp(PredPropByFunc(f,mod.t())); + } else { + ap = RepPredProp(PredPropByAtom(at.a,mod.t())); + } + } + + /// Atom/Arity constructor for predicates. + /// + YAPPredicate(YAPAtom at, arity_t arity); + + + /// String constructor for predicates. + /// + /// String is a Prolog term, we extract the main functor after considering the module qualifiers. + inline YAPPredicate(const char *s) throw (int) { + Term t, tp; + t = YAP_ReadBuffer(s,&tp); + if (t == 0L) + throw YAPError::YAP_SYNTAX_ERROR; + CELL * v; + ap = getPred( t, v); + } + + + /// String constructor for predicates, also keeps arguments in tp[] + /// + /// String is a Prolog term, we extract the main functor after considering the module qualifiers. + inline YAPPredicate(const char *s, Term* outp) throw (int) { + Term t, tp; + t = YAP_ReadBuffer(s,&tp); + if (t == 0L) + throw YAPError::YAP_SYNTAX_ERROR; + ap = getPred( t, outp ); + } + + /// module of a predicate + /// + /// notice that modules are currently treated as atoms, this should change. + YAPModule module() { + if (ap->ModuleOfPred == PROLOG_MODULE) + return YAPModule(AtomProlog); + else + return YAPModule(AtomOfTerm(ap->ModuleOfPred)); + } + + /// name of predicate + /// + /// notice that we return the atom, not a string. + YAPAtom name() { if (ap->ArityOfPE) + return YAPAtom((Atom)ap->FunctorOfPred); + else + return YAPAtom(NameOfFunctor(ap->FunctorOfPred)); + } + + /// arity of predicate + /// + /// we return a positive number. + arity_t getArity() { return ap->ArityOfPE; } +}; + +/** + * @brief PrologPredicate + * + * This class interfaces with Predicates Implemented in Prolog. + */ +class YAPPrologPredicate: public YAPPredicate { +public: + YAPPrologPredicate(YAPAtom name, + arity_t arity, + YAPModule module = YAPModule(), + bool tabled = false, + bool logical_updates = false, + bool local = false, + bool sourced = true, + bool discontiguous = false, + bool multiFile = false, + bool hidden = false, + bool untraceable = false, + bool unspyable = false, + bool meta = false, + bool sync = false, + bool quasi_quotable = false, + size_t mega_clause = 0 + ); + void *assertClause( YAPTerm clause, bool last=true, YAPTerm source= YAPTerm(TermNil)); + void *retractClause( YAPTerm skeleton, bool all=false); + void *clause( YAPTerm skeleton, YAPTerm &body ); +}; + +/** + * @brief PrologPredicate + * + * This class interfaces with Predicates Implemented in Prolog. + */ +class YAPFLIP: public YAPPredicate { +public: + YAPFLIP(CPredicate call, + YAPAtom name, + arity_t arity, + YAPModule module = YAPModule(), + CPredicate retry = 0, + CPredicate cut = 0, + size_t extra = 0, + bool test = false + ) : YAPPredicate( name, arity, module) { + if (retry) { + Yap_InitCPredBackCut(name.getName(), arity, extra, call, retry, cut, UserCPredFlag); + } else { + if (test) { + YAP_UserCPredicate (name.getName(), + call, arity); + } else { + YAP_UserCPredicate (name.getName(), + call, arity); + } + } + + }; + YAPFLIP(const char *name, + arity_t arity, + YAPModule module = YAPModule(), + bool backtrackable = false + ) : YAPPredicate( YAPAtom(name), arity, module) { + if (backtrackable) { + Yap_InitCPredBackCut(name, arity, 0, 0, 0, 0, UserCPredFlag); + } else { + YAP_UserCPredicate (name, + 0, arity); + } + }; + bool addCall(CPredicate call) { + return Yap_AddCallToFli( ap, call ); + } + bool addRetry(CPredicate call) { + return Yap_AddRetryToFli( ap, call ); + } + bool addCut(CPredicate call) { + return Yap_AddCutToFli( ap, call ); + } + +}; + diff --git a/CXX/yapi.cpp b/CXX/yapi.cpp index 11cb87f5a..944950593 100644 --- a/CXX/yapi.cpp +++ b/CXX/yapi.cpp @@ -5,11 +5,12 @@ #include "SWI-Stream.h" + YAPAtomTerm::YAPAtomTerm(char *s) { // build string BACKUP_H(); CACHE_REGS - seq_tv_t inp, out; + seq_tv_t inp, out; inp.val.c = s; inp.type = YAP_STRING_CHARS; out.type = YAP_STRING_ATOM; @@ -267,7 +268,7 @@ intptr_t YAPTerm::hashTerm(size_t sz, size_t depth, bool variant) { return out; } -char *YAPTerm::text(void) { +char *YAPTerm::text() { size_t sze = 4096, length; char *os; int enc; @@ -281,7 +282,7 @@ char *YAPTerm::text(void) { return os; } -char *YAPQuery::text(void) { +char *YAPQuery::text() { size_t sze = 4096, length; char *os; int enc; @@ -387,81 +388,18 @@ char *YAPAtom::getName(void) { } } - -YAPPredicate::YAPPredicate(const char *s, Term* &outp, YAPTerm &vnames) throw (int) { - CACHE_REGS - vnames = Yap_NewSlots(1 PASS_REGS); - Term t = Yap_StringToTerm(s, strlen(s)+1, Yap_GetFromSlot( vnames.t PASS_REGS)); - if (t == 0L) - throw YAPError::YAP_SYNTAX_ERROR; - ap = getPred( t, outp ); -} - -YAPPredicate::YAPPredicate(YAPAtom at) { - CACHE_REGS - ap = RepPredProp(PredPropByAtom(at.a,CurrentModule)); -} - -YAPPredicate::YAPPredicate(YAPAtom at, arity_t arity) { - CACHE_REGS - if (arity) { - Functor f = Yap_MkFunctor(at.a, arity); - ap = RepPredProp(PredPropByFunc(f,CurrentModule)); - } else { - ap = RepPredProp(PredPropByAtom(at.a,CurrentModule)); - } -} - -/// auxiliary routine to find a predicate in the current module. -PredEntry *YAPPredicate::getPred( Term t, Term* &outp ) { - CACHE_REGS - Term m = CurrentModule ; - { CACHE_REGS __android_log_print(ANDROID_LOG_ERROR, __FUNCTION__, "H= %p, outp=%p", HR, outp) ; } - t = Yap_StripModule(t, &m); - if (IsVarTerm(t) || IsNumTerm(t)) { - ap = (PredEntry *)NULL; - outp = (Term *)NULL; - } - if (IsAtomTerm(t)) { - ap = RepPredProp(PredPropByAtom(AtomOfTerm(t), m)); - if (outp) outp = (Term *)NULL; - } else if (IsPairTerm(t)) { - ap = RepPredProp(PredPropByFunc(FunctorCsult, PROLOG_MODULE)); - outp = HR; - HR[0] = RepPair(t)[0]; - HR[1] = m; - HR+=2; - } else { - Functor f = FunctorOfTerm(t); - if (IsExtensionFunctor(f)) { - ap = (PredEntry *)NULL; - outp = (Term *)NULL; - } else { - ap = RepPredProp(PredPropByFunc(f, m)); - outp = RepAppl(t)+1; - } - } - { CACHE_REGS __android_log_print(ANDROID_LOG_ERROR, __FUNCTION__, "done H= %p, outp=%p", HR, outp) ; } - return ap; -} - -YAPPredicate::YAPPredicate(YAPFunctor f) { - CACHE_REGS - ap = RepPredProp(PredPropByFunc(f.f,CurrentModule)); -} - - void YAPQuery::initQuery( Term *ts ) { CACHE_REGS - - this->oq = (YAPQuery *)LOCAL_execution; + this->oq = (YAPQuery *)LOCAL_execution; LOCAL_execution = (struct open_query_struct *)this; this->q_open=1; this->q_state=0; this->q_flags = PL_Q_PASS_EXCEPTION; - this->q_g = ts; + this->q_g = ts; + this->q_p = P; + this->q_cp = CP; } void @@ -502,6 +440,7 @@ bool YAPQuery::next() { CACHE_REGS int result; + if (q_open != 1) return false; if (setjmp(((YAPQuery *)LOCAL_execution)->q_env)) return false; @@ -549,17 +488,6 @@ void YAPQuery::close() LOCAL_execution = (struct open_query_struct *)this->oq; } -int YAPPredicate::call(YAPTerm t[]) -{ - YAPQuery q = YAPQuery(*this, t); - int ret; - - ret = q.next(); - q.cut(); - q.close(); - return ret; -} - static YAPEngine *curren; #if __ANDROID__ @@ -644,3 +572,153 @@ YAPQuery *YAPEngine::query( char *s ) { } + +YAPPredicate::YAPPredicate(const char *s, Term* &outp, Term &vnames) throw (int) { + CACHE_REGS + yhandle_t sl = Yap_NewSlots(1 PASS_REGS); + Term t = Yap_StringToTerm(s, strlen(s)+1, sl ); + if (t == 0L) + throw YAPError::YAP_SYNTAX_ERROR; + vnames = Yap_GetFromSlot( sl PASS_REGS ); + ap = getPred( t, outp ); +} + +YAPPredicate::YAPPredicate(YAPAtom at) { + CACHE_REGS + ap = RepPredProp(PredPropByAtom(at.a,CurrentModule)); +} + +YAPPredicate::YAPPredicate(YAPAtom at, arity_t arity) { + CACHE_REGS + if (arity) { + Functor f = Yap_MkFunctor(at.a, arity); + ap = RepPredProp(PredPropByFunc(f,CurrentModule)); + } else { + ap = RepPredProp(PredPropByAtom(at.a,CurrentModule)); + } +} + +/// auxiliary routine to find a predicate in the current module. +PredEntry *YAPPredicate::getPred( Term t, Term* &outp ) { + CACHE_REGS + Term m = CurrentModule ; + { CACHE_REGS __android_log_print(ANDROID_LOG_ERROR, __FUNCTION__, "H= %p, outp=%p", HR, outp) ; } + t = Yap_StripModule(t, &m); + if (IsVarTerm(t) || IsNumTerm(t)) { + ap = (PredEntry *)NULL; + outp = (Term *)NULL; + } + if (IsAtomTerm(t)) { + ap = RepPredProp(PredPropByAtom(AtomOfTerm(t), m)); + if (outp) outp = (Term *)NULL; + } else if (IsPairTerm(t)) { + ap = RepPredProp(PredPropByFunc(FunctorCsult, PROLOG_MODULE)); + outp = HR; + HR[0] = RepPair(t)[0]; + HR[1] = m; + HR+=2; + } else { + Functor f = FunctorOfTerm(t); + if (IsExtensionFunctor(f)) { + ap = (PredEntry *)NULL; + outp = (Term *)NULL; + } else { + ap = RepPredProp(PredPropByFunc(f, m)); + outp = RepAppl(t)+1; + } + } + { CACHE_REGS __android_log_print(ANDROID_LOG_ERROR, __FUNCTION__, "done H= %p, outp=%p", HR, outp) ; } + return ap; +} + + +YAPPrologPredicate::YAPPrologPredicate(YAPAtom name, + arity_t arity, + YAPModule mod, + bool tabled, + bool logical_updates, + bool thread_local, + bool sourced, + bool discontiguous, + bool multiFile, + bool hidden, + bool untraceable, + bool unspyable, + bool meta, + bool moduleTransparent, + bool quasiQuotable, + size_t mega_clause + ) : YAPPredicate(name, arity, mod) { + if (!ap) return; + if (thread_local) { + if (ap->cs.p_code.NOfClauses || tabled) + return; + ap->PredFlags |= (ThreadLocalPredFlag|LogUpdatePredFlag); + } else if (logical_updates) { + if (ap->cs.p_code.NOfClauses || tabled) + return; + ap->PredFlags |= LogUpdatePredFlag; + ap->CodeOfPred = FAILCODE; + ap->OpcodeOfPred = FAILCODE->opc; + } + if (tabled) { + ap->PredFlags |= TabledPredFlag; + if (ap->cs.p_code.NOfClauses || tabled) + return; + ap->PredFlags |= TabledPredFlag; + } + if (sourced) { + ap->PredFlags |= SourcePredFlag; + } + if (discontiguous) { + ap->PredFlags |= DiscontiguousPredFlag; + } + if (multiFile) { + ap->PredFlags |= MultiFileFlag; + } + if (hidden) { + ap->PredFlags |= HiddenPredFlag; + } + if (untraceable) { + ap->PredFlags |= SourcePredFlag; + } + if (unspyable) { + ap->PredFlags |= NoSpyPredFlag; + } + if (meta) { + ap->PredFlags |= MetaPredFlag; + } else if (moduleTransparent) { + ap->PredFlags |= ModuleTransparentPredFlag; + } + if (quasiQuotable) { + ap->PredFlags |= QuasiQuotationPredFlag; + } + if (untraceable) { + ap->PredFlags |= SourcePredFlag; + } + if (hidden) { + ap->PredFlags |= SourcePredFlag; + } +} + +void *YAPPrologPredicate::assertClause( YAPTerm clause, bool last, YAPTerm source) { + CACHE_REGS + + Term tt = clause.gt(); + Term sourcet = source.gt(); + yamop *codeaddr = Yap_cclause(tt, PP->ArityOfPE, CurrentModule, sourcet); /* vsc: give the number of arguments + to cclause in case there is overflow */ + Term ntt = clause.gt(); + if (LOCAL_ErrorMessage) + return 0; + Term *tref = &ntt; + if (Yap_addclause(ntt, codeaddr, (last ? 0 : 2), CurrentModule, tref)) + return tref; + return 0; +} +void* YAPPrologPredicate::retractClause( YAPTerm skeleton, bool all) { + return 0; +} +void* YAPPrologPredicate::clause( YAPTerm skeleton, YAPTerm &body ) { + return 0; +} diff --git a/CXX/yapi.hh b/CXX/yapi.hh index 0d1eca326..c7df5c8ea 100644 --- a/CXX/yapi.hh +++ b/CXX/yapi.hh @@ -31,15 +31,7 @@ extern "C" { #include -#ifdef __cplusplus -#define old_cplusplus __cplusplus -#undef __cplusplus -#endif -#ifdef old_cplusplus -#define __cplusplus old_cplusplus -#undef old_cplusplus -#endif - + #include "Yap.h" #include "Yatom.h" @@ -60,8 +52,6 @@ extern "C" { #include "YapText.h" -#include "yapie.hh" - #if HAVE_STDARG_H #include #endif @@ -88,6 +78,7 @@ extern "C" { // it shouldn't } + //#include @@ -97,503 +88,19 @@ class YAPFunctor; class YAPApplTerm; class YAPPairTerm; class YAPQuery; +class YAPModule; +class YAPError; +class YAPPredicate; -/** - * @brief Generic Prolog Term - */ -class YAPTerm { - friend class YAPPredicate; - friend class YAPApplTerm; - friend class YAPPairTerm; - friend class YAPListTerm; - friend class YAPQuery; -protected: - yhandle_t t; /// handle to term, equivalent to term_t - void mk(Term t0); /// internal method to convert from term to handle - Term gt(); /// get handle and obtain term - YAPTerm(Term tn) { mk( tn ); } /// private method to convert from Term (internal YAP representation) to YAPTerm - inline Term term() { return gt(); } /// private method to convert from YAPTerm to Term (internal YAP representation) -public: - // do nothing constructor - YAPTerm() { mk(TermNil); } - /// integer to term - YAPTerm(intptr_t i); - /// pointer to term - YAPTerm(void *ptr); - /// parse string s and construct a term. - YAPTerm(char *s) { Term tp ; mk( YAP_ReadBuffer(s,&tp) ); } - /// extract the tag of a term, after dereferencing. - YAP_tag_t tag(); - /// copy the term ( term copy ) - YAPTerm deepCopy(); - //const YAPTerm *vars(); - /// this term is == to t1 - bool exactlyEqual(YAPTerm t1); - bool unify(YAPTerm t1); /// t = t1 - bool unifiable(YAPTerm t1); /// we can unify t and t1 - bool variant(YAPTerm t1); /// t =@= t1, the two terms are equal up to variable renaming - intptr_t hashTerm(size_t sz, size_t depth, bool variant); /// term hash, - bool isVar() { return IsVarTerm( gt() ); } /// type check for unbound - bool isAtom() { return IsAtomTerm( gt() ); } /// type check for atom - bool isInteger() { return IsIntegerTerm( gt() ); } /// type check for integer - bool isFloat() { return IsFloatTerm( gt() ); } /// type check for floating-point - bool isString() { return IsStringTerm( gt() ); } /// type check for a string " ... " - bool isCompound() { return !(IsVarTerm( gt() ) || IsNumTerm( gt() )); } /// is a primitive term - bool isAppl() { return IsApplTerm( gt() ); } /// is a structured term - bool isPair() { return IsPairTerm( gt() ); } /// is a pair term - bool isGround() { return Yap_IsGroundTerm( gt() ); } /// term is ground - bool isList() { return Yap_IsListTerm( gt() ); } /// term is a list +#include "yapa.hh" - /// extract the argument i of the term, where i in 1...arity - inline YAPTerm getArg(int i) { - Term t0 = gt(); - if (IsApplTerm(t0)) - return YAPTerm(ArgOfTerm(i, t0)); - else if (IsPairTerm(t0)) { - if (i==1) - return YAPTerm(HeadOfTerm(t0)); - if (i==2) - return YAPTerm(TailOfTerm(t0)); - } - return YAPTerm((Term)0); - } +#include "yapie.hh" - /// return a string with a textual representation of the term - char *text(); -}; +#include "yapt.hh" -/** - * @brief Variable Term - */ -class YAPVarTerm: public YAPTerm { - YAPVarTerm(Term t) { if (IsVarTerm(t)) mk( t ); } -public: - /// constructor - YAPVarTerm(); - /// get the internal representation - CELL *getVar() { return VarOfTerm( gt() ); } - /// is the variable bound to another one - bool unbound() { return IsUnboundVar(VarOfTerm( gt() )); } -}; +#include "yapdb.hh" -/** - * @brief Compound Term - */ -class YAPApplTerm: public YAPTerm { - friend class YAPTerm; - YAPApplTerm(Term t0) { mk(t0); } -public: - YAPApplTerm(YAPTerm t0) { mk(t0.term()); } - YAPApplTerm(YAPFunctor f, YAPTerm ts[]); - YAPApplTerm(YAPFunctor f); - YAPFunctor getFunctor(); - YAPTerm getArg(int i); -}; - -/** - * @brief List Constructor Term - */ -class YAPPairTerm: public YAPTerm { - friend class YAPTerm; - YAPPairTerm(Term t0) { if (IsPairTerm(t0)) mk( t0 ); else mk(0); } -public: - YAPPairTerm(YAPTerm hd, YAPTerm tl); - YAPPairTerm(); - YAPTerm getHead() { return YAPTerm(HeadOfTerm( gt() )); } - YAPTerm getTail() { return YAPTerm(TailOfTerm( gt() )); } -}; - -/** - * @brief Integer Term - */ - -class YAPIntegerTerm: public YAPTerm { -public: - YAPIntegerTerm(intptr_t i); - intptr_t getInteger() { return IntegerOfTerm( gt() ); } - bool isTagged() { return IsIntTerm( gt() ); } -}; - -class YAPListTerm: public YAPTerm { -public: - /// Create a list term out of a standard term. Check if a valid operation. - /// - /// @param[in] the term - YAPListTerm(Term t0) { mk(t0); /* else type_error */ } - /* /// Create a list term out of an array of terms. - /// - /// @param[in] the array of terms - /// @param[in] the length of the array - YAPListTerm(YAPTerm ts[], size_t n); - */ - // YAPListTerm( vector v ); - /// Return the number of elements in a list term. - size_t length() { Term *tailp; Term t1 = gt(); return Yap_SkipList(&t1, &tailp); } - /// Extract the first element of a list. - /// - /// @param[in] the list - YAPTerm car(); - /// Extract the tail elements of a list. - /// - /// @param[in] the list - YAPListTerm cdr() - { - Term to = gt(); - if (IsPairTerm( to )) - return YAPListTerm(TailOfTerm( to )); - else - return MkIntTerm(-1); - } - - /// Check if the list is empty. - /// - /// @param[in] the list - bool nil(); -}; - -/** - * @brief Atom - */ -class YAPAtom { - friend class YAPPredicate; - friend class YAPFunctor; - friend class YAPAtomTerm; - Atom a; - /// construct new YAPAtom from Atom - YAPAtom( Atom at ) { a = at; } -public: - /// construct new YAPAtom from string - YAPAtom( char * s) { a = Yap_LookupAtom( s ); } - /// construct new YAPAtom from wide string - YAPAtom( wchar_t * s) { a = Yap_LookupMaybeWideAtom( s ); } - /// construct new YAPAtom from max-length string - YAPAtom( char * s, size_t len) { a = Yap_LookupAtomWithLength( s, len ); } - /// construct new YAPAtom from max-length wide string - YAPAtom( wchar_t * s, size_t len) { a = Yap_LookupMaybeWideAtomWithLength( s, len ); } - /// get name of atom - char *getName(void); -}; - -/** - * @brief String Term - */ -class YAPStringTerm: public YAPTerm { -public: - /// your standard constructor - YAPStringTerm(char *s) ; - /// use this one to construct length limited strings - YAPStringTerm(char *s, size_t len); - /// construct using wide chars - YAPStringTerm(wchar_t *s) ; - /// construct using length-limited wide chars - YAPStringTerm(wchar_t *s, size_t len); - const char *getString() { return StringOfTerm( gt() ); } -}; - -/** - * @brief Atom Term - */ -class YAPAtomTerm: public YAPTerm { -public: - YAPAtomTerm(YAPAtom a): YAPTerm() { mk( MkAtomTerm(a.a) ); } - YAPAtomTerm(Atom a): YAPTerm() { mk( MkAtomTerm(a) ); } - YAPAtomTerm(char *s) ; - YAPAtomTerm(char *s, size_t len); - YAPAtomTerm(wchar_t *s) ; - YAPAtomTerm(wchar_t *s, size_t len); - YAPAtom getAtom() { return YAPAtom(AtomOfTerm( gt() )); } -}; - -/** - * @brief YAPFunctor represents Prolog functors Name/Arity - */ -class YAPFunctor { - friend class YAPApplTerm; - friend class YAPPredicate; - Functor f; - /// Constructor: receives Prolog functor and casts it to YAPFunctor - /// - /// Notice that this is designed for internal use only. - YAPFunctor( Functor ff) { f = ff; } -public: - /// Constructor: receives name as a string plus arity - /// - /// Notice that this is designed for ISO-LATIN-1 right now - YAPFunctor( char * s, arity_t arity) { f = Yap_MkFunctor( Yap_LookupAtom( s ), arity ); } - /// Constructor: receives name as a wide string plus arity - /// - /// Notice that this is designed for UNICODE right now - YAPFunctor( wchar_t * s, arity_t arity) { f = Yap_MkFunctor( Yap_LookupWideAtom( s ), arity ); } - /// Constructor: receives name as an atom, plus arity - /// - /// This is the default method, and the most popi;at - YAPFunctor( YAPAtom at, arity_t arity) { f = Yap_MkFunctor( at.a, arity ); } - - /// Getter: extract name of functor as an atom - /// - /// this is for external usage. - YAPAtom name(void) { - return YAPAtom( NameOfFunctor( f ) ); - } - - /// Getter: extract arity of functor as an unsigned integer - /// - /// this is for external usage. - arity_t arity(void) { - return ArityOfFunctor( f ); - } -}; - -/** - * @brief Predicates - * - * This class interfaces with PredEntry in Yatom.g - */ -class YAPPredicate { - friend class YAPQuery; - -private: - PredEntry *ap; - - /// auxiliary routine to find a predicate in the current module. - PredEntry *getPred( Term t, Term* &outp ) ; - - /// String constructor for predicates - /// - /// It also communicates the array of arguments t[] abd the array of variables - /// back to yapquery - YAPPredicate(const char *s, Term* &outp, YAPTerm& vnames ) throw (int); - - /// Term constructor for predicates - /// - /// It is just a call to getPred - inline YAPPredicate(Term t) { - CELL * v = NULL; - ap = getPred( t , v ); - } - - /// Cast constructor for predicates, - /// if we have the implementation data. - /// - inline YAPPredicate(PredEntry *pe) { - ap = pe; - } - -public: - - /// Functor constructor for predicates - /// - /// Asssumes that we use the current module. - YAPPredicate(YAPFunctor f); - - /// Functor constructor for predicates, is given a specific module. - /// - inline YAPPredicate(YAPFunctor f, YAPTerm mod) { - ap = RepPredProp(PredPropByFunc(f.f,mod.t)); - } - - /// Name/arity constructor for predicates. - /// - inline YAPPredicate(YAPAtom at, YAPTerm mod) { - ap = RepPredProp(PredPropByAtom(at.a,mod.t)); - } - - - /// Name/0 constructor for predicates. - /// - YAPPredicate(YAPAtom at); - - /// Mod:Name/Arity constructor for predicates. - /// - inline YAPPredicate(YAPAtom at, arity_t arity, YAPTerm mod) { - if (arity) { - Functor f = Yap_MkFunctor(at.a, arity); - ap = RepPredProp(PredPropByFunc(f,mod.t)); - } else { - ap = RepPredProp(PredPropByAtom(at.a,mod.t)); - } - } - - /// Atom/Arity constructor for predicates. - /// - YAPPredicate(YAPAtom at, arity_t arity); - - - /// String constructor for predicates. - /// - /// String is a Prolog term, we extract the main functor after considering the module qualifiers. - inline YAPPredicate(char *s) throw (int) { - Term t, tp; - t = YAP_ReadBuffer(s,&tp); - if (t == 0L) - throw YAPError::YAP_SYNTAX_ERROR; - CELL * v; - ap = getPred( t, v); - } - - - /// String constructor for predicates, also keeps arguments in tp[] - /// - /// String is a Prolog term, we extract the main functor after considering the module qualifiers. - inline YAPPredicate(char *s, Term* &outp) throw (int) { - Term t, tp; - t = YAP_ReadBuffer(s,&tp); - if (t == 0L) - throw YAPError::YAP_SYNTAX_ERROR; - ap = getPred( t, outp ); - } - - /// meta-call this predicate, with arguments ts[] - /// - int call(YAPTerm ts[]); - - /// module of a predicate - /// - /// notice that modules are currently treated as atoms, this should change. - YAPAtom module() { - if (ap->ModuleOfPred == PROLOG_MODULE) - return YAPAtom(AtomProlog); - else - return YAPAtom(AtomOfTerm(ap->ModuleOfPred)); - } - - /// name of predicate - /// - /// notice that we return the atom, not a string. - YAPAtom name() { if (ap->ArityOfPE) - return YAPAtom((Atom)ap->FunctorOfPred); - else - return YAPAtom(NameOfFunctor(ap->FunctorOfPred)); - } - - /// arity of predicate - /// - /// we return a positive number. - arity_t getArity() { return ap->ArityOfPE; } - -}; - -/** - * @brief Queries - * - * interface to a YAP Query; - * uses an SWI-like status info internally. - */ -class YAPQuery: public YAPPredicate { - int q_open; - int q_state; - Term *q_g; - yamop *q_p, *q_cp; - jmp_buf q_env; - int q_flags; - YAP_dogoalinfo q_h; - YAPQuery *oq; - YAPTerm vnames; - void initQuery( Term ts[] ); - void initQuery( YAPTerm t[], arity_t arity ); -public: - /// main constructor, uses a predicate and an array of terms - /// - /// It is given a YAPPredicate _p_ , and an array of terms that must have at least - /// the same arity as the functor. - YAPQuery(YAPPredicate p, YAPTerm t[]); - /// full constructor, - /// - /// It is given a functor, module, and an array of terms that must have at least - /// the same arity as the functor. - YAPQuery(YAPFunctor f, YAPTerm mod, YAPTerm t[]); - /// functor/term constructor, - /// - /// It is given a functor, and an array of terms that must have at least - /// the same arity as the functor. Works within the current module. - YAPQuery(YAPFunctor f, YAPTerm t[]); - /// string constructor without varnames - /// - /// It is given a string, calls the parser and obtains a Prolog term that should be a callable - /// goal. It does not ask for a list of variables. - inline YAPQuery(char *s): YAPPredicate(s, q_g) - { - initQuery( q_g ); - } - /// string constructor with varnames - /// - /// It is given a string, calls the parser and obtains a Prolog term that should be a callable - /// goal and a list of variables. Useful for top-level simulation. Works within the current module. - inline YAPQuery(char *s, YAPTerm &vnames): YAPPredicate(s, q_g, vnames) - { - initQuery( q_g ); - } - /// set flags for query execution, currently only for exception handling - void setFlag(int flag) {q_flags |= flag; } - /// reset flags for query execution, currently only for exception handling - void resetFlag(int flag) {q_flags &= ~flag; } - /// first query - /// - /// actually implemented by calling the next(); - inline bool first() { return next(); } - /// ask for the next solution of the current query - /// same call for every solution - bool next(); - /// represent the top-goal - char *text(); - /// remove alternatives in the current search space, and finish the current query - void cut(); - /// finish the current query: undo all bindings. - void close(); - /// query variables. - YAPListTerm namedVars(); -}; - -// Java support - -/// This class implements a callback Prolog-side. It will be inherited by the Java or Python -/// class that actually implements the callback. -class YAPCallback { -public: - virtual ~YAPCallback() { printf("~YAPCallback\n"); } - virtual void run() { __android_log_print(ANDROID_LOG_INFO, __FUNCTION__, "callback"); } - virtual void run(char *s) { } -}; - -/** - * @brief YAP Engine: takes care of the execution environment - where we can go executing goals. - * - * - */ -class YAPEngine { -private: - YAPCallback *_callback; - YAP_init_args init_args; - YAPError yerror; -public: - YAPEngine(char *savedState = (char *)NULL, - size_t stackSize = 0, - size_t trailSize = 0, - size_t maxStackSize = 0, - size_t maxTrailSize = 0, - char *libDir = (char *)NULL, - char *bootFile = (char *)NULL, - char *goal = (char *)NULL, - char *topLevel = (char *)NULL, - bool script = FALSE, - bool fastBoot = FALSE, - YAPCallback *callback=(YAPCallback *)NULL); /// construct a new engine, including aaccess to callbacks - /// kill engine - ~YAPEngine() { delYAPCallback(); } - /// remove current callback - void delYAPCallback() { _callback = 0; } - /// set a new callback - void setYAPCallback(YAPCallback *cb) { delYAPCallback(); _callback = cb; } - /// execute the callback. - void run() { if (_callback) _callback->run(); } - /// execute the callback with a text argument. - void run( char *s) { if (_callback) _callback->run(s); } - /// execute the callback with a text argument. - YAPError hasError( ) { return yerror; } - /// build a query on the engine - YAPQuery *query( char *s ); -}; +#include "yapq.hh" /** * @} diff --git a/CXX/yapq.hh b/CXX/yapq.hh new file mode 100644 index 000000000..d087bf29b --- /dev/null +++ b/CXX/yapq.hh @@ -0,0 +1,127 @@ +#ifndef YAPQ_HH +#define YAPQ_HH 1 + +/** + Queries and engines +*/ + +/** + * @brief Queries + * + * interface to a YAP Query; + * uses an SWI-like status info internally. + */ +class YAPQuery: public YAPPredicate { + int q_open; + int q_state; + Term *q_g; + yamop *q_p, *q_cp; + jmp_buf q_env; + int q_flags; + Term vs; + YAP_dogoalinfo q_h; + YAPQuery *oq; + YAPTerm vnames; + void initQuery( Term ts[] ); + void initQuery( YAPTerm t[], arity_t arity ); +public: + /// main constructor, uses a predicate and an array of terms + /// + /// It is given a YAPPredicate _p_ , and an array of terms that must have at least + /// the same arity as the functor. + YAPQuery(YAPPredicate p, YAPTerm t[]); + /// full constructor, + /// + /// It is given a functor, module, and an array of terms that must have at least + /// the same arity as the functor. + YAPQuery(YAPFunctor f, YAPTerm mod, YAPTerm t[]); + /// functor/term constructor, + /// + /// It is given a functor, and an array of terms that must have at least + /// the same arity as the functor. Works within the current module. + YAPQuery(YAPFunctor f, YAPTerm t[]); + /// string constructor without varnames + /// + /// It is given a string, calls the parser and obtains a Prolog term that should be a callable + /// goal. It does not ask for a list of variables. + inline YAPQuery(const char *s): YAPPredicate(s, q_g, vs) + { + vnames = YAPTerm( vs ); + initQuery( q_g ); + } + + /// set flags for query execution, currently only for exception handling + void setFlag(int flag) {q_flags |= flag; } + /// reset flags for query execution, currently only for exception handling + void resetFlag(int flag) {q_flags &= ~flag; } + /// first query + /// + /// actually implemented by calling the next(); + inline bool first() { return next(); } + /// ask for the next solution of the current query + /// same call for every solution + bool next(); + /// represent the top-goal + char *text(); + /// remove alternatives in the current search space, and finish the current query + void cut(); + /// finish the current query: undo all bindings. + void close(); + /// query variables. + YAPListTerm namedVars(); +}; + +// Java support + +/// This class implements a callback Prolog-side. It will be inherited by the Java or Python +/// class that actually implements the callback. +class YAPCallback { +public: + virtual ~YAPCallback() { printf("~YAPCallback\n"); } + virtual void run() { __android_log_print(ANDROID_LOG_INFO, __FUNCTION__, "callback"); } + virtual void run(char *s) { } +}; + +/** + * @brief YAP Engine: takes care of the execution environment + where we can go executing goals. + * + * + */ +class YAPEngine { +private: + YAPCallback *_callback; + YAP_init_args init_args; + YAPError yerror; +public: + YAPEngine(char *savedState = (char *)NULL, + size_t stackSize = 0, + size_t trailSize = 0, + size_t maxStackSize = 0, + size_t maxTrailSize = 0, + char *libDir = (char *)NULL, + char *bootFile = (char *)NULL, + char *goal = (char *)NULL, + char *topLevel = (char *)NULL, + bool script = FALSE, + bool fastBoot = FALSE, + YAPCallback *callback=(YAPCallback *)NULL); /// construct a new engine, including aaccess to callbacks + /// kill engine + ~YAPEngine() { delYAPCallback(); } + /// remove current callback + void delYAPCallback() { _callback = 0; } + /// set a new callback + void setYAPCallback(YAPCallback *cb) { delYAPCallback(); _callback = cb; } + /// execute the callback. + void run() { if (_callback) _callback->run(); } + /// execute the callback with a text argument. + void run( char *s) { if (_callback) _callback->run(s); } + /// execute the callback with a text argument. + YAPError hasError( ) { return yerror; } + /// build a query on the engine + YAPQuery *query( char *s ); + /// current module for the engine + YAPModule currentModule( ) { return YAPModule( ) ; } +}; + +#endif /* YAPQ_HH */ diff --git a/CXX/yapt.hh b/CXX/yapt.hh new file mode 100644 index 000000000..2fd869782 --- /dev/null +++ b/CXX/yapt.hh @@ -0,0 +1,202 @@ +#ifndef YAPT_HH +#define YAPT_HH 1 + +/** + * @brief Generic Prolog Term + */ +class YAPTerm { + friend class YAPPredicate; + friend class YAPPrologPredicate; + friend class YAPQuery; + friend class YAPModule; + friend class YAPModuleProp; +protected: + yhandle_t t; /// handle to term, equivalent to term_t + void mk(Term t0); /// internal method to convert from term to handle + Term gt(); /// get handle and obtain term +public: + ~YAPTerm() {}; + YAPTerm(Term tn) { mk( tn ); } /// private method to convert from Term (internal YAP representation) to YAPTerm + // do nothing constructor + YAPTerm() { mk(TermNil); } + /// integer to term + YAPTerm(intptr_t i); + /// pointer to term + YAPTerm(void *ptr); + /// parse string s and construct a term. + YAPTerm(char *s) { Term tp ; mk( YAP_ReadBuffer(s,&tp) ); } + /// extract the tag of a term, after dereferencing. + YAP_tag_t tag(); + /// copy the term ( term copy ) + YAPTerm deepCopy(); + inline Term term() { return gt(); } /// private method to convert from YAPTerm to Term (internal YAP representation) + //const YAPTerm *vars(); + /// this term is == to t1 + bool exactlyEqual(YAPTerm t1); + bool unify(YAPTerm t1); /// t = t1 + bool unifiable(YAPTerm t1); /// we can unify t and t1 + bool variant(YAPTerm t1); /// t =@= t1, the two terms are equal up to variable renaming + intptr_t hashTerm(size_t sz, size_t depth, bool variant); /// term hash, + bool isVar() { return IsVarTerm( gt() ); } /// type check for unbound + bool isAtom() { return IsAtomTerm( gt() ); } /// type check for atom + bool isInteger() { return IsIntegerTerm( gt() ); } /// type check for integer + bool isFloat() { return IsFloatTerm( gt() ); } /// type check for floating-point + bool isString() { return IsStringTerm( gt() ); } /// type check for a string " ... " + bool isCompound() { return !(IsVarTerm( gt() ) || IsNumTerm( gt() )); } /// is a primitive term + bool isAppl() { return IsApplTerm( gt() ); } /// is a structured term + bool isPair() { return IsPairTerm( gt() ); } /// is a pair term + bool isGround() { return Yap_IsGroundTerm( gt() ); } /// term is ground + bool isList() { return Yap_IsListTerm( gt() ); } /// term is a list + + /// extract the argument i of the term, where i in 1...arity + inline YAPTerm getArg(int i) { + Term t0 = gt(); + if (IsApplTerm(t0)) + return YAPTerm(ArgOfTerm(i, t0)); + else if (IsPairTerm(t0)) { + if (i==1) + return YAPTerm(HeadOfTerm(t0)); + if (i==2) + return YAPTerm(TailOfTerm(t0)); + } + return YAPTerm((Term)0); + } + + /// return a string with a textual representation of the term + char *text(); +}; + +/** + * @brief Variable Term + */ +class YAPVarTerm: private YAPTerm { + YAPVarTerm(Term t) { if (IsVarTerm(t)) mk( t ); } +public: + /// constructor + YAPVarTerm(); + /// get the internal representation + CELL *getVar() { return VarOfTerm( gt() ); } + /// is the variable bound to another one + bool unbound() { return IsUnboundVar(VarOfTerm( gt() )); } +}; + +/** + * @brief Compound Term + */ +class YAPApplTerm: YAPTerm { + friend class YAPTerm; + YAPApplTerm(Term t0) { mk(t0); } +public: + ~YAPApplTerm() { } + YAPApplTerm(YAPFunctor f, YAPTerm ts[]); + YAPApplTerm(YAPFunctor f); + YAPFunctor getFunctor(); + YAPTerm getArg(int i); +}; + +/** + * @brief List Constructor Term + */ +class YAPPairTerm: YAPTerm { + friend class YAPTerm; + YAPPairTerm(Term t0) { if (IsPairTerm(t0)) mk( t0 ); else mk(0); } +public: + YAPPairTerm(YAPTerm hd, YAPTerm tl); + YAPPairTerm(); + YAPTerm getHead() { return YAPTerm(HeadOfTerm( gt() )); } + YAPTerm getTail() { return YAPTerm(TailOfTerm( gt() )); } +}; + +/** + * @brief Integer Term + */ + +class YAPIntegerTerm: private YAPTerm { +public: + YAPIntegerTerm(intptr_t i); + intptr_t getInteger() { return IntegerOfTerm( gt() ); } + bool isTagged() { return IsIntTerm( gt() ); } +}; + +class YAPListTerm: private YAPTerm { +public: + /// Create a list term out of a standard term. Check if a valid operation. + /// + /// @param[in] the term + YAPListTerm(Term t0) { mk(t0); /* else type_error */ } + /* /// Create a list term out of an array of terms. + /// + /// @param[in] the array of terms + /// @param[in] the length of the array + YAPListTerm(YAPTerm ts[], size_t n); + */ + // YAPListTerm( vector v ); + /// Return the number of elements in a list term. + size_t length() { Term *tailp; Term t1 = gt(); return Yap_SkipList(&t1, &tailp); } + /// Extract the first element of a list. + /// + /// @param[in] the list + YAPTerm car(); + /// Extract the tail elements of a list. + /// + /// @param[in] the list + YAPListTerm cdr() + { + Term to = gt(); + if (IsPairTerm( to )) + return YAPListTerm(TailOfTerm( to )); + else + return MkIntTerm(-1); + } + + /// Check if the list is empty. + /// + /// @param[in] the list + bool nil(); +}; + +/** + * @brief String Term + */ +class YAPStringTerm: private YAPTerm { +public: + /// your standard constructor + YAPStringTerm(char *s) ; + /// use this one to construct length limited strings + YAPStringTerm(char *s, size_t len); + /// construct using wide chars + YAPStringTerm(wchar_t *s) ; + /// construct using length-limited wide chars + YAPStringTerm(wchar_t *s, size_t len); + const char *getString() { return StringOfTerm( gt() ); } +}; + +/** + * @brief Atom Term + * Term Representation of an Atom + */ +class YAPAtomTerm: YAPTerm { + friend class YAPModule; + // Constructor: receives a C-atom; + YAPAtomTerm(Atom a) { mk( MkAtomTerm(a) ); } + YAPAtomTerm(Term t): YAPTerm(t) { IsAtomTerm(t); } + // Getter for Prolog atom + Term getTerm() { return t; } +public: + // Constructor: receives an atom; + YAPAtomTerm(YAPAtom a): YAPTerm() { mk( MkAtomTerm(a.a) ); } + // Constructor: receives a sequence of ISO-LATIN1 codes; + YAPAtomTerm(char *s) ; + // Constructor: receives a sequence of up to n ISO-LATIN1 codes; + YAPAtomTerm(char *s, size_t len); + // Constructor: receives a sequence of wchar_ts, whatever they may be; + YAPAtomTerm(wchar_t *s) ; + // Constructor: receives a sequence of n wchar_ts, whatever they may be; + YAPAtomTerm(wchar_t *s, size_t len); + // Getter: outputs the atom; + YAPAtom getAtom() { return YAPAtom(AtomOfTerm( gt() )); } + // Getter: outputs the name as a sequence of ISO-LATIN1 codes; + const char *getName() { return AtomOfTerm( gt() )->StrOfAE; } +}; + +#endif /* YAPT_HH */ From 88e3d637ecb7e866fdf34aab3ed93cc644d247e9 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?V=C3=ADtor=20Santos=20Costa?= Date: Mon, 9 Feb 2015 01:53:28 +0000 Subject: [PATCH 9/9] C++ & swig --- C/adtdefs.c | 3 +- C/init.c | 69 ++++++++++++++++++++++++++++-------- C/traced_absmi_insts.h | 15 -------- H/Atoms.h | 17 +++++++++ H/TermExt.h | 38 +++++--------------- H/Yap.h | 2 +- H/Yapproto.h | 13 ++++--- H/Yatom.h | 4 +-- H/absmi.h | 3 +- H/amijit.h | 4 +-- Makefile.in | 8 +++-- os/pl-stream.c | 2 +- packages/swig/Makefile.in | 18 +++++++--- packages/swig/python/demo.py | 16 ++++----- packages/swig/yap.i | 10 ++++++ 15 files changed, 134 insertions(+), 88 deletions(-) diff --git a/C/adtdefs.c b/C/adtdefs.c index 7b834bdbf..2e82d2735 100755 --- a/C/adtdefs.c +++ b/C/adtdefs.c @@ -388,7 +388,8 @@ Yap_FullLookupAtom(const char *atom) } void -Yap_LookupAtomWithAddress(const char *atom, AtomEntry *ae) +Yap_LookupAtomWithAddress(const char *atom, + AtomEntry *ae) { /* lookup atom in atom table */ register CELL hash; register unsigned char *p; diff --git a/C/init.c b/C/init.c index e6976eb7b..80fcda37d 100755 --- a/C/init.c +++ b/C/init.c @@ -593,6 +593,54 @@ Yap_InitCPred(const char *Name, UInt Arity, CPredicate code, pred_flags_t flags) pe->OpcodeOfPred = pe->CodeOfPred->opc; } +bool +Yap_AddCallToFli( PredEntry *pe, CPredicate call ) +{ + yamop *p_code; + + if (pe->PredFlags & BackCPredFlag) { + p_code = (yamop *)(pe->cs.p_code.FirstClause); + p_code->y_u.OtapFs.f = call; + return true; + } else if (pe->PredFlags & CPredFlag) { + pe->cs.f_code = call; + return true; + } else { + return false; + } +} + +bool +Yap_AddRetryToFli( PredEntry *pe, CPredicate re ) +{ + yamop *p_code; + + if (pe->PredFlags & BackCPredFlag) { + p_code = (yamop *)(pe->cs.p_code.FirstClause); + p_code = NEXTOP(p_code,OtapFs); + p_code->y_u.OtapFs.f = re; + return true; + } else { + return false; + } +} + +bool +Yap_AddCutToFli( PredEntry *pe, CPredicate CUT ) +{ + yamop *p_code; + + if (pe->PredFlags & BackCPredFlag) { + p_code = (yamop *)(pe->cs.p_code.FirstClause); + p_code = NEXTOP(p_code,OtapFs); + p_code = NEXTOP(p_code,OtapFs); + p_code->y_u.OtapFs.f = CUT; + return true; + } else { + return false; + } +} + void Yap_InitCmpPred(const char *Name, UInt Arity, CmpPredicate cmp_code, pred_flags_t flags) { @@ -776,7 +824,7 @@ CleanBack(PredEntry *pe, CPredicate Start, CPredicate Cont, CPredicate Cut) pe->cs.p_code.TrueCodeOfPred != pe->cs.p_code.FirstClause || pe->CodeOfPred != pe->cs.p_code.FirstClause) { Yap_Error(SYSTEM_ERROR,TermNil, - "initiating a C Pred with backtracking"); + "initiating a C Pred with backtracking"); return; } code = (yamop *)(pe->cs.p_code.FirstClause); @@ -1082,21 +1130,12 @@ InitAtoms(void) HashChain[i].Entry = NIL; } NOfAtoms = 0; -#if THREADS - SF_STORE->AtFoundVar = Yap_LookupAtom("**"); - Yap_ReleaseAtom(AtomFoundVar); - SF_STORE->AtFreeTerm = Yap_LookupAtom("?"); + Yap_LookupAtomWithAddress("**",(AtomEntry *)&(SF_STORE->AtFoundVar)); + Yap_ReleaseAtom(AtomFoundVar); + Yap_LookupAtomWithAddress("?",(AtomEntry *)&(SF_STORE->AtFreeTerm)); Yap_ReleaseAtom(AtomFreeTerm); - SF_STORE->AtNil = Yap_LookupAtom("[]"); - SF_STORE->AtDot = Yap_LookupAtom("."); -#else - Yap_LookupAtomWithAddress("**",&(SF_STORE->AtFoundVar)); - Yap_ReleaseAtom(AtomFoundVar); - Yap_LookupAtomWithAddress("?",&(SF_STORE->AtFreeTerm)); - Yap_ReleaseAtom(AtomFreeTerm); - Yap_LookupAtomWithAddress("[]",&(SF_STORE->AtNil)); - Yap_LookupAtomWithAddress(".",&(SF_STORE->AtDot)); -#endif + Yap_LookupAtomWithAddress("[]",(AtomEntry *)&(SF_STORE->AtNil)); + Yap_LookupAtomWithAddress(".",(AtomEntry *)&(SF_STORE->AtDot)); } static void diff --git a/C/traced_absmi_insts.h b/C/traced_absmi_insts.h index f51164ad3..14c2357cf 100644 --- a/C/traced_absmi_insts.h +++ b/C/traced_absmi_insts.h @@ -14570,20 +14570,5 @@ S_SREG = RepAppl(d0); BOp(try_udi ,p); goto Ystop; ENDBOp(); - /* BOp(table_answer_resolution_completion, Otapl); - goto Ystop; - ENDBOp(); - BOp(run_eam, os); - goto Ystop; - ENDBOp(); - BOp(retry_eam, e); - goto Ystop; - ENDBOp(); - BOp(thread_local, e); - goto Ystop; - ENDBOp(); - BOp(clause_with_cut, e); - goto Ystop; - ENDBOp(); */ diff --git a/H/Atoms.h b/H/Atoms.h index 4bda9a031..5a352186b 100644 --- a/H/Atoms.h +++ b/H/Atoms.h @@ -66,6 +66,23 @@ typedef struct AtomEntryStruct } AtomEntry; +// compatible with C and C++; +typedef struct ExtraAtomEntryStruct +{ + Atom NextOfAE; /* used to build hash chains */ + Prop PropsOfAE; /* property list for this atom */ +#if defined(YAPOR) || defined(THREADS) + rwlock_t ARWLock; +#endif + + union { + char uStrOfAE[4]; /* representation of atom as a string */ + wchar_t uWStrOfAE[1]; /* representation of atom as a string */ + struct atom_blob blob[1]; + } rep; +} + ExtraAtomEntry; + #define StrOfAE rep.uStrOfAE #define WStrOfAE rep.uWStrOfAE diff --git a/H/TermExt.h b/H/TermExt.h index 94ca19ad1..6c37edfd0 100755 --- a/H/TermExt.h +++ b/H/TermExt.h @@ -37,16 +37,11 @@ language. Next, we discuss support to the most important ones. #define AtomFreeTerm ((Atom)(&(((special_functors *)(NULL))->AtFreeTerm))) #define AtomNil ((Atom)(&(((special_functors *)(NULL))->AtNil))) #define AtomDot ((Atom)(&(((special_functors *)(NULL))->AtDot))) -#elif defined(THREADS) -#define AtomFoundVar AbsAtom(SF_STORE->AtFoundVar) -#define AtomFreeTerm AbsAtom(SF_STORE->AtFreeTerm) -#define AtomNil AbsAtom(SF_STORE->AtNil) -#define AtomDot AbsAtom(SF_STORE->AtDot) #else -#define AtomFoundVar AbsAtom(&(SF_STORE->AtFoundVar)) -#define AtomFreeTerm AbsAtom(&(SF_STORE->AtFreeTerm)) -#define AtomNil AbsAtom(&(SF_STORE->AtNil)) -#define AtomDot AbsAtom(&(SF_STORE->AtDot)) +#define AtomFoundVar AbsAtom((AtomEntry *)&(SF_STORE->AtFoundVar)) +#define AtomFreeTerm AbsAtom((AtomEntry *)&(SF_STORE->AtFreeTerm)) +#define AtomNil AbsAtom((AtomEntry *)&(SF_STORE->AtNil)) +#define AtomDot AbsAtom((AtomEntry *)&(SF_STORE->AtDot)) #endif #define TermFoundVar MkAtomTerm(AtomFoundVar) @@ -164,32 +159,17 @@ exts; #endif -#ifdef YAP_H +#if defined(YAP_H) /* make sure that these data structures are the first thing to be allocated in the heap when we start the system */ -#ifdef THREADS typedef struct special_functors_struct { - AtomEntry *AtFoundVar; - AtomEntry *AtFreeTerm; - AtomEntry *AtNil; - AtomEntry *AtDot; -} special_functors; -#else -typedef struct special_functors_struct -{ - AtomEntry AtFoundVar; - char AtFoundVarChars[8]; - AtomEntry AtFreeTerm; - char AtFreeTermChars[8]; - AtomEntry AtNil; - char AtNilChars[8]; - AtomEntry AtDot; - char AtDotChars[8]; + struct ExtraAtomEntryStruct AtFoundVar; + struct ExtraAtomEntryStruct AtFreeTerm; + struct ExtraAtomEntryStruct AtNil; + struct ExtraAtomEntryStruct AtDot; } special_functors; -#endif - #endif /* YAP_H */ INLINE_ONLY inline EXTERN Float CpFloatUnaligned(CELL *ptr); diff --git a/H/Yap.h b/H/Yap.h index 6b3b13674..80d247957 100755 --- a/H/Yap.h +++ b/H/Yap.h @@ -166,7 +166,7 @@ #endif /* _WIN32 */ #endif /* __MINGW32__ */ -#if HAVE_GCC +#if HAVE_GCC && !defined(__cplusplus) #define MIN_ARRAY 0 #define DUMMY_FILLER_FOR_ABS_TYPE #else diff --git a/H/Yapproto.h b/H/Yapproto.h index a4c49ed10..49e70e3ef 100755 --- a/H/Yapproto.h +++ b/H/Yapproto.h @@ -24,19 +24,19 @@ Term Yap_ArrayToList(Term *,size_t); int Yap_GetName(char *,UInt,Term); Term Yap_GetValue(Atom); int Yap_HasOp(Atom); -struct operator_entry *Yap_GetOpPropForAModuleHavingALock(AtomEntry *, Term); +struct operator_entry *Yap_GetOpPropForAModuleHavingALock(struct AtomEntryStruct *, Term); Atom Yap_LookupAtom(const char *); Atom Yap_LookupAtomWithLength(const char *, size_t); Atom Yap_LookupUTF8Atom(const char *); Atom Yap_LookupMaybeWideAtom(const wchar_t *); Atom Yap_LookupMaybeWideAtomWithLength(const wchar_t *, size_t); Atom Yap_FullLookupAtom(const char *); -void Yap_LookupAtomWithAddress(const char *,AtomEntry *); +void Yap_LookupAtomWithAddress(const char *,struct AtomEntryStruct *); Prop Yap_NewPredPropByFunctor(struct FunctorEntryStruct *, Term); Prop Yap_NewPredPropByAtom(struct AtomEntryStruct *, Term); Prop Yap_PredPropByFunctorNonThreadLocal(struct FunctorEntryStruct *, Term); Prop Yap_PredPropByAtomNonThreadLocal(struct AtomEntryStruct *, Term); -Functor Yap_UnlockedMkFunctor(AtomEntry *,unsigned int); +Functor Yap_UnlockedMkFunctor(struct AtomEntryStruct *,unsigned int); Functor Yap_MkFunctor(Atom,unsigned int); void Yap_MkFunctorWithAddress(Atom,unsigned int,FunctorEntry *); void Yap_PutValue(Atom,Term); @@ -57,7 +57,7 @@ Prop Yap_GetPredPropByAtomInThisModule(Atom, Term); Prop Yap_GetPredPropByFuncInThisModule(Functor, Term); Prop Yap_GetPredPropHavingLock(Atom,unsigned int, Term); Prop Yap_GetExpProp(Atom,unsigned int); -Prop Yap_GetExpPropHavingLock(AtomEntry *,unsigned int); +Prop Yap_GetExpPropHavingLock(struct AtomEntryStruct *,unsigned int); /* agc.c */ void Yap_atom_gc( CACHE_TYPE1 ); @@ -251,6 +251,9 @@ int Yap_DebugGetc(void); #endif int Yap_IsOpType(char *); void Yap_InitWorkspace(UInt,UInt,UInt,UInt,UInt,int,int,int); +bool Yap_AddCallToFli( struct pred_entry *pe, CPredicate call ); +bool Yap_AddRetryToFli( struct pred_entry *pe, CPredicate re ); +bool Yap_AddCutToFli( struct pred_entry *pe, CPredicate cut ); #ifdef YAPOR void Yap_init_yapor_workers(void); @@ -443,7 +446,7 @@ void Yap_swi_install(void); void Yap_InitSWIHash(void); int Yap_get_stream_handle(Term, int, int, void *); Term Yap_get_stream_position(void *); -AtomEntry *Yap_lookupBlob(void *blob, size_t len, void *type, int *newp); +struct AtomEntryStruct *Yap_lookupBlob(void *blob, size_t len, void *type, int *newp); /* opt.preds.c */ void Yap_init_optyap_preds(void); diff --git a/H/Yatom.h b/H/Yatom.h index f78ca05bc..1ac048f88 100755 --- a/H/Yatom.h +++ b/H/Yatom.h @@ -153,7 +153,7 @@ AbsFunctorProp (FunctorEntry * p) #endif -INLINE_ONLY inline EXTERN Int ArityOfFunctor (Functor); + INLINE_ONLY inline EXTERN Int ArityOfFunctor (Functor); INLINE_ONLY inline EXTERN Int ArityOfFunctor (Functor Fun) @@ -491,7 +491,7 @@ typedef enum } op_type; -OpEntry *Yap_GetOpProp(Atom, op_type CACHE_TYPE); + OpEntry *Yap_GetOpProp(Atom, op_type CACHE_TYPE); int Yap_IsPrefixOp(Atom,int *,int *); int Yap_IsOp(Atom); diff --git a/H/absmi.h b/H/absmi.h index 48ff56782..aa66d2a0c 100755 --- a/H/absmi.h +++ b/H/absmi.h @@ -2220,10 +2220,11 @@ prune(choiceptr cp USES_REGS) #include #include +#if YAP_JIT + extern Environment ExpEnv; extern char fin[1024]; -#if YAP_JIT #ifndef _NATIVE #include diff --git a/H/amijit.h b/H/amijit.h index 4a43e8af8..cb6a45a6f 100644 --- a/H/amijit.h +++ b/H/amijit.h @@ -177,9 +177,9 @@ typedef struct printt_struc { CELL msg_after; // If I print, what message should come after? } PrinttStruc; +#if YAP_JIT /* This struct represents our experimental environment for YAP */ typedef struct environment { -#if YAP_JIT // struct for analysis predicates -- all fields are modified by analysis predicates (JIT_AnalysisPreds.c) struct { CELL outfile; // Where will analysis results be printed? @@ -331,8 +331,8 @@ typedef struct environment { Int exit_on_error; // Should I exit when any error occur? } act_predicate_actions; } debug_struc; -#endif } Environment; +#endif #if YAP_JIT /* Enumeration for types of basic blocks -- used on trace construction */ diff --git a/Makefile.in b/Makefile.in index 455a4c38a..9a5617624 100755 --- a/Makefile.in +++ b/Makefile.in @@ -192,7 +192,7 @@ HEADERS = \ H/inline-only.h \ H/iopreds.h \ H/iswiatoms.h \ - H/qly.h \ +H/qly.h \ H/rclause.h \ H/rglobals.h \ H/rlocals.h \ @@ -206,8 +206,9 @@ HEADERS = \ H/YapText.h \ H/cut_c.h \ H/iatoms.h H/ratoms.h H/tatoms.h \ + CXX/yapdb.hh \ CXX/yapi.hh \ - BEAM/eam.h BEAM/eamamasm.h \ + BEAM/eam.h BEAM/eamamasm.h \ OPTYap/opt.config.h \ OPTYap/opt.proto.h OPTYap/opt.structs.h \ OPTYap/opt.macros.h OPTYap/or.macros.h \ @@ -302,7 +303,8 @@ C_SOURCES= \ # library/lammpi/yap_mpi.c library/lamm1pi/hash.c library/lammpi/prologterms2c.c CXX_SOURCES = \ CXX/yapi.cpp \ - JIT/JIT_Compiler.cpp + CXX/yapi.cpp \ + JIT/JIT_Compiler.cpp PLCONS_SOURCES = \ console/LGPL/pl-nt.c \ diff --git a/os/pl-stream.c b/os/pl-stream.c index 457260168..d66a46516 100755 --- a/os/pl-stream.c +++ b/os/pl-stream.c @@ -3764,7 +3764,7 @@ SinitStreams(void) #if HAVE_SETLINEBUF /* make sure wwe buffer on new line for ttys, eg eclipse console */ } else if (i == 1) { - setlinebuf( stdout ); + setlinebuf( stdout ); #endif } if ( s > 0) diff --git a/packages/swig/Makefile.in b/packages/swig/Makefile.in index 5474f1cd1..d13253ec2 100644 --- a/packages/swig/Makefile.in +++ b/packages/swig/Makefile.in @@ -12,6 +12,14 @@ srcdir=@srcdir@ CPPFLAGS= -I../.. -I$(srcdir)/../../H -I$(srcdir)/../../include -I$(srcdir)/../../os -I$(srcdir)/../../OPTYap -I$(srcdir)/../../BEAM -I$(srcdir)/../../CXX CXXFLAGS= $(YAP_EXTRAS) $(DEFS) $(CPPFLAGS) +YAP_SWIG_INTERFACE= $(srcdir)/yap.i \ + $(srcdir)/../../CXX/yapi.hh \ + $(srcdir)/../../CXX/yapa.hh \ + $(srcdir)/../../CXX/yapdb.hh \ + $(srcdir)/../../CXX/yapie.hh \ + $(srcdir)/../../CXX/yapq.hh \ + $(srcdir)/../../CXX/yapi.cpp + JNI_SQLITE="$(srcdir)/android/jni/sqlite" JAVA_SQLITE="$(srcdir)/android/src/org" @@ -47,7 +55,7 @@ python: $(SWIG_FILES) python/_yap.so python/yap.py python/_yap.so: python/yap_wrap.o $(CXX) -shared $(LDSOFLAGS) -o python/_yap.so python/yap_wrap.o ../../yapi.o $(LIBS) @PYTHON_LIBS@ -L ../.. -lYap -lpthread -python/yap_wrap.cpp python/yap.py: $(srcdir)/yap.i +python/yap_wrap.cpp python/yap.py: $(YAP_SWIG_INTERFACE) mkdir -p python $(SWIG) -c++ -python -outdir python -o $@ $(CXXFLAGS) -Wall $< @@ -55,13 +63,13 @@ python/yap_wrap.o: python/yap_wrap.cpp $(CXX) -c @SHLIB_CXXFLAGS@ $(CXXFLAGS) @PYTHON_INCLUDES@ $< -o $@ java: jni/libyap.@SO@ java/yap.java - cd java ; $(JAVAC) *.java; $(JAR) cvf yap.jar *.class + cd java ; $(JAVAC) *.java; $(JAR) cvf yap.jar *.class jni/libyap.@SO@: jni/yap_wrap.o $(CXX) -shared $(LDSOFLAGS) -o $@ ../../yapi.o $< $(LIBS) @JPLLDFLAGS@ -L ../.. -lYap -lpthread -jni/yap_wrap.cpp java/yap.java: $(srcdir)/yap.i - $(SWIG) -c++ -java -package pt.up.fc.dcc.yap -outdir java -o jni/yap_wrap.cpp $(CXXFLAGS) -Wall $< +jni/yap_wrap.cpp java/yap.java: $(YAP_SWIG_INTERFACE) + $(SWIG) -c++ -java -package pt.up.fc.dcc.yap -outdir java -o jni/yap_wrap.cpp $(CXXFLAGS) -Wall $< jni/yap_wrap.o: jni/yap_wrap.cpp $(CXX) -c @SHLIB_CXXFLAGS@ $(CXXFLAGS) @JPLCFLAGS@ $< -o $@ @@ -104,7 +112,7 @@ android/AndroidManifest.xml: $(ANDROID_PKG) mkdir -p android/assets/lib/Yap mkdir -p android/jni -android/jni/yap_wrap.cpp: $(srcdir)/yap.i $(srcdir)/../../CXX/yapi.hh $(srcdir)/../../CXX/yapi.cpp android/AndroidManifest.xml +android/jni/yap_wrap.cpp: $(YAP_SWIG_INTERF) android/AndroidManifest.xml $(SWIG) -c++ -java -I$(srcdir)/../../CXX -package pt.up.fc.dcc.yap -outdir android/src/pt/up/fc/dcc/yap -o android/jni/yap_wrap.cpp $< install-android: android diff --git a/packages/swig/python/demo.py b/packages/swig/python/demo.py index f43cfe70c..090312417 100644 --- a/packages/swig/python/demo.py +++ b/packages/swig/python/demo.py @@ -9,14 +9,14 @@ engine = yap.YAPEngine(); def go(): while True: s = raw_input("Prolog Query: ") - try: - q = engine.query(s) - except: - print "Oops! That was no valid number. Try again..." + q = engine.query(s) while q.next(): vs = q.namedVars(); - while vs.length() > 0: - eq = vs.car() - print eq.getArg(1).text() + " = " + eq.getArg(2).text() - vs = vs.cdr() + if vs.length() == 0: + print "yes" + else: + while vs.length() > 0: + eq = vs.car() + print eq.getArg(1).text() + " = " + eq.getArg(2).text() + vs = vs.cdr() print "no more answers" diff --git a/packages/swig/yap.i b/packages/swig/yap.i index 7b2ca1da5..6095d4628 100644 --- a/packages/swig/yap.i +++ b/packages/swig/yap.i @@ -68,6 +68,16 @@ %include "yapi.hh" +%include "yapa.hh" + +%include "yapie.hh" + +%include "yapt.hh" + +%include "yapdb.hh" + +%include "yapq.hh" + #ifdef SWIGJAVA %javaexception("java.text.ParseException") YAPPredicate { try {