1 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. 233 234 236 Copyright (C) 2003-2022 Free Software Foundation, Inc. 237 238 Copying and distribution of this file, with or without modification, 239 are permitted in any medium without royalty provided the copyright 240 notice and this notice are preserved. 241
Indexes created Fri Aug 14 00:25:39 UTC 2026