diff options
Diffstat (limited to 'gcc/config/mt/ABI.txt')
| -rw-r--r-- | gcc/config/mt/ABI.txt | 219 |
1 files changed, 0 insertions, 219 deletions
diff --git a/gcc/config/mt/ABI.txt b/gcc/config/mt/ABI.txt deleted file mode 100644 index 97dfbb8..0000000 --- a/gcc/config/mt/ABI.txt +++ /dev/null @@ -1,219 +0,0 @@ - Copyright (C) 2005 Free Software Foundation, Inc. - - Copying and distribution of this file, with or without modification, - are permitted in any medium without royalty provided the copyright - notice and this notice are preserved. - --------------------------------------------------------------------------- - - MS1 ABI - ========= - -Sizes and alignments --------------------- - - Type Size (bytes) Alignment (bytes) - - char 1 1 - short 2 2 - int 4 4 - unsigned 4 4 - long 4 4 - long long 8 8 - float 4 4 - double 8 8 - pointers 4 4 - -* alignment within aggregates (structs and unions) is as above, with - padding added if needed -* aggregates have alignment equal to that of their most aligned - member -* aggregates have sizes which are a multiple of their alignment - - -Floating point --------------- - -All emulated using IEEE floating point conventions. - -Registers ----------------- - -r0 always zero -r1 argument register 1 -r2 argument register 2 -r3 argument register 3 -r4 argument register 4 -r5 callee must save -r6 callee must save -r7 call clobbers -r8 call clobbers -r9 call clobbers -r10 call clobbers -r11 function return value -r12 frame pointer -r13 stack pointer -r14 linkage pointer -r15 interrupt pointer - -Stack alignment 8 bytes - -Structures passed <= 32 bits as values, else as pointers - -The MS1 Stack ---------------- - -Space is allocated as needed in the stack frame for the following at compile -time: - -* Outgoing parameters beyond the fourth - -* All automatic arrays, automatic data aggregates, automatic - scalars which must be addressable, and automatic scalars for - which there is no room in registers - -* Compiler-generated temporary values (typically when there are - too many for the compiler to keep them all in registers) - -Space can be allocated dynamically (at runtime) in the stack frame for the -following: - -* Memory allocated using the alloca() function of the C library - -Addressable automatic variables on the stack are addressed with positive -offsets relative to r12; dynamically allocated space is addressed with positive -offsets from the pointer returned by alloca(). - -Stack Frame ------------ - - +-----------------------+ - | Parameter Word 1 | - +-----------------------+ <-sp - | Previous FP | - +-----------------------+ - | Return address | - +-----------------------+ - | Saved Registers | - +-----------------------+ - | ... | - +-----------------------+ - | Local Variables | - +-----------------------+ <-fp - | Alloca | - +-----------------------+ - | ... | - +-----------------------+ - | Parameter Word 2 | - +-----------------------+ - | Parameter Word 1 | - +-----------------------+ <-sp - - -Parameter Assignment to Registers ---------------------------------- - -Consider the parameters in a function call as ordered from left (first -parameter) to right. GR contains the number of the next available -general-purpose register. STARG is the address of the next available stack -parameter word. - -INITIALIZE: - Set GR=r1 and STARG to point to parameter word 1. - -SCAN: - If there are no more parameters, terminate. - Otherwise, select one of the following depending on the type - of the next parameter: - - SIMPLE ARG: - - A SIMPLE ARG is one of the following: - - * One of the simple integer types which will fit into a - general-purpose register, - * A pointer to an object of any type, - * A struct or union small enough to fit in a register (<= 32 bits) - * A larger struct or union, which shall be treated as a - pointer to the object or to a copy of the object. - (See below for when copies are made.) - - If GR > r4, go to STACK. Otherwise, load the parameter value into - general-purpose register GR and advance GR to the next general-purpose - register. Values shorter than the register size are sign-extended or - zero-extended depending on whether they are signed or unsigned. Then - go to SCAN. - - DOUBLE or LONG LONG - - If GR > r3, go to STACK. Otherwise, if GR is odd, advance GR to the - next register. Load the 64-bit long long or double value into register - pair GR and GR+1. Advance GR to GR+2 and go to SCAN. - - STACK: - - Parameters not otherwise handled above are passed in the parameter - words of the caller's stack frame. SIMPLE ARGs, as defined above, are - considered to have size and alignment equal to the size of a - general-purpose register, with simple argument types shorter than this - sign- or zero-extended to this width. Round STARG up to a multiple of - the alignment requirement of the parameter and copy the argument - byte-for-byte into STARG, STARG+1, ... STARG+size-1. Set STARG to - STARG+size and go to SCAN. - - -Structure passing ------------------ - -As noted above, code which passes structures and unions by value is implemented -specially. (In this section, "struct" will refer to structs and unions -inclusively.) Structs small enough to fit in a register are passed by value in -a single register or in a stack frame slot the size of a register. Structs -containing a single double or long long component are passed by value in two -registers or in a stack frame slot the size of two registers. Other structs -are handled by passing the address of the structure. In this case, a copy of -the structure will be made if necessary in order to preserve the pass-by-value -semantics. - -Copies of large structs are made under the following rules: - - ANSI mode K&R Mode - --------- -------- -Normal param Callee copies if needed Caller copies -Varargs (...) param Caller copies Caller copies - -In the case of normal (non-varargs) large-struct parameters in ANSI mode, the -callee is responsible for producing the same effect as if a copy of the -structure were passed, preserving the pass-by-value semantics. This may be -accomplished by having the callee make a copy, but in some cases the callee may -be able to determine that a copy is not necessary in order to produce the same -results. In such cases, the callee may choose to avoid making a copy of the -parameter. - - -Varargs handling ----------------- - -No special changes are needed for handling varargs parameters other than the -caller knowing that a copy is needed on struct parameters larger than a -register (see above). - -The varargs macros set up a register save area for the general-purpose -registers to be saved. Because the save area lies between the caller and -callee stack frames, the saved register parameters are contiguous with -parameters passed on the stack. A pointer advances from the register save area -into the caller's stack frame. - - -Function return values ----------------------- - - Type Register - ---- -------- - int r11 - short r11 - long r11 - long long stack - float r11 - double stack - |