Editing P-code machine (section)

==UCSD P-Machine==

===Architecture===
Like many other P-code machines, the UCSD P-Machine is a [[stack machine]], which means that most instructions take their operands from a [[Stack (abstract data type)|stack]], and place results back on the stack. Thus, the <code>add</code> instruction replaces the two topmost elements of the stack with their sum. A few instructions take an immediate argument. Like Pascal, the P-code is [[Strong and weak typing|strongly typed]], supporting Boolean (b), character (c), integer (i), real (r), set (s), and pointer (a) [[data type]]s natively.

Some simple instructions:

 Insn.   Stack   Stack   Description
         before  after
 &nbsp;
 adi     i1 i2   i1+i2   add two integers
 adr     r1 r2   r1+r2   add two reals
 inn     i1 s1   b1      set membership; b1 = whether i1 is a member of s1
 ldi     i1 i1   i1      load integer constant
 mov     a1 a2   a2      move
 not     b1 b1   -b1     Boolean negation

===Environment===
Similar to a real target CPU, the P-System has only one stack shared by procedure stack frames (providing [[Return statement|return address]], etc.) and the arguments to local instructions. Three of the machine's [[Processor register|registers]] point into the stack (which grows upwards):
* SP points to the top of the stack (the [[stack pointer]]).
* MP marks the beginning of the active stack frame (the [[mark pointer]]).
* EP points to the highest stack location used in the current procedure (the [[extreme pointer]]).

Also present is a constant area, and, below that, the [[Dynamic memory allocation|heap]] growing down towards the stack. The NP (the [[new pointer]]) register points to the top (lowest used address) of the heap. When EP gets greater than NP, the machine's memory is exhausted.

The fifth register, PC, points at the current instruction in the code area.

===Calling conventions===
{{how-to|section|date=January 2024}}

Stack frames look like this:

 EP ->
       local stack
 SP -> ...
       locals
       ...
       parameters
       ...
       return address (previous PC)
       previous EP
       dynamic link (previous MP)
       static link (MP of surrounding procedure)
 MP -> function return value

The procedure calling sequence works as follows: The call is introduced with

  mst n

where <code>n</code> specifies the difference in nesting levels (remember that Pascal supports nested procedures). This instruction will ''mark'' the stack, i.e. reserve the first five cells of the above stack frame, and initialize previous EP, dynamic, and static link. The caller then computes and pushes any parameters for the procedure, and then issues

  cup n, p

to call a user procedure (<code>n</code> being the number of parameters, <code>p</code> the procedure's address). This will save the PC in the return address cell, and set the procedure's address as the new PC.

User procedures begin with the two instructions

  ent 1, i
  ent 2, j

The first sets SP to MP + <code>i</code>, the second sets EP to SP + <code>j</code>. So <code>i</code> essentially specifies the space reserved for locals (plus the number of parameters plus 5), and <code>j</code> gives the number of entries needed locally for the stack. Memory exhaustion is checked at this point.

Returning to the caller is accomplished via

  retC

with <code>C</code> giving the return type (i, r, c, b, a as above, and p for no return value). The return value has to be stored in the appropriate cell previously. On all types except p, returning will leave this value on the stack.

Instead of calling a user procedure (cup), standard procedure <code>q</code> can be called with

  csp q

These standard procedures are Pascal procedures like <code>readln()</code> (<code>csp rln</code>), <code>sin()</code> (<code>csp sin</code>), etc. Peculiarly <code>eof()</code> is a p-Code instruction instead.