1 |
12 |
jlechner |
IQ2000 ABI
|
2 |
|
|
=========
|
3 |
|
|
|
4 |
|
|
Sizes and alignments
|
5 |
|
|
--------------------
|
6 |
|
|
|
7 |
|
|
Type Size (bytes) Alignment (bytes)
|
8 |
|
|
|
9 |
|
|
char 1 1
|
10 |
|
|
short 2 2
|
11 |
|
|
int 4 4
|
12 |
|
|
unsigned 4 4
|
13 |
|
|
long 4 4
|
14 |
|
|
long long 8 8
|
15 |
|
|
float 4 4
|
16 |
|
|
double 8 8
|
17 |
|
|
pointers 4 4
|
18 |
|
|
|
19 |
|
|
* alignment within aggregates (structs and unions) is as above, with
|
20 |
|
|
padding added if needed
|
21 |
|
|
* aggregates have alignment equal to that of their most aligned
|
22 |
|
|
member
|
23 |
|
|
* aggregates have sizes which are a multiple of their alignment
|
24 |
|
|
|
25 |
|
|
|
26 |
|
|
Floating point
|
27 |
|
|
--------------
|
28 |
|
|
|
29 |
|
|
All emulated using IEEE floating point conventions.
|
30 |
|
|
|
31 |
|
|
Registers
|
32 |
|
|
----------------
|
33 |
|
|
|
34 |
|
|
%0 always zero
|
35 |
|
|
%1 call clobbered
|
36 |
|
|
%2 return value
|
37 |
|
|
%3 return value
|
38 |
|
|
%4 argument register 1
|
39 |
|
|
%5 argument register 2
|
40 |
|
|
%6 argument register 3
|
41 |
|
|
%7 argument register 4
|
42 |
|
|
%8 argument register 5
|
43 |
|
|
%9 argument register 6
|
44 |
|
|
%10 argument register 7
|
45 |
|
|
%11 argument register 8
|
46 |
|
|
%12 call clobbered
|
47 |
|
|
%13 call clobbered
|
48 |
|
|
%14 call clobbered
|
49 |
|
|
%15 call clobbered
|
50 |
|
|
%16 call saved
|
51 |
|
|
%17 call saved
|
52 |
|
|
%18 call saved
|
53 |
|
|
%19 call saved
|
54 |
|
|
%20 call saved
|
55 |
|
|
%21 call saved
|
56 |
|
|
%22 call saved
|
57 |
|
|
%23 call saved
|
58 |
|
|
%24 call clobbered
|
59 |
|
|
%25 call clobbered
|
60 |
|
|
%26 reserved
|
61 |
|
|
%27 frame ptr
|
62 |
|
|
%28 global ptr
|
63 |
|
|
%29 stack ptr
|
64 |
|
|
%30 reserved
|
65 |
|
|
%31 return address
|
66 |
|
|
|
67 |
|
|
Stack alignment 8 bytes
|
68 |
|
|
|
69 |
|
|
Structures passed <= 32 bits as values, else as pointers
|
70 |
|
|
|
71 |
|
|
The IQ2000 Stack
|
72 |
|
|
---------------
|
73 |
|
|
|
74 |
|
|
Space is allocated as needed in the stack frame for the following at compile
|
75 |
|
|
time:
|
76 |
|
|
|
77 |
|
|
* Outgoing parameters beyond the eighth
|
78 |
|
|
|
79 |
|
|
* All automatic arrays, automatic data aggregates, automatic
|
80 |
|
|
scalars which must be addressable, and automatic scalars for
|
81 |
|
|
which there is no room in registers
|
82 |
|
|
|
83 |
|
|
* Compiler-generated temporary values (typically when there are
|
84 |
|
|
too many for the compiler to keep them all in registers)
|
85 |
|
|
|
86 |
|
|
Space can be allocated dynamically (at runtime) in the stack frame for the
|
87 |
|
|
following:
|
88 |
|
|
|
89 |
|
|
* Memory allocated using the alloca() function of the C library
|
90 |
|
|
|
91 |
|
|
Addressable automatic variables on the stack are addressed with positive
|
92 |
|
|
offsets relative to %27; dynamically allocated space is addressed with positive
|
93 |
|
|
offsets from the pointer returned by alloca().
|
94 |
|
|
|
95 |
|
|
Stack Frame
|
96 |
|
|
-----------
|
97 |
|
|
|
98 |
|
|
+-----------------------+
|
99 |
|
|
| Caller memory args |
|
100 |
|
|
+-----------------------+ <-sp
|
101 |
|
|
| Return address |
|
102 |
|
|
+-----------------------+
|
103 |
|
|
| Previous FP |
|
104 |
|
|
+-----------------------+
|
105 |
|
|
| Saved Registers |
|
106 |
|
|
+-----------------------+
|
107 |
|
|
| ... |
|
108 |
|
|
+-----------------------+
|
109 |
|
|
| Local Variables |
|
110 |
|
|
+-----------------------+ <-fp
|
111 |
|
|
| Alloca |
|
112 |
|
|
+-----------------------+
|
113 |
|
|
| ... |
|
114 |
|
|
+-----------------------+
|
115 |
|
|
| Parameter Word 2 |
|
116 |
|
|
+-----------------------+
|
117 |
|
|
| Parameter Word 1 |
|
118 |
|
|
+-----------------------+ <-sp
|
119 |
|
|
|
120 |
|
|
|
121 |
|
|
Parameter Assignment to Registers
|
122 |
|
|
---------------------------------
|
123 |
|
|
|
124 |
|
|
Consider the parameters in a function call as ordered from left (first
|
125 |
|
|
parameter) to right. GR contains the number of the next available
|
126 |
|
|
general-purpose register. STARG is the address of the next available stack
|
127 |
|
|
parameter word.
|
128 |
|
|
|
129 |
|
|
INITIALIZE:
|
130 |
|
|
Set GR=r4 and STARG to point to parameter word 1.
|
131 |
|
|
|
132 |
|
|
SCAN:
|
133 |
|
|
If there are no more parameters, terminate.
|
134 |
|
|
Otherwise, select one of the following depending on the type
|
135 |
|
|
of the next parameter:
|
136 |
|
|
|
137 |
|
|
SIMPLE ARG:
|
138 |
|
|
|
139 |
|
|
A SIMPLE ARG is one of the following:
|
140 |
|
|
|
141 |
|
|
* One of the simple integer types which will fit into a
|
142 |
|
|
general-purpose register,
|
143 |
|
|
* A pointer to an object of any type,
|
144 |
|
|
* A struct or union small enough to fit in a register (<= 32 bits)
|
145 |
|
|
* A larger struct or union, which shall be treated as a
|
146 |
|
|
pointer to the object or to a copy of the object.
|
147 |
|
|
(See below for when copies are made.)
|
148 |
|
|
|
149 |
|
|
If GR > r11, go to STACK. Otherwise, load the parameter value into
|
150 |
|
|
general-purpose register GR and advance GR to the next general-purpose
|
151 |
|
|
register. Values shorter than the register size are sign-extended or
|
152 |
|
|
zero-extended depending on whether they are signed or unsigned. Then
|
153 |
|
|
go to SCAN.
|
154 |
|
|
|
155 |
|
|
DOUBLE or LONG LONG
|
156 |
|
|
|
157 |
|
|
If GR > r10, go to STACK. Otherwise, if GR is odd, advance GR to the
|
158 |
|
|
next register. Load the 64-bit long long or double value into register
|
159 |
|
|
pair GR and GR+1. Advance GR to GR+2 and go to SCAN.
|
160 |
|
|
|
161 |
|
|
STACK:
|
162 |
|
|
|
163 |
|
|
Parameters not otherwise handled above are passed in the parameter
|
164 |
|
|
words of the caller's stack frame. SIMPLE ARGs, as defined above, are
|
165 |
|
|
considered to have size and alignment equal to the size of a
|
166 |
|
|
general-purpose register, with simple argument types shorter than this
|
167 |
|
|
sign- or zero-extended to this width. Round STARG up to a multiple of
|
168 |
|
|
the alignment requirement of the parameter and copy the argument
|
169 |
|
|
byte-for-byte into STARG, STARG+1, ... STARG+size-1. Set STARG to
|
170 |
|
|
STARG+size and go to SCAN.
|
171 |
|
|
|
172 |
|
|
|
173 |
|
|
Structure passing
|
174 |
|
|
-----------------
|
175 |
|
|
|
176 |
|
|
As noted above, code which passes structures and unions by value is implemented
|
177 |
|
|
specially. (In this section, "struct" will refer to structs and unions
|
178 |
|
|
inclusively.) Structs small enough to fit in a register are passed by value in
|
179 |
|
|
a single register or in a stack frame slot the size of a register. Structs
|
180 |
|
|
containing a single double or long long component are passed by value in two
|
181 |
|
|
registers or in a stack frame slot the size of two registers. Other structs
|
182 |
|
|
are handled by passing the address of the structure. In this case, a copy of
|
183 |
|
|
the structure will be made if necessary in order to preserve the pass-by-value
|
184 |
|
|
semantics.
|
185 |
|
|
|
186 |
|
|
Copies of large structs are made under the following rules:
|
187 |
|
|
|
188 |
|
|
ANSI mode K&R Mode
|
189 |
|
|
--------- --------
|
190 |
|
|
Normal param Callee copies if needed Caller copies
|
191 |
|
|
Varargs (...) param Caller copies Caller copies
|
192 |
|
|
|
193 |
|
|
In the case of normal (non-varargs) large-struct parameters in ANSI mode, the
|
194 |
|
|
callee is responsible for producing the same effect as if a copy of the
|
195 |
|
|
structure were passed, preserving the pass-by-value semantics. This may be
|
196 |
|
|
accomplished by having the callee make a copy, but in some cases the callee may
|
197 |
|
|
be able to determine that a copy is not necessary in order to produce the same
|
198 |
|
|
results. In such cases, the callee may choose to avoid making a copy of the
|
199 |
|
|
parameter.
|
200 |
|
|
|
201 |
|
|
|
202 |
|
|
Varargs handling
|
203 |
|
|
----------------
|
204 |
|
|
|
205 |
|
|
No special changes are needed for handling varargs parameters other than the
|
206 |
|
|
caller knowing that a copy is needed on struct parameters larger than a
|
207 |
|
|
register (see above).
|
208 |
|
|
|
209 |
|
|
The varargs macros set up a register save area for the general-purpose
|
210 |
|
|
registers to be saved. Because the save area lies between the caller and
|
211 |
|
|
callee stack frames, the saved register parameters are contiguous with
|
212 |
|
|
parameters passed on the stack. A pointer advances from the register save area
|
213 |
|
|
into the caller's stack frame.
|
214 |
|
|
|
215 |
|
|
|
216 |
|
|
Function return values
|
217 |
|
|
----------------------
|
218 |
|
|
|
219 |
|
|
Type Register
|
220 |
|
|
---- --------
|
221 |
|
|
int r2
|
222 |
|
|
short r2
|
223 |
|
|
long r2
|
224 |
|
|
long long r2-r3
|
225 |
|
|
float r2
|
226 |
|
|
double r2-r3
|
227 |
|
|
struct/union see below
|
228 |
|
|
|
229 |
|
|
Structs/unions which will fit into two general-purpose registers are returned
|
230 |
|
|
in r2, or in r2-r3 if necessary. Larger structs/unions are handled by the
|
231 |
|
|
caller passing as a "hidden" first argument a pointer to space allocated to
|
232 |
|
|
receive the return value.
|