1			IQ2000 ABI
2			=========
3
4Sizes 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
26Floating point
27--------------
28
29All emulated using IEEE floating point conventions.
30
31Registers
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
67Stack alignment		8 bytes
68
69Structures passed	<= 32 bits as values, else as pointers
70
71The IQ2000 Stack
72---------------
73
74Space is allocated as needed in the stack frame for the following at compile
75time:
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
86Space can be allocated dynamically (at runtime) in the stack frame for the
87following:
88
89* Memory allocated using the alloca() function of the C library
90
91Addressable automatic variables on the stack are addressed with positive
92offsets relative to %27; dynamically allocated space is addressed with positive
93offsets from the pointer returned by alloca().
94
95Stack 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
121Parameter Assignment to Registers
122---------------------------------
123
124Consider the parameters in a function call as ordered from left (first
125parameter) to right.  GR contains the number of the next available
126general-purpose register.  STARG is the address of the next available stack
127parameter word.
128
129INITIALIZE:
130	Set GR=r4 and STARG to point to parameter word 1.
131
132SCAN:
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
173Structure passing
174-----------------
175
176As noted above, code which passes structures and unions by value is implemented
177specially.  (In this section, "struct" will refer to structs and unions
178inclusively.)  Structs small enough to fit in a register are passed by value in
179a single register or in a stack frame slot the size of a register.  Structs
180containing a single double or long long component are passed by value in two
181registers or in a stack frame slot the size of two registers.  Other structs
182are handled by passing the address of the structure.  In this case, a copy of
183the structure will be made if necessary in order to preserve the pass-by-value
184semantics.
185
186Copies of large structs are made under the following rules:
187
188			ANSI mode			K&R Mode
189			---------			--------
190Normal param	 	Callee copies if needed		Caller copies
191Varargs (...) param	Caller copies			Caller copies
192
193In the case of normal (non-varargs) large-struct parameters in ANSI mode, the
194callee is responsible for producing the same effect as if a copy of the
195structure were passed, preserving the pass-by-value semantics.  This may be
196accomplished by having the callee make a copy, but in some cases the callee may
197be able to determine that a copy is not necessary in order to produce the same
198results.  In such cases, the callee may choose to avoid making a copy of the
199parameter.
200
201
202Varargs handling
203----------------
204
205No special changes are needed for handling varargs parameters other than the
206caller knowing that a copy is needed on struct parameters larger than a
207register (see above).
208
209The varargs macros set up a register save area for the general-purpose
210registers to be saved.  Because the save area lies between the caller and
211callee stack frames, the saved register parameters are contiguous with
212parameters passed on the stack.  A pointer advances from the register save area
213into the caller's stack frame.
214
215
216Function 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
229Structs/unions which will fit into two general-purpose registers are returned
230in r2, or in r2-r3 if necessary.  Larger structs/unions are handled by the
231caller passing as a "hidden" first argument a pointer to space allocated to
232receive the return value.
233
234
235Copyright (C) 2003-2020 Free Software Foundation, Inc.
236
237Copying and distribution of this file, with or without modification,
238are permitted in any medium without royalty provided the copyright
239notice and this notice are preserved.
240