YAP 7.1.0
fail_absmi_insts.h
1/*****************************************************************
2 * Failure *
3 *****************************************************************/
4
5#ifdef INDENT_CODE
6{
7#endif /* INDENT_CODE */
8
9 /* trust_fail */
10 BOp(trust_fail, e);
11 {
12 while (POP_CHOICE_POINT(B->cp_b)) {
13 POP_EXECUTE();
14 }
15 }
16#ifdef YAPOR
17 {
18 choiceptr cut_pt;
19 cut_pt = B->cp_b;
20 CUT_prune_to(cut_pt);
21 B = cut_pt;
22 }
23#else
24 B = B->cp_b;
25#endif /* YAPOR */
26 goto fail;
27 ENDBOp();
28
29#ifdef YAPOR
30shared_fail:
31 B = Get_LOCAL_top_cp();
32 SET_BB(PROTECT_FROZEN_B(B));
33 goto fail;
34#endif /* YAPOR */
35
36 /* fail */
37 PBOp(op_fail, e);
38
39 if (PP) {
40 UNLOCK(PP->PELock);
41 PP = NULL;
42 }
43#ifdef COROUTINING
44 CACHE_Y_AS_ENV(YREG);
45 check_stack(NoStackFail, HR);
46 ENDCACHE_Y_AS_ENV();
47#endif
48
49fail : {
50 register tr_fr_ptr pt0 = TR;
51#if defined(YAPOR) || defined(THREADS)
52 if (PP) {
53 UNLOCK(PP->PELock);
54 PP = NULL;
55 }
56#endif
57 PREG = B->cp_ap;
58 save_pc();
59 CACHE_TR(B->cp_tr);
60 PREFETCH_OP(PREG);
61failloop:
62 if (pt0 == S_TR) {
63 SP = SP0;
64#ifdef LOW_LEVEL_TRACER
65 if (Yap_do_low_level_trace) {
66 int go_on = true;
67 yamop *ipc = PREG;
68
69 while (go_on) {
70 op_numbers opnum = Yap_op_from_opcode(ipc->opc);
71
72 go_on = false;
73 switch (opnum) {
74#ifdef TABLING
75 case _table_load_answer:
76 low_level_trace(retry_table_loader, LOAD_CP(B)->cp_pred_entry, NULL);
77 break;
78 case _table_try_answer:
79 case _table_retry_me:
80 case _table_trust_me:
81 case _table_retry:
82 case _table_trust:
83 case _table_completion:
84#ifdef THREADS_CONSUMER_SHARING
85 case _table_answer_resolution_completion:
86#endif /* THREADS_CONSUMER_SHARING */
87#ifdef DETERMINISTIC_TABLING
88 if (IS_DET_GEN_CP(B))
89 low_level_trace(retry_table_generator, DET_GEN_CP(B)->cp_pred_entry,
90 NULL);
91 else
92#endif /* DETERMINISTIC_TABLING */
93 low_level_trace(retry_table_generator, GEN_CP(B)->cp_pred_entry,
94 (CELL *)(GEN_CP(B) + 1));
95 break;
96 case _table_answer_resolution:
97 low_level_trace(retry_table_consumer, CONS_CP(B)->cp_pred_entry,
98 NULL);
99 break;
100 case _trie_trust_var:
101 case _trie_retry_var:
102 case _trie_trust_var_in_pair:
103 case _trie_retry_var_in_pair:
104 case _trie_trust_val:
105 case _trie_retry_val:
106 case _trie_trust_val_in_pair:
107 case _trie_retry_val_in_pair:
108 case _trie_trust_atom:
109 case _trie_retry_atom:
110 case _trie_trust_atom_in_pair:
111 case _trie_retry_atom_in_pair:
112 case _trie_trust_null:
113 case _trie_retry_null:
114 case _trie_trust_null_in_pair:
115 case _trie_retry_null_in_pair:
116 case _trie_trust_pair:
117 case _trie_retry_pair:
118 case _trie_trust_appl:
119 case _trie_retry_appl:
120 case _trie_trust_appl_in_pair:
121 case _trie_retry_appl_in_pair:
122 case _trie_trust_extension:
123 case _trie_retry_extension:
124 case _trie_trust_double:
125 case _trie_retry_double:
126 case _trie_trust_longint:
127 case _trie_retry_longint:
128 case _trie_trust_gterm:
129 case _trie_retry_gterm:
130 low_level_trace(retry_table_loader, UndefHook, NULL);
131 break;
132#endif /* TABLING */
133 case _or_else:
134 case _or_last:
135 low_level_trace(retry_or, NULL, NULL);
136 break;
137 case _retry2:
138 case _retry3:
139 case _retry4:
140 ipc = NEXTOP(ipc, l);
141 go_on = true;
142 break;
143 case _jump:
144 ipc = ipc->y_u.l.l;
145 go_on = true;
146 break;
147 case _retry_c:
148 case _retry_userc:
149 //case retry_pred:
150 if (ipc->y_u.OtapFs.p->ArityOfPE)
151 low_level_trace(retry_pred, ipc->y_u.OtapFs.p, B->cp_args);
152 else
153 low_level_trace(retry_pred, ipc->y_u.OtapFs.p, NULL);
154
155 break;
156 case _retry_profiled:
157 case _count_retry:
158 ipc = NEXTOP(ipc, p);
159 go_on = true;
160 break;
161 case _retry_me:
162 case _trust_me:
163 case _count_retry_me:
164 case _count_trust_me:
165 case _profiled_retry_me:
166 case _profiled_trust_me:
167 case _retry_and_mark:
168 case _profiled_retry_and_mark:
169 case _retry:
170 case _trust:
171 if (ipc->y_u.Otapl.p && ipc->y_u.Otapl.p->ArityOfPE)
172 low_level_trace(retry_pred, ipc->y_u.Otapl.p, B->cp_args);
173 else
174 low_level_trace(retry_pred, ipc->y_u.Otapl.p, NULL);
175 break;
176 case _try_logical:
177 case _retry_logical:
178 case _profiled_retry_logical:
179 case _count_retry_logical:
180 case _trust_logical:
181 case _profiled_trust_logical:
182 case _count_trust_logical:
183 if (ipc->y_u.OtILl.d->ClPred
184 &&ipc->y_u.OtILl.d->ClPred->ArityOfPE)
185 low_level_trace(retry_pred, ipc->y_u.OtILl.d->ClPred, B->cp_args);
186 else
187 low_level_trace(retry_pred, ipc->y_u.OtILl.d->ClPred, NULL);
188 break;
189 case _Nstop:
190 case _Ystop:
191 low_level_trace(retry_pred, NULL, NULL);
192 break;
193 default:
194 break;
195 }
196 }
197 }
198#endif /* LOW_LEVEL_TRACER */
199#ifdef FROZEN_STACKS
200#ifdef YAPOR_SBA
201 if (pt0 < TR_FZ || pt0 > (ADDR)CurrentTrailTop + MinTrailGap)
202#else
203 if (pt0 < TR_FZ)
204#endif /* YAPOR_SBA */
205 {
206 TR = TR_FZ;
207 TRAIL_LINK(pt0);
208 } else
209#endif /* FROZEN_STACKS */
210 RESTORE_TR();
211 GONext();
212 }
213 BEGD(d1);
214 d1 = TrailTerm(pt0 - 1);
215 pt0--;
216 if (IsVarTerm(d1)) {
217#if defined(YAPOR_SBA) && defined(YAPOR)
218 /* clean up the trail when we backtrack */
219 if (Unsigned((Int)(d1) - (Int)(H_FZ)) >
220 Unsigned((Int)(B_FZ) - (Int)(H_FZ))) {
221 RESET_VARIABLE(STACK_TO_SBA(d1));
222 } else
223#endif
224 /* normal variable */
225 RESET_VARIABLE(d1);
226 goto failloop;
227 }
228/* pointer to code space */
229/* or updatable variable */
230#if defined(TERM_EXTENSIONS) || defined(FROZEN_STACKS) || \
231 defined(MULTI_ASSIGNMENT_VARIABLES)
232 if (IsPairTerm(d1))
233#endif /* TERM_EXTENSIONS || FROZEN_STACKS || MULTI_ASSIGNMENT_VARIABLES */
234 {
235 register CELL flags;
236 CELL *pt1 = RepPair(d1);
237#ifdef LIMIT_TABLING
238 if ((ADDR)pt1 == LOCAL_TrailBase) {
239 sg_fr_ptr sg_fr = (sg_fr_ptr)TrailVal(pt0);
240 TrailTerm(pt0) = AbsPair((CELL *)(pt0 - 1));
241 SgFr_state(sg_fr)--; /* complete_in_use --> complete : compiled_in_use -->
242 compiled */
243 insert_into_global_sg_fr_list(sg_fr);
244 goto failloop;
245 }
246#endif /* LIMIT_TABLING */
247#ifdef FROZEN_STACKS /* TRAIL */
248 /* avoid frozen segments0 */
249 if (
250#ifdef YAPOR_SBA
251 (ADDR)pt1 >= HeapTop
252#else
253 IN_BETWEEN(LOCAL_TrailBase, pt1, (ADDR)CurrentTrailTop + MinTrailGap)
254#endif /* YAPOR_SBA */
255 ) {
256 pt0 = (tr_fr_ptr)pt1;
257 goto failloop;
258 } else
259#endif /* FROZEN_STACKS */
260 if (IN_BETWEEN(H0, pt1, HR)) {
261 if (IsAttVar(pt1)) {
262 goto failloop;
263 } else {
264 TR = pt0;
265 RESET_VARIABLE(&TrailTerm(pt0));
266 RESET_VARIABLE(&TrailVal(pt0));
267 Yap_CleanOpaqueVariable(d1);
268 S_TR = B->cp_tr;
269 PREG = B->cp_ap;
270 PREFETCH_OP(PREG);
271
272 goto failloop;
273 }
274 }
275#ifdef FROZEN_STACKS /* TRAIL */
276 /* don't reset frozen variables */
277 if (pt0 < TR_FZ)
278 goto failloop;
279#endif
280 flags = *pt1;
281#if MULTIPLE_STACKS
282 if (FlagOn(DBClMask, flags)) {
283 DBRef dbr = DBStructFlagsToDBStruct(pt1);
284 int erase;
285
286 LOCK(dbr->lock);
287 DEC_DBREF_COUNT(dbr);
288 erase = (dbr->Flags & ErasedMask) && (dbr->ref_count == 0);
289 UNLOCK(dbr->lock);
290 if (erase) {
291 saveregs();
292 Yap_ErDBE(dbr);
293 setregs();
294 }
295 } else {
296 if (flags & LogUpdMask) {
297 if (flags & IndexMask) {
298 LogUpdIndex *cl = ClauseFlagsToLogUpdIndex(pt1);
299 int erase;
300#if PARALLEL_YAP
301 PredEntry *ap = cl->ClPred;
302#endif
303
304 PELOCK(8, ap);
305 DEC_CLREF_COUNT(cl);
306 erase = (cl->ClFlags & ErasedMask) && !(cl->ClRefCount);
307 if (erase) {
308 saveregs();
309 /* at this point,
310we are the only ones accessing the clause,
311hence we don't need to have a lock it */
312 Yap_ErLogUpdIndex(cl);
313 setregs();
314 } else if (cl->ClFlags & DirtyMask) {
315 saveregs();
316 /* at this point,
317we are the only ones accessing the clause,
318hence we don't need to have a lock it */
319 Yap_CleanUpIndex(cl);
320 setregs();
321 }
322 UNLOCK(ap->PELock);
323 } else {
324 LogUpdClause *cl = ClauseFlagsToLogUpdClause(pt1);
325 int erase;
326#if PARALLEL_YAP
327 PredEntry *ap = cl->ClPred;
328#endif
329 /* BB support */
330 if (ap) {
331
332 PELOCK(9, ap);
333 DEC_CLREF_COUNT(cl);
334 erase = (cl->ClFlags & ErasedMask) && !(cl->ClRefCount);
335 if (erase) {
336 saveregs();
337 /* at this point,
338we are the only ones accessing the clause,
339hence we don't need to have a lock it */
340 Yap_ErLogUpdCl(cl);
341 setregs();
342 }
343 UNLOCK(ap->PELock);
344 }
345 }
346 } else {
347 DynamicClause *cl = ClauseFlagsToDynamicClause(pt1);
348 int erase;
349
350 LOCK(cl->ClLock);
351 DEC_CLREF_COUNT(cl);
352 erase = (cl->ClFlags & ErasedMask) && !(cl->ClRefCount);
353 UNLOCK(cl->ClLock);
354 if (erase) {
355 saveregs();
356 /* at this point,
357we are the only ones accessing the clause,
358hence we don't need to have a lock it */
359 Yap_ErCl(cl);
360 setregs();
361 }
362 }
363 }
364#else
365 ResetFlag(InUseMask, flags);
366 *pt1 = flags;
367 if (FlagOn((ErasedMask | DirtyMask), flags)) {
368 if (FlagOn(DBClMask, flags)) {
369 saveregs();
370 Yap_ErDBE(DBStructFlagsToDBStruct(pt1));
371 setregs();
372 } else {
373 saveregs();
374 if (flags & LogUpdMask) {
375 if (flags & IndexMask) {
376 if (FlagOn(ErasedMask, flags)) {
377 Yap_ErLogUpdIndex(ClauseFlagsToLogUpdIndex(pt1));
378 } else {
379 Yap_CleanUpIndex(ClauseFlagsToLogUpdIndex(pt1));
380 }
381 } else {
382 Yap_ErLogUpdCl(ClauseFlagsToLogUpdClause(pt1));
383 }
384 } else {
385 Yap_ErCl(ClauseFlagsToDynamicClause(pt1));
386 }
387 setregs();
388 }
389 }
390#endif
391 goto failloop;
392 }
393#ifdef MULTI_ASSIGNMENT_VARIABLES
394 else /* if (IsApplTerm(d1)) */
395 {
396 CELL *pt = RepAppl(d1);
397/* AbsAppl means */
398/* multi-assignment variable */
399/* so the next cell is the old value */
400#ifdef FROZEN_STACKS
401 --pt0;
402 pt[0] = TrailVal(pt0);
403#else
404 pt[0] = TrailTerm(pt0 - 1);
405 pt0 -= 2;
406#endif /* FROZEN_STACKS */
407 goto failloop;
408 }
409#endif
410 ENDD(d1);
411 ENDCACHE_TR();
412}
413
414#ifdef COROUTINING
415NoStackFail:
416 BEGD(d0);
417#ifdef SHADOW_S
418 Yap_REGS.S_ = SREG;
419#endif
420 saveregs();
421 d0 = interrupt_fail(PASS_REGS1);
422 setregs();
423#ifdef SHADOW_S
424 SREG = Yap_REGS.S_;
425#endif
426 if (!d0)
427 FAIL();
428 JMPNext();
429 ENDD(d0);
430
431#endif /* COROUTINING */
432 ENDPBOp();
433#ifdef INDENT_CODE
434}
435#endif /* INDENT_CODE */
DB_STRUCT
Definition: Yatom.h:716
dynamic_clause
Definition: clause.h:101
logic_upd_clause
Definition: clause.h:64
logic_upd_index
Definition: clause.h:46
pred_entry
Definition: Yatom.h:544
subgoal_frame
Definition: tab.structs.h:296
yami
Definition: amidefs.h:264