|
|
| (97 intermediate revisions by the same user not shown) |
| Line 1: |
Line 1: |
| {{TOCright}}
| | #REDIRECT [[ist:Postfix Reference Guide]] |
| 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:
| |
| | |
| == directivas ==
| |
| | |
| text data rodata bss align label extrn globl const str char id byte double
| |
| | |
| == Addressing ==
| |
| | |
| 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
| |
| |}
| |
| | |
| == 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
| |
| | |
| [[category:Compilers]] | |
| [[category:Teaching]]
| |