Postfix Reference Guide: Difference between revisions
From Wiki**3
| Line 56: | Line 56: | ||
|ID name || || || Declares a name for an address (i.e., declares the address associated with '''name''') | |ID name || || || Declares a name for an address (i.e., declares the address associated with '''name''') | ||
|- | |- | ||
|STR string || || || Declares a static NULL-terminated character string (C-like) (may contain special characters) | |STR string || || || Declares a static NULL-terminated character '''string''' (C-like) (may contain special characters) | ||
|} | |} | ||
Revision as of 13:34, 8 May 2012
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.
- IP -- the instruction pointer -- indicates the position of the next instruction to be executed;
- SP -- the stack pointer -- indicates the position of the element currently at the stack top;
- FP -- the frame pointer -- indicates the position of the activation register of the function currently being executed.
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:
Segments, Values, and Labels
Segment choices
These operations start various segments. They do not affect the stack.
| BSS | Specifies/selects the data segment for uninitialized values | ||
| DATA | Specifies/selects the data segment for initialized values | ||
| RODATA | Specifies/selects the data segment for initialized constant values | ||
| TEXT | Specifies/selects the text (code) segment |
Values (declaration in segments)
These operations declare values directly in various segments. They do not affect the stack.
| BYTE size | Declares an uninitialized vector with length size (in bytes) | ||
| SHORT value | Declares a static 16-bit integer value | ||
| CHAR value | Declares a static 8-bit character value | ||
| CONST value | Declares a static 32-bit integer value | ||
| DOUBLE value | Declares a static double precision (64-bit) floating point value | ||
| FLOAT value | Declares a static simple precision (32-bit) floating point value | ||
| ID name | Declares a name for an address (i.e., declares the address associated with name) | ||
| STR string | Declares a static NULL-terminated character string (C-like) (may contain special characters) |
Labels
These operations handle symbols and their definitions within some segment. They do not affect the stack.
| ALIGN | Forces the alignment of code or data | ||
| LABEL name | Generates a new label, as indicated by the argument | ||
| EXTERN name | Declares the symbol whose name is passed as argument as being externally defined, i.e., defined in another compilation module | ||
| GLOBAL name, type | Declare a name/label (first argument) with a given type (second argument; see below) -- the declaration of a name must preceed its definition |
In a declaration common to several modules, any number of modules may contain common or external declarations, but only one of them may contain an initialized declaration. A declaration does not need to be specified in a specific segment.
Global names may be of different types. These labels are to be used to generate the types needed for the second argument of GLOBAL.
| NONE | Unknown type | ||
| FUNC | Name/label corresponds to a function | ||
| OBJ | Name/label corresponds to an object (data) |
Addressing, Loading and Storing
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.
Adressing operations
| 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 |
ADDRA, ADDRV, LOCA, LOCV are functionally equivalent to ADDR+STORE, ADDR+LOAD, LOCAL+STORE, LOCAL+LOAD, but the generated code is more efficient. They are compound operations (i.e., they contain not only the addressing part, but also the load/store part as well).
Load operations
The load instructions assume that the top of the stack contains an address pointing to the data to be read. Each load instruction will replace the address at the top of the stack with the contents of the position it points to. Load operations differ only in what they load.
| LOAD | $ addr | $ [addr] | Loads 8 bytes (int/float) |
| DLOAD | $ addr | $ [addr] | Loads 8 bytes (double) |
| LDCHR | $ addr | $ [addr] | Loads 1 byte (char) |
| ULDCHR | $ addr | $ [addr] | Loads 1 byte (without sign) (unsigned char) |
| LD16 | $ addr | $ [addr] | Loads 2 bytes (short) |
| ULD16 | $ addr | $ [addr] | Loads 2 bytes (without sign) (unsigned short) |
Store operations
Store instructions assume the stack contains at the top the address where data is to be stored. That data is in the stack, immediately after the address. Store instructions differ only in what they store.
| STORE | $ val addr | $ | Stores 4 bytes (int/float) |
| DSTORE | $ val addr | $ | Stores 8 bytes (double) |
| STCHR | $ val addr | $ | Stores 1 byte (char) |
| ST16 | $ val addr | $ | Stores 2 bytes (short) |
Simple Instructions
| ALLOC | ||
| DUP | ||
| DDUP | ||
| SWAP | ||
| PUSH | ||
| DPUSH | ||
| POP | ||
| DPOP | ||
| INT | ||
| SP | $ | $ sp |
Arithmetic Operations
The arithmetic operations considered here apply to both signed and unsigned integer arguments, and to double precision floating point arguments.
Integer operations
| 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 |
Floating point operations
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 |
Comparison Operations
Integer comparison instructions
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 |
Floating point comparison operator
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 |
Logical Operations
| 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 |
bit a bit
rotl rotr shtl shtru shtrs and or not xor
funções/saltos
call ret start enter leave trash jmp jz jnz branch leap nil nop