The Postfix reference guide contains information about the structure and operations of the stack machine.
The original stack machine was created by Santos (2004). Is was composed by a set of macros to be used with printf functions. Each macro would “take” as arguments, either a number or a string. This was a simple and effective approach but was limited in its expressiveness.
The current postfix code generator class maintains the stack machine abstraction, but does not rely on macros. Instead, it defines an interface to be used by semantic analysers, as defined by a strategy pattern (Gamma et al., 1995). Specific implementations provide the realization of the postfix commands for a particular target machine. Since it is written in C++, it's very easy to extend to new needs and implementations (new target machines).
Like the original postfix code generator, the current abstraction uses an architecture based on a stack machine, hence the name ``postfix, and three registers.
In some of the following tables, the "Stack" column presents the actions on the values at the top of the stack. Note that only elements relevant in a given context, i.e., that of the postfix instruction being executed, are shown. The notation #length represents a set of length consecutive bytes in the stack, i.e., a vector.
Consider the following example:
$ a #8 b : $ a b
The stack had at its top b, followed by eight bytes, followed by a. After executing some postfix instruction using these elements, the stack has at its top b, followed by a. We use $ to denote the point in the stack not affected by the current operation (this could be the top if the stack were empty).
The following groups of operations are available in the Postfix interface:
text data rodata bss align label extrn globl const str char id byte double
Absolute addressing uses addresses based on named labels. Local addressing is used in function frames and uses offsets relative to the frame pointer to load data: negative addresses correspond to local variables, offset zero contains the previous (saved) value of the frame pointer, offset 4 (32 bits) contains the previous (saved) value of the instruction pointer, and, after offset 8, reside the function arguments.
| ADDR name | $ | $ &name | Absolute addressing: load address of name |
| ADDRA name | $ a | $ | Absolute addressing: store a to name |
| ADDRV name | $ | $ *name | Absolute addressing: load value at name |
| LOCAL offset | $ | $ fp+offset | Local addressing: load address of offset |
| LOCA offset | $ a | $ | Local addressing: writes a to offset |
| LOCV offset | $ | $ *(fp+offset) | Local addressing: load value at offset |
| LOAD | $ address | $ value | Load value pointed to by *SP |
| DLOAD | |||
| LDCHR | |||
| STORE | |||
| DSTORE | |||
| STCHR |
| ALLOC | ||
| DUP | ||
| DDUP | ||
| SWAP | ||
| PUSH | ||
| DPUSH | ||
| POP | ||
| DPOP | ||
| INT | ||
| SP | $ | $ sp |
The arithmetic operations considered here apply to both signed and unsigned integer arguments, and to double precision floating point arguments.
| NEG | $ a | $ -a | Negation (symmetric) of integer value |
| ADD | $ a b | $ a+b | Integer sum of two integer values |
| SUB | $ a b | $ a-b | Integer subtraction of two integer values |
| MUL | $ a b | $ a*b | Integer multiplication of two integer values |
| DIV | $ a b | $ a/b | Integer division of two integer values |
| MOD | $ a b | $ a%b | Remainder of the integer division of two integer values |
| UDIV | $ a b | $ a/b | Integer division of two natural (unsigned) integer values |
| UMOD | $ a b | $ a%b | Remainder of the integer division of two natural (unsigned) integer values.\\\hline |
These operations take double precision floating
| DNEG | $ a | $ -a | Negation (symmetric) |
| DADD | $ a b | $ a+b | Sum |
| DSUB | $ a b | $ a-b | Subtraction |
| DMUL | $ a b | $ a*b | Multiplication |
| DDIV | $ a b | $ a/b | Division |
The comparison instructions are binary operations that leave at the top of the stack 0 (zero) or 1 (one), depending on the result result of the comparison: respectively, false or true. The value may be directly used to perform conditional jumps (e.g., JZ, JNZ), that use the value of the top of the stack instead of relying on special processor registers ("flags").
| EQ | $ a b | $ a≡b | equal to |
| NE | $ a b | $ a≠b | not equal to |
| GT | $ a b | $ a>b | greater than |
| GE | $ a b | $ a≥b | greater than or equal to |
| LE | $ a b | $ a≤b | less than or equal to |
| LT | $ a b | $ a<b | less than |
The following consider unsigned operands:
| UGT | $ a b | $ a>b | greater than for unsigned integers |
| UGE | $ a b | $ a≥b | greater than or equal to for unsigned integers |
| ULE | $ a b | $ a≤b | less than or equal to for unsigned integers |
| ULT | $ a b | $ a<b | less than for unsigned integers |
This operator compares two double precision floating point numbers. The result is an integer value: less than 0, if the first operand is less than the second; 0, if they are equal; greater than 0, otherwise.
| DCMP | $ a b | i | "compare" -- i<0, a<b; i≡0, a≡b; i>0, a>b |
| NOT | $ a | $ ~a | Logical (bitwise) negation, i.e., one's complement |
| AND | $ a b | $ a∧b | Logical (bitwise) AND operation |
| OR | $ a b | a∨b | Logical (bitwise) OR operation |
| XOR | $ a b | $ a⊕b | Logical (bitwise) XOR (exclusive OR) operation |
rotl rotr shtl shtru shtrs and or not xor
call ret start enter leave trash jmp jz jnz branch leap nil nop