239static char SccsId[] =
"@(#)rheap.c 1.3 3/15/90";
252#define ConstantTermAdjust(P) ConstantTermAdjust__(P PASS_REGS)
253#define DBGroundTermAdjust(P) DBGroundTermAdjust__(P PASS_REGS)
254#define AdjustDBTerm(P, A, B, C) AdjustDBTerm__(P, A, B, C PASS_REGS)
255#define AdjustSwitchTable(op, table, i) \
256 AdjustSwitchTable__(op, table, i PASS_REGS)
257#define RestoreOtaplInst(start, opc, pe) \
258 RestoreOtaplInst__(start, opc, pe PASS_REGS)
259#define RestoreDBErasedMarker() RestoreDBErasedMarker__(PASS_REGS1)
260#define RestoreLogDBErasedMarker() RestoreLogDBErasedMarker__(PASS_REGS1)
261#define RestoreForeignCode() RestoreForeignCode__(PASS_REGS1)
262#define RestoreEmptyWakeups() RestoreEmptyWakeups__(PASS_REGS1)
263#define RestoreAtoms() RestoreAtoms__(PASS_REGS1)
264#define RestoreWideAtoms() RestoreWideAtoms__(PASS_REGS1)
265#define RestoreSWIBlobs() RestoreSWIBlobs__(PASS_REGS1)
266#define RestoreSWIBlobTypes() RestoreSWIBlobTypes__(PASS_REGS1)
267#define RestoreInvisibleAtoms() RestoreInvisibleAtoms__(PASS_REGS1)
268#define RestorePredHash() RestorePredHash__(PASS_REGS1)
269#define RestoreHiddenPredicates() RestoreHiddenPredicates__(PASS_REGS1)
270#define RestoreDBTermsList() RestoreDBTermsList__(PASS_REGS1)
271#define RestoreExpandList() RestoreExpandList__(PASS_REGS1)
272#define RestoreIntKeys() RestoreIntKeys__(PASS_REGS1)
273#define RestoreIntLUKeys() RestoreIntLUKeys__(PASS_REGS1)
274#define RestoreIntBBKeys() RestoreIntBBKeys__(PASS_REGS1)
275#define RestoreDeadStaticClauses() RestoreDeadStaticClauses__(PASS_REGS1)
276#define RestoreDeadMegaClauses() RestoreDeadMegaClauses__(PASS_REGS1)
277#define RestoreDeadStaticIndices() RestoreDeadStaticIndices__(PASS_REGS1)
278#define RestoreDBErasedList() RestoreDBErasedList__(PASS_REGS1)
279#define RestoreDBErasedIList() RestoreDBErasedIList__(PASS_REGS1)
280#define RestoreYapRecords() RestoreYapRecords__(PASS_REGS1)
281static Term ConstantTermAdjust__(Term t USES_REGS) {
283 return AtomTermAdjust(t);
287static Term DBGroundTermAdjust__(Term t USES_REGS) {
290 return AbsPair(PtoHeapCellAdjust(RepPair(t)));
292 return AbsAppl(PtoHeapCellAdjust(RepAppl(t)));
298static void do_clean_susp_clauses(
yamop *ipc USES_REGS) {
302 ipc->opc = Yap_opcode(_expand_clauses);
303 ipc->y_u.sssllp.p = PtoPredAdjust(ipc->y_u.sssllp.p);
304 if (ipc->y_u.sssllp.sprev) {
305 ipc->y_u.sssllp.sprev = PtoOpAdjust(ipc->y_u.sssllp.sprev);
307 if (ipc->y_u.sssllp.snext) {
308 ipc->y_u.sssllp.snext = PtoOpAdjust(ipc->y_u.sssllp.snext);
310 for (i = 0; i < ipc->y_u.sssllp.s1; i++, st++) {
312 *st = PtoOpAdjust(*st);
317static void AdjustSwitchTable__(op_numbers op,
yamop *table,
319 CELL *startcode = (CELL *)table;
324 case _switch_on_func: {
329 for (j = 0; j < i; j++) {
331 CODEADDR oldjmp = (CODEADDR)(oldcode[1]);
333 oldcode[0] = (CELL)FuncAdjust(oldfunc);
335 oldcode[1] = (CELL)CodeAddrAdjust(oldjmp);
338 rehash(startcode, i, Funcs PASS_REGS);
340 case _switch_on_cons: {
344#if !defined(USE_OFFSETS)
347 for (j = 0; j < i; j++) {
348 Term oldcons = oldcode[0];
349 CODEADDR oldjmp = (CODEADDR)(oldcode[1]);
350 if (oldcons != 0x0 && IsAtomTerm(oldcons)) {
351 oldcode[0] = AtomTermAdjust(oldcons);
353 oldcode[1] = (CELL)CodeAddrAdjust(oldjmp);
357 rehash(startcode, i, Atomics PASS_REGS);
363 startcode[0] = (CELL)FuncAdjust(oldfunc);
364 startcode[1] = (CELL)CodeAddrAdjust((CODEADDR)startcode[1]);
365 startcode[3] = (CELL)CodeAddrAdjust((CODEADDR)startcode[3]);
368 Term oldcons = startcode[0];
370 if (IsAtomTerm(oldcons)) {
371 startcode[0] = AtomTermAdjust(oldcons);
373 startcode[1] = (CELL)CodeAddrAdjust((CODEADDR)startcode[1]);
374 startcode[3] = (CELL)CodeAddrAdjust((CODEADDR)startcode[3]);
379 for (j = 0; j < i; j++) {
381 CODEADDR oldjmp = (CODEADDR)(startcode[1]);
382 startcode[0] = (CELL)FuncAdjust(oldfunc);
383 startcode[1] = (CELL)CodeAddrAdjust(oldjmp);
388 startcode[1] = (CELL)CodeAddrAdjust((CODEADDR)startcode[1]);
393 for (j = 0; j < i; j++) {
394 Term oldcons = startcode[0];
395 CODEADDR oldjmp = (CODEADDR)(startcode[1]);
396 if (IsAtomTerm(oldcons)) {
397 startcode[0] = (CELL)AtomTermAdjust(oldcons);
399 startcode[1] = (CELL)CodeAddrAdjust(oldjmp);
403 startcode[1] = (CELL)CodeAddrAdjust((CODEADDR)startcode[1]);
406 Yap_Error(SYSTEM_ERROR_INTERNAL, 0L,
407 "Opcode Not Implemented in AdjustSwitchTable");
411static void RestoreAtomList(
Atom CACHE_TYPE);
412static void RestoreAtom(
AtomEntry *CACHE_TYPE);
413static void RestoreHashPreds(CACHE_TYPE1);
415static void RestoreAtoms__(USES_REGS1) {
419 HashChain = PtoAtomHashEntryAdjust(HashChain);
421 for (i = 0; i < AtomHashTableSize; ++i) {
422 HashPtr->Entry = NoAGCAtomAdjust(HashPtr->Entry);
423 RestoreAtomList(HashPtr->Entry PASS_REGS);
428static void RestoreWideAtoms__(USES_REGS1) {
432 WideHashChain = PtoAtomHashEntryAdjust(WideHashChain);
433 HashPtr = WideHashChain;
434 for (i = 0; i < WideAtomHashTableSize; ++i) {
435 HashPtr->Entry = AtomAdjust(HashPtr->Entry);
436 RestoreAtomList(HashPtr->Entry PASS_REGS);
441static void RestoreInvisibleAtoms__(USES_REGS1) {
442 INVISIBLECHAIN.Entry = AtomAdjust(INVISIBLECHAIN.Entry);
443 RestoreAtomList(INVISIBLECHAIN.Entry PASS_REGS);
444 RestoreAtom(RepAtom(AtomFoundVar) PASS_REGS);
445 RestoreAtom(RepAtom(AtomFreeTerm) PASS_REGS);
451static Term AdjustDBTerm__(Term trm, Term *p_base, Term *p_lim,
452 Term *p_max USES_REGS) {
454 return CodeVarAdjust(trm);
456 return AtomTermAdjust(trm);
457 if (IsPairTerm(trm)) {
461 p = PtoHeapCellAdjust(RepPair(trm));
464 if (p >= p_base || p < p_lim) {
465 p[0] = AdjustDBTerm(p[0], p, p_lim, p_max);
466 if (IsPairTerm(p[1])) {
468 Term *newp = PtoHeapCellAdjust(RepPair(p[1]));
469 p[1] = AbsPair(newp);
474 p[1] = AdjustDBTerm(p[1], p, p_lim, p_max);
479 if (IsApplTerm(trm)) {
482 Term *p0 = p = PtoHeapCellAdjust(RepAppl(trm));
485 if (p >= p_base || p < p_lim) {
486 if (p >= p_max || p < p_lim) {
487 if (DBRefOfTerm(trm) != DBRefAdjust(DBRefOfTerm(trm), FALSE))
489 return MkDBRefTerm(DBRefAdjust(DBRefOfTerm(trm), FALSE));
492 if (!IsExtensionFunctor(f)) {
497 Arity = ArityOfFunctor(f);
498 for (i = 0; i < Arity; ++i) {
499 *p = AdjustDBTerm(*p, p0, p_lim, p_max);
502 }
else if (f == FunctorDBRef) {
510static void RestoreDBTerm(
DBTerm *dbr,
bool src,
int attachments USES_REGS) {
513 if (attachments == 1 && dbr->ag.attachments)
514 dbr->ag.attachments =
515 AdjustDBTerm(dbr->ag.attachments, dbr->Contents, dbr->Contents,
516 dbr->Contents + dbr->NOfCells);
520 dbr->ag.NextDBT = DBTermAdjust(dbr->ag.NextDBT);
526 dbr->DBRefs = DBRefPAdjust(dbr->DBRefs);
528 while ((tm = *--cp) != 0) {
529 *cp = DBRefAdjust(tm, TRUE);
532 dbr->Entry = AdjustDBTerm(dbr->Entry, dbr->Contents, dbr->Contents,
533 dbr->Contents + dbr->NOfCells);
538static void RestoreEmptyWakeups__(USES_REGS1) {
540 for (i = 0; i < MaxEmptyWakeups; i++) {
541 EmptyWakeups[i] = AtomAdjust(EmptyWakeups[i]);
546static void RestoreStaticClause(
StaticClause *cl USES_REGS)
552 if (cl->ClFlags & SrcMask && !(cl->ClFlags & FactMask)) {
553 cl->usc.ClSource = DBTermAdjust(cl->usc.ClSource);
554 RestoreDBTerm(cl->usc.ClSource,
true, 2 PASS_REGS);
557 cl->ClNext = PtoStCAdjust(cl->ClNext);
559 restore_opcodes(cl->ClCode, NULL PASS_REGS);
563static void RestoreMegaClause(
MegaClause *cl USES_REGS)
569 yamop *ptr, *max, *nextptr;
571 cl->ClPred = PtoPredAdjust(cl->ClPred);
573 cl->ClNext = (
MegaClause *)AddrAdjust((ADDR)(cl->ClNext));
575 max = (
yamop *)((CODEADDR)cl + cl->ClSize);
577 if (cl->ClFlags & ExoMask) {
578 CELL *base = (CELL *)((ADDR)cl->ClCode + 2 *
sizeof(
struct index_t *));
579 CELL *end = (CELL *)max, *ptr;
581 for (ptr = base; ptr < end; ptr++) {
584 *ptr = AtomTermAdjust(t);
588 for (ptr = cl->ClCode; ptr < max;) {
589 nextptr = (
yamop *)((
char *)ptr + cl->ClItemSize);
590 restore_opcodes(ptr, nextptr PASS_REGS);
603 if (cl->ClPrevious != NULL) {
604 cl->ClPrevious = PtoOpAdjust(cl->ClPrevious);
606 INIT_LOCK(cl->ClLock);
607 restore_opcodes(cl->ClCode, NULL PASS_REGS);
618 if (cl->ClFlags & LogUpdRuleMask) {
619 cl->ClExt = PtoOpAdjust(cl->ClExt);
621 if (!(cl->ClFlags & FactMask)) {
622 cl->lusl.ClSource = DBTermAdjust(cl->lusl.ClSource);
623 RestoreDBTerm(cl->lusl.ClSource,
true, 2 PASS_REGS);
626 cl->ClPrev = PtoLUCAdjust(cl->ClPrev);
629 cl->ClNext = PtoLUCAdjust(cl->ClNext);
631 cl->ClPred = PtoPredAdjust(cl->ClPred);
632 restore_opcodes(cl->ClCode, NULL PASS_REGS);
635static void RestoreDBTermEntry(
struct dbterm_list *dbl USES_REGS) {
639 dbt = dbl->dbterms = DBTermAdjust(dbl->dbterms);
642 dbl->clause_code = PtoOpAdjust(dbl->clause_code);
644 dbl->next_dbl = PtoDBTLAdjust(dbl->next_dbl);
645 dbl->p = PredEntryAdjust(dbl->p);
647 RestoreDBTerm(dbt,
false, 0 PASS_REGS);
648 dbt = dbt->ag.NextDBT;
652static void CleanLUIndex(
LogUpdIndex *idx,
int recurse USES_REGS) {
654 idx->ClPred = PtoPredAdjust(idx->ClPred);
655 if (idx->ParentIndex)
656 idx->ParentIndex = LUIndexAdjust(idx->ParentIndex);
657 if (idx->PrevSiblingIndex) {
658 idx->PrevSiblingIndex = LUIndexAdjust(idx->PrevSiblingIndex);
660 if (idx->SiblingIndex) {
661 idx->SiblingIndex = LUIndexAdjust(idx->SiblingIndex);
663 CleanLUIndex(idx->SiblingIndex, TRUE PASS_REGS);
665 if (idx->ChildIndex) {
666 idx->ChildIndex = LUIndexAdjust(idx->ChildIndex);
668 CleanLUIndex(idx->ChildIndex, TRUE PASS_REGS);
670 if (!(idx->ClFlags & SwitchTableMask)) {
671 restore_opcodes(idx->ClCode, NULL PASS_REGS);
675static void CleanSIndex(
StaticIndex *idx,
int recurse USES_REGS) {
677 if (!(idx->ClFlags & SwitchTableMask)) {
678 restore_opcodes(idx->ClCode, NULL PASS_REGS);
680 idx->ClPred = PtoPredAdjust(idx->ClPred);
681 if (idx->ChildIndex) {
682 idx->ChildIndex = SIndexAdjust(idx->ChildIndex);
684 CleanSIndex(idx->ChildIndex, TRUE PASS_REGS);
686 if (idx->SiblingIndex) {
687 idx->SiblingIndex = SIndexAdjust(idx->SiblingIndex);
690 idx = idx->SiblingIndex;
696#define RestoreBlobTypes() RestoreBlobTypes__(PASS_REGS1)
697#define RestoreBlobs() RestoreBlobs__(PASS_REGS1);
699static void RestoreBlobTypes__(USES_REGS1) {}
701static void RestoreBlobs__(USES_REGS1) {
702 Blobs = AtomAdjust(Blobs);
703 RestoreAtomList(Blobs PASS_REGS);
706static void RestoreHiddenPredicates__(USES_REGS1) {
707 HIDDEN_PREDICATES = PropAdjust(HIDDEN_PREDICATES);
708 RestoreEntries(HIDDEN_PREDICATES, TRUE PASS_REGS);
711static void RestorePredHash__(USES_REGS1) {
712 PredHash = PtoPtoPredAdjust(PredHash);
713 if (PredHash == NULL) {
714 Yap_Error(SYSTEM_ERROR_FATAL, MkIntTerm(0),
715 "restore should find predicate hash table");
717 REINIT_RWLOCK(PredHashRWLock);
718 RestoreHashPreds(PASS_REGS1);
721static void RestoreEnvInst(
yamop start[2],
yamop **instp, op_numbers opc,
725 ipc->opc = Yap_opcode(_call);
726 ipc->y_u.Osbpp.p = pred;
727 ipc->y_u.Osbpp.p0 = pred;
728 ipc->y_u.Osbpp.bmap = NULL;
729 ipc->y_u.Osbpp.s = -Signed(RealEnvSize);
730 ipc = NEXTOP(ipc, Osbpp);
731 ipc->opc = Yap_opcode(opc);
735static void RestoreOtaplInst__(
yamop start[1], OPCODE opc,
740 ipc->opc = Yap_opcode(opc);
741 ipc->y_u.Otapl.s = 0;
742 ipc->y_u.Otapl.p = pe;
743 if (ipc->y_u.Otapl.d)
744 ipc->y_u.Otapl.d = PtoOpAdjust(ipc->y_u.Otapl.d);
746 INIT_YAMOP_LTT(ipc, 1);
749 ipc->y_u.Otapl.te = NULL;
753static void RestoreDBTermsList__(USES_REGS1) {
755 struct dbterm_list *dbl = PtoDBTLAdjust(DBTermsList);
758 RestoreDBTermEntry(dbl PASS_REGS);
764static void RestoreExpandList__(USES_REGS1) {
765 if (ExpandClausesFirst)
766 ExpandClausesFirst = PtoOpAdjust(ExpandClausesFirst);
767 if (ExpandClausesLast)
768 ExpandClausesLast = PtoOpAdjust(ExpandClausesLast);
770 yamop *ptr = ExpandClausesFirst;
772 do_clean_susp_clauses(ptr PASS_REGS);
773 ptr = ptr->y_u.sssllp.snext;
778static void RestoreUdiControlBlocks(
void) {}
780static void RestoreIntKeys__(USES_REGS1) {
781 if (INT_KEYS != NULL) {
782 INT_KEYS = (
Prop *)AddrAdjust((ADDR)(INT_KEYS));
785 for (i = 0; i < INT_KEYS_SIZE; i++) {
786 if (INT_KEYS[i] != NIL) {
787 Prop p0 = INT_KEYS[i] = PropAdjust(INT_KEYS[i]);
788 RestoreEntries(RepProp(p0), TRUE PASS_REGS);
795static void RestoreIntLUKeys__(USES_REGS1) {
796 if (INT_LU_KEYS != NULL) {
797 INT_LU_KEYS = (
Prop *)AddrAdjust((ADDR)(INT_LU_KEYS));
800 for (i = 0; i < INT_KEYS_SIZE; i++) {
801 Prop p0 = INT_LU_KEYS[i];
807 pe->NextOfPE = PropAdjust(pe->NextOfPE);
808 CleanCode(pe PASS_REGS);
809 p0 = RepProp(pe->NextOfPE);
817static void RestoreIntBBKeys__(USES_REGS1) {
818 if (INT_BB_KEYS != NULL) {
819 INT_BB_KEYS = (
Prop *)AddrAdjust((ADDR)(INT_BB_KEYS));
822 for (i = 0; i < INT_BB_KEYS_SIZE; i++) {
823 if (INT_BB_KEYS[i] != NIL) {
824 Prop p0 = INT_BB_KEYS[i] = PropAdjust(INT_BB_KEYS[i]);
825 RestoreEntries(RepProp(p0), TRUE PASS_REGS);
832static void RestoreDBErasedMarker__(USES_REGS1) {
833 DBErasedMarker = DBRefAdjust(DBErasedMarker, TRUE);
834 DBErasedMarker->id = FunctorDBRef;
835 DBErasedMarker->Flags = ErasedMask;
836 DBErasedMarker->Code = NULL;
837 DBErasedMarker->DBT.DBRefs = NULL;
838 DBErasedMarker->Parent = NULL;
841static void RestoreLogDBErasedMarker__(USES_REGS1) {
842 LogDBErasedMarker = PtoLUCAdjust(LogDBErasedMarker);
843 LogDBErasedMarker->Id = FunctorDBRef;
844 LogDBErasedMarker->ClFlags = ErasedMask | LogUpdMask;
845 LogDBErasedMarker->lusl.ClSource = NULL;
846 LogDBErasedMarker->ClRefCount = 0;
847 LogDBErasedMarker->ClPred = PredLogUpdClause;
848 LogDBErasedMarker->ClExt = NULL;
849 LogDBErasedMarker->ClPrev = NULL;
850 LogDBErasedMarker->ClNext = NULL;
851 LogDBErasedMarker->ClSize = (UInt)NEXTOP(((
LogUpdClause *)NULL)->ClCode, e);
852 LogDBErasedMarker->ClCode->opc = Yap_opcode(_op_fail);
853 INIT_CLREF_COUNT(LogDBErasedMarker);
856static void RestoreDeadStaticClauses__(USES_REGS1) {
857 if (DeadStaticClauses) {
859 DeadStaticClauses = sc;
861 RestoreStaticClause(sc PASS_REGS);
867static void RestoreDeadMegaClauses__(USES_REGS1) {
868 if (DeadMegaClauses) {
870 DeadMegaClauses = mc;
872 RestoreMegaClause(mc PASS_REGS);
878static void RestoreDeadStaticIndices__(USES_REGS1) {
879 if (DeadStaticIndices) {
881 DeadStaticIndices = si;
883 CleanSIndex(si, FALSE PASS_REGS);
884 si = si->SiblingIndex;
889static void RestoreDBErasedList__(USES_REGS1) {
891 LogUpdClause *lcl = DBErasedList = PtoLUCAdjust(DBErasedList);
893 RestoreLUClause(lcl, FALSE PASS_REGS);
899static void RestoreDBErasedIList__(USES_REGS1) {
901 LogUpdIndex *icl = DBErasedIList = LUIndexAdjust(DBErasedIList);
903 CleanLUIndex(icl, FALSE PASS_REGS);
904 icl = icl->SiblingIndex;
909static void RestoreForeignCode__(USES_REGS1) {
912 if (!ForeignCodeLoaded)
914 if (ForeignCodeLoaded != NULL)
915 ForeignCodeLoaded = (
void *)AddrAdjust((ADDR)ForeignCodeLoaded);
916 f_code = ForeignCodeLoaded;
917 while (f_code != NULL) {
919 if (f_code->objs != NULL)
920 f_code->objs = (
StringList)AddrAdjust((ADDR)f_code->objs);
922 while (objs != NULL) {
923 if (objs->next != NULL)
924 objs->next = (
StringList)AddrAdjust((ADDR)objs->next);
925 objs->name = AtomAdjust(objs->name);
928 if (f_code->libs != NULL)
929 f_code->libs = (
StringList)AddrAdjust((ADDR)f_code->libs);
931 while (libs != NULL) {
932 if (libs->next != NULL)
933 libs->next = (
StringList)AddrAdjust((ADDR)libs->next);
934 libs->name = AtomAdjust(libs->name);
937 if (f_code->f != NULL) {
938 f_code->f = AtomAdjust(f_code->f);
940 if (f_code->next != NULL)
941 f_code->next = (
ForeignObj *)AddrAdjust((ADDR)f_code->next);
942 f_code = f_code->next;
946static void RestoreBallTerm(
int wid) {
948 if (LOCAL_UserTerm) {
949 DBTerm *dv = DBTermAdjust(AddressOfTerm(LOCAL_UserTerm));
950 LOCAL_UserTerm = MkAddressTerm(dv);
951 RestoreDBTerm(dv,
false, 1 PASS_REGS);
955static void RestoreYapRecords__(USES_REGS1) {
958 RestoreBallTerm(worker_id);
959 Yap_Records = DBRecordAdjust(Yap_Records);
962 ptr->next_rec = DBRecordAdjust(ptr->next_rec);
963 ptr->prev_rec = DBRecordAdjust(ptr->prev_rec);
964 ptr->dbrecord = DBTermAdjust(ptr->dbrecord);
965 RestoreDBTerm(ptr->dbrecord,
false, 0 PASS_REGS);
970#if defined(THREADS) || defined(YAPOR)
977static void restore_codes(
void) {
979 HeapTop = AddrAdjust(LOCAL_OldHeapTop);
983 RestoreWorker(worker_id PASS_REGS);
986static void RestoreDBEntry(
DBRef dbr USES_REGS) {
988 fprintf(stderr,
"Restoring at %x", dbr);
989 if (dbr->Flags & DBAtomic)
990 fprintf(stderr,
" an atomic term\n");
991 else if (dbr->Flags & DBNoVars)
992 fprintf(stderr,
" with no vars\n");
993 else if (dbr->Flags & DBComplex)
994 fprintf(stderr,
" complex term\n");
995 else if (dbr->Flags & DBIsRef)
996 fprintf(stderr,
" a ref\n");
998 fprintf(stderr,
" a var\n");
1000 RestoreDBTerm(&(dbr->DBT),
true, 1 PASS_REGS);
1002 dbr->Parent = (
DBProp)AddrAdjust((ADDR)(dbr->Parent));
1004 if (dbr->Code != NULL)
1005 dbr->Code = PtoOpAdjust(dbr->Code);
1006 if (dbr->Prev != NULL)
1007 dbr->Prev = DBRefAdjust(dbr->Prev, TRUE);
1008 if (dbr->Next != NULL)
1009 dbr->Next = DBRefAdjust(dbr->Next, TRUE);
1010#ifdef DEBUG_RESTORE2
1011 fprintf(stderr,
"Recomputing masks\n");
1013 recompute_mask(dbr);
1017static void RestoreDB(
DBEntry *pp USES_REGS) {
1020 if (pp->First != NULL)
1021 pp->First = DBRefAdjust(pp->First, TRUE);
1022 if (pp->Last != NULL)
1023 pp->Last = DBRefAdjust(pp->Last, TRUE);
1025 pp->FunctorOfDB = FuncAdjust(pp->FunctorOfDB);
1027 pp->FunctorOfDB = (
Functor)AtomAdjust((
Atom)(pp->FunctorOfDB));
1029 pp->F0 = DBRefAdjust(pp->F0, TRUE);
1031 pp->L0 = DBRefAdjust(pp->L0, TRUE);
1036 RestoreDBEntry(dbr PASS_REGS);
1038 dbr->n = DBRefAdjust(dbr->n, TRUE);
1040 dbr->p = DBRefAdjust(dbr->p, TRUE);
1052 if (pp->PredFlags & LogUpdatePredFlag) {
1054 while (cl != NULL) {
1055 RestoreLUClause(cl, pp PASS_REGS);
1058 }
else if (pp->PredFlags & MegaClausePredFlag) {
1059 MegaClause *cl = ClauseCodeToMegaClause(First);
1061 RestoreMegaClause(cl PASS_REGS);
1062 }
else if (pp->PredFlags & DynamicPredFlag) {
1066 RestoreDynamicClause(ClauseCodeToDynamicClause(cl), pp PASS_REGS);
1069 cl = NextDynamicClause(cl);
1075 RestoreStaticClause(cl PASS_REGS);
1076 if (cl->ClCode == Last)
1085 Term t = pp->Element;
1087 if (!IsVarTerm(t)) {
1088 if (IsAtomicTerm(t)) {
1089 if (IsAtomTerm(t)) {
1090 pp->Element = AtomTermAdjust(t);
1093 RestoreLUClause((
LogUpdClause *)DBRefOfTerm(t), NULL PASS_REGS);
1098 pp->KeyOfBB = AtomAdjust(pp->KeyOfBB);
1100 if (pp->ModuleOfBB) {
1101 pp->ModuleOfBB = AtomTermAdjust(pp->ModuleOfBB);
1106 Int sz = -ae->ArrayEArity;
1107 switch (ae->ArrayType) {
1109 case array_of_doubles:
1110 case array_of_chars:
1111 case array_of_uchars:
1113 case array_of_ptrs: {
1116 ae->ValueOfVE.ptrs = base;
1118 for (i = 0; i < sz; i++) {
1122 }
else if (IsOldCode((CELL)reg)) {
1123 *base++ = AtomEntryAdjust(reg);
1124 }
else if (IsOldLocalInTR((CELL)reg)) {
1125 *base++ = (
AtomEntry *)LocalAddrAdjust((ADDR)reg);
1126 }
else if (IsOldGlobal((CELL)reg)) {
1127 *base++ = (
AtomEntry *)GlobalAddrAdjust((ADDR)reg);
1128 }
else if (IsOldTrail((CELL)reg)) {
1129 *base++ = (
AtomEntry *)TrailAddrAdjust((ADDR)reg);
1138 case array_of_atoms: {
1139 Term *base = (Term *)AddrAdjust((ADDR)(ae->ValueOfVE.atoms));
1141 ae->ValueOfVE.atoms = base;
1143 for (i = 0; i < sz; i++) {
1148 *base++ = AtomTermAdjust(reg);
1154 case array_of_dbrefs: {
1155 Term *base = (Term *)AddrAdjust((ADDR)(ae->ValueOfVE.dbrefs));
1158 ae->ValueOfVE.dbrefs = base;
1160 for (i = 0; i < sz; i++) {
1165 *base++ = AbsAppl(PtoHeapCellAdjust(RepAppl(reg)));
1171 case array_of_nb_terms: {
1175 ae->ValueOfVE.lterms = base;
1177 for (i = 0; i < sz; i++, base++) {
1178 Term reg = base->tlive;
1179 if (IsVarTerm(reg)) {
1180 CELL *var = (CELL *)reg;
1182 if (IsOldGlobalPtr(var)) {
1183 base->tlive = (CELL)PtoGloAdjust(var);
1185 base->tlive = (CELL)PtoHeapCellAdjust(var);
1187 }
else if (IsAtomTerm(reg)) {
1188 base->tlive = AtomTermAdjust(reg);
1189 }
else if (IsApplTerm(reg)) {
1190 CELL *db = RepAppl(reg);
1191 db = PtoGloAdjust(db);
1192 base->tlive = AbsAppl(db);
1193 }
else if (IsApplTerm(reg)) {
1194 CELL *db = RepPair(reg);
1195 db = PtoGloAdjust(db);
1196 base->tlive = AbsPair(db);
1200 if (IsVarTerm(reg)) {
1201 base->tstore = (Term)GlobalAddrAdjust((ADDR)reg);
1202 }
else if (IsAtomTerm(reg)) {
1203 base->tstore = AtomTermAdjust(reg);
1206 db = DBTermAdjust(db);
1207 RestoreDBTerm(db,
false, 1 PASS_REGS);
1208 base->tstore = AbsAppl((CELL *)db);
1213 case array_of_terms: {
1214 DBTerm **base = (
DBTerm **)AddrAdjust((ADDR)(ae->ValueOfVE.terms));
1217 ae->ValueOfVE.terms = base;
1219 for (i = 0; i < sz; i++) {
1224 *base++ = reg = DBTermAdjust(reg);
1225 RestoreDBTerm(reg,
false, 1 PASS_REGS);
1238static void CleanCode(
PredEntry *pp USES_REGS) {
1242 if (pp->ModuleOfPred) {
1243 pp->ModuleOfPred = AtomTermAdjust(pp->ModuleOfPred);
1245 if (pp->ArityOfPE) {
1246 if (pp->ModuleOfPred == IDB_MODULE) {
1247 if (pp->PredFlags & NumberDBPredFlag) {
1249 }
else if (pp->PredFlags & AtomDBPredFlag) {
1250 pp->FunctorOfPred = (
Functor)AtomAdjust((
Atom)(pp->FunctorOfPred));
1252 pp->FunctorOfPred = FuncAdjust(pp->FunctorOfPred);
1255 pp->FunctorOfPred = FuncAdjust(pp->FunctorOfPred);
1258 pp->FunctorOfPred = (
Functor)AtomAdjust((
Atom)(pp->FunctorOfPred));
1260 if (!(pp->PredFlags & NumberDBPredFlag)) {
1261 if (pp->src.OwnerFile) {
1262 pp->src.OwnerFile = AtomAdjust(pp->src.OwnerFile);
1265 pp->OpcodeOfPred = Yap_opcode(Yap_op_from_opcode(pp->OpcodeOfPred));
1266 if (pp->NextPredOfModule) {
1267 pp->NextPredOfModule = PtoPredAdjust(pp->NextPredOfModule);
1269 if (pp->PredFlags & (AsmPredFlag | CPredFlag)) {
1271 if (pp->CodeOfPred) {
1272 pp->CodeOfPred = PtoOpAdjust(pp->CodeOfPred);
1273 CleanClauses(pp->CodeOfPred, pp->CodeOfPred, pp PASS_REGS);
1276 yamop *FirstC, *LastC;
1278 if (pp->cs.p_code.FirstClause)
1279 pp->cs.p_code.FirstClause = PtoOpAdjust(pp->cs.p_code.FirstClause);
1280 if (pp->cs.p_code.LastClause)
1281 pp->cs.p_code.LastClause = PtoOpAdjust(pp->cs.p_code.LastClause);
1282 pp->CodeOfPred = PtoOpAdjust(pp->CodeOfPred);
1283 pp->cs.p_code.TrueCodeOfPred = PtoOpAdjust(pp->cs.p_code.TrueCodeOfPred);
1284 pp->cs.p_code.ExpandCode = Yap_opcode(_expand_index);
1285 flag = pp->PredFlags;
1286 FirstC = pp->cs.p_code.FirstClause;
1287 LastC = pp->cs.p_code.LastClause;
1289 if (FirstC == NULL && LastC == NULL) {
1292#ifdef DEBUG_RESTORE2
1293 fprintf(stderr,
"at %lx Correcting clauses from %p to %p\n",
1294 *(OPCODE *)FirstC, FirstC, LastC);
1296 CleanClauses(FirstC, LastC, pp PASS_REGS);
1297 if (flag & IndexedPredFlag) {
1298#ifdef DEBUG_RESTORE2
1299 fprintf(stderr,
"Correcting indexed code\n");
1301 if (flag & LogUpdatePredFlag) {
1302 CleanLUIndex(ClauseCodeToLogUpdIndex(pp->cs.p_code.TrueCodeOfPred),
1305 CleanSIndex(ClauseCodeToStaticIndex(pp->cs.p_code.TrueCodeOfPred),
1308 }
else if (flag & DynamicPredFlag) {
1309#ifdef DEBUG_RESTORE2
1310 fprintf(stderr,
"Correcting dynamic code\n");
1312 RestoreDynamicClause(
1313 ClauseCodeToDynamicClause(pp->cs.p_code.TrueCodeOfPred),
1324static void RestoreEntries(
PropEntry *pp,
int int_key USES_REGS) {
1325 while (!EndOfPAEntr(pp)) {
1326 switch (pp->KindOfPE) {
1327 case FunctorProperty: {
1330 fe->NextOfPE = PropAdjust(fe->NextOfPE);
1331 fe->NameOfFE = AtomAdjust(fe->NameOfFE);
1332 p0 = fe->PropsOfFE = PropAdjust(fe->PropsOfFE);
1333 if (!EndOfPAEntr(p0)) {
1335 CleanCode(RepPredProp(p0) PASS_REGS);
1336 RepPredProp(p0)->NextOfPE = PropAdjust(RepPredProp(p0)->NextOfPE);
1341 Term tv = ve->ValueOfVE;
1342 ve->NextOfPE = PropAdjust(ve->NextOfPE);
1344 ve->ValueOfVE = AtomTermAdjust(tv);
1346 case HoldProperty: {
1348 he->NextOfPE = PropAdjust(he->NextOfPE);
1350 case MutexProperty: {
1352 he->NextOfPE = PropAdjust(he->NextOfPE);
1354 case TranslationProperty: {
1356 he->NextOfPE = PropAdjust(he->NextOfPE);
1358 case FlagProperty: {
1360 he->NextOfPE = PropAdjust(he->NextOfPE);
1362 case ArrayProperty: {
1364 ae->NextOfPE = PropAdjust(ae->NextOfPE);
1365 if (ae->TypeOfAE == STATIC_ARRAY) {
1369 sae->NextAE = PtoArraySAdjust(sae->NextAE);
1370 restore_static_array(sae PASS_REGS);
1373 ae->NextAE = PtoArrayEAdjust(ae->NextAE);
1374 if (IsVarTerm(ae->ValueOfVE))
1375 RESET_VARIABLE(&(ae->ValueOfVE));
1377 CELL *ptr = RepAppl(ae->ValueOfVE);
1383 if (IsOldGlobalPtr(ptr)) {
1384 ae->ValueOfVE = AbsAppl(PtoGloAdjust(ptr));
1385 }
else if (IsOldCodeCellPtr(ptr)) {
1386 ae->ValueOfVE = AbsAppl(PtoHeapCellAdjust(ptr));
1387 }
else if (IsOldLocalInTRPtr(ptr)) {
1388 ae->ValueOfVE = AbsAppl(PtoLocAdjust(ptr));
1389 }
else if (IsOldTrailPtr(ptr)) {
1390 ae->ValueOfVE = AbsAppl(CellPtoTRAdjust(ptr));
1397 pe->NextOfPE = PropAdjust(pe->NextOfPE);
1398 CleanCode(pe PASS_REGS);
1401 case CodeDBProperty:
1402#ifdef DEBUG_RESTORE2
1403 fprintf(stderr,
"Correcting data base clause at %p\n", pp);
1407 de->NextOfPE = PropAdjust(de->NextOfPE);
1408 RestoreDB(de PASS_REGS);
1413 bb->NextOfPE = PropAdjust(bb->NextOfPE);
1414 RestoreBB(bb, int_key PASS_REGS);
1416 case GlobalProperty: {
1418 Term gbt = gb->global;
1420 gb->NextOfPE = PropAdjust(gb->NextOfPE);
1421 gb->AtomOfGE = AtomEntryAdjust(gb->AtomOfGE);
1423 gb->NextGE = GlobalEntryAdjust(gb->NextGE);
1425 if (IsVarTerm(gbt)) {
1426 CELL *gbp = VarOfTerm(gbt);
1427 if (IsOldGlobalPtr(gbp))
1428 gbp = PtoGloAdjust(gbp);
1430 gbp = CellPtoHeapAdjust(gbp);
1431 gb->global = (CELL)gbp;
1432 }
else if (IsPairTerm(gbt)) {
1433 gb->global = AbsPair(PtoGloAdjust(RepPair(gbt)));
1434 }
else if (IsApplTerm(gbt)) {
1435 CELL *gbp = RepAppl(gbt);
1436 if (IsOldGlobalPtr(gbp))
1437 gbp = PtoGloAdjust(gbp);
1439 gbp = CellPtoHeapAdjust(gbp);
1440 gb->global = AbsAppl(gbp);
1441 }
else if (IsAtomTerm(gbt)) {
1442 gb->global = AtomTermAdjust(gbt);
1447 if (opp->NextOfPE) {
1448 opp->NextOfPE = PropAdjust(opp->NextOfPE);
1450 opp->OpName = AtomAdjust(opp->OpName);
1451 if (opp->OpModule) {
1452 opp->OpModule = AtomTermAdjust(opp->OpModule);
1455 opp->OpNext = OpEntryAdjust(opp->OpNext);
1461 me->NextOfPE = PropAdjust(me->NextOfPE);
1471 pp->NextOfPE = PropAdjust(pp->NextOfPE);
1474 pp->NextOfPE = PropAdjust(pp->NextOfPE);
1477 bpe->blob_type = BlobTypeAdjust(bpe->blob_type);
1482 Yap_Error(SYSTEM_ERROR_INTERNAL, TermNil,
1483 "Invalid Atom Property %d at %p", pp->KindOfPE, pp);
1486 pp = RepProp(pp->NextOfPE);
1490static void RestoreAtom(
AtomEntry *at USES_REGS) {
1494 at->PropsOfAE = PropAdjust(at->PropsOfAE);
1496 if (IsWideAtom(AbsAtom(at)))
1497 fprintf(stderr,
"Restoring %S\n", at->WStrOfAE);
1499 fprintf(stderr,
"Restoring %s\n", at->StrOfAE);
1501 RestoreEntries(RepProp(at->PropsOfAE), FALSE PASS_REGS);
1503 nat = RepAtom(at->NextOfAE);
1505 at->NextOfAE = AbsAtom(AtomEntryAdjust(nat));
Module property: low-level data used to manage modes.
struct mod_entry * NextME
Module local flags (from SWI compat)
Atom AtomOfME
index in operator table
struct pred_entry * PredForME
kind of property