diff options
Diffstat (limited to 'gcc/config/iq2000/abi')
| -rw-r--r-- | gcc/config/iq2000/abi | 239 |
1 files changed, 239 insertions, 0 deletions
diff --git a/gcc/config/iq2000/abi b/gcc/config/iq2000/abi new file mode 100644 index 000000000..e4e62c097 --- /dev/null +++ b/gcc/config/iq2000/abi @@ -0,0 +1,239 @@ + IQ2000 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 +---------------- + +%0 always zero +%1 call clobbered +%2 return value +%3 return value +%4 argument register 1 +%5 argument register 2 +%6 argument register 3 +%7 argument register 4 +%8 argument register 5 +%9 argument register 6 +%10 argument register 7 +%11 argument register 8 +%12 call clobbered +%13 call clobbered +%14 call clobbered +%15 call clobbered +%16 call saved +%17 call saved +%18 call saved +%19 call saved +%20 call saved +%21 call saved +%22 call saved +%23 call saved +%24 call clobbered +%25 call clobbered +%26 reserved +%27 frame ptr +%28 global ptr +%29 stack ptr +%30 reserved +%31 return address + +Stack alignment 8 bytes + +Structures passed <= 32 bits as values, else as pointers + +The IQ2000 Stack +--------------- + +Space is allocated as needed in the stack frame for the following at compile +time: + +* Outgoing parameters beyond the eighth + +* 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 %27; dynamically allocated space is addressed with positive +offsets from the pointer returned by alloca(). + +Stack Frame +----------- + + +-----------------------+ + | Caller memory args | + +-----------------------+ <-sp + | Return address | + +-----------------------+ + | Previous FP | + +-----------------------+ + | 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=r4 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 > r11, 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 > r10, 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 r2 + short r2 + long r2 + long long r2-r3 + float r2 + double r2-r3 + struct/union see below + +Structs/unions which will fit into two general-purpose registers are returned +in r2, or in r2-r3 if necessary. Larger structs/unions are handled by the +caller passing as a "hidden" first argument a pointer to space allocated to +receive the return value. + + +Copyright (C) 2003 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. |