WAM: How does put unsafe value handle nonvar terms?

[UWN]

scryer-prolog/src/machine/dispatch.rs

Line 3217 in 62513e0

&Instruction::PutUnsafeValue(n, arg) => {

(While looking for reasons for #1545)

How does put unsafe value handle constants or other nonvar terms? From what I gather, there are only address comparisons. But what happens there with a simple constant? And why should the address of, say a list matter, as it is safe already.

[mthom]

Generally, values stored in the stack have to be moved into the heap before the final procedure of a clause is called / the stack frame is deallocated. This is part of how last call optimization is implemented in the WAM. At compile time instructions like put_value aren't aware of the types of the cell values. They could be constants, yes, but they could also be addresses.

[triska]

But at runtime, we know their value, and a constant already resides on the heap right? So PutUnsafeValue could also take the tag into account, and not copy the value (again) onto the heap.

[mthom]

Yes, it checks that the address is "protected", and if so, it does not copy into the heap.

[triska]

Pertaining to the s < e test in types.rs, Hassan Aït-Kaci's WAM tutorial reconstruction states in the footnote where put_unsafe_value is shown:

Strictly speaking, this test is not quite correct because deref may actually yield the address of an X register containing a literal constant. To prevent this trivial point from complicating matters unnecessarily, we may assume that X registers conveniently reside at the highest end of the global store.

Is this useful in such cases?

[mthom]

Addresses in the Scryer WAM can only point to the heap and the stack, never the registers, so I'm not sure. I don't think so. I admit I don't fully understand the point he is making in the footnote.

[UWN]

Generally, values stored in the stack have to be moved into the heap before the final procedure of a clause is called / the stack frame is deallocated.

Only (uninstantiated) variables that reside in the topmost stackframe need to be moved into the heap. And in many cases, it can be determined statically that this case cannot happen. Consider:

?- [user].
p(X,Y,Z) :- q, r(X,Y,Z).


?- wam_instructions(p/3,Ls),maplist(portray_clause,Ls).
allocate(3).
get_variable(y(2),1).
get_variable(y(3),2).
get_variable(y(1),3).
call(q,0).
put_unsafe_value(2,1).  % unexpected, but not incorrect
put_unsafe_value(3,2).  % unexpected, but not incorrect
put_unsafe_value(1,3).  % unexpected, but not incorrect
deallocate.
execute(r,3).

In this case, not a single check is necessary. They all could be straight put_value instructions.