240 lines
7.0 KiB
Plaintext
240 lines
7.0 KiB
Plaintext
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.
|