| 82 | | /* Some of the array op functions are written as library functions, |
|---|
| 83 | | * presumably to optimize them with special CPU vector instructions. |
|---|
| 84 | | * List those library functions here, in alpha order. |
|---|
| 85 | | */ |
|---|
| 86 | | static const char *libArrayopFuncs[] = |
|---|
| 87 | | { |
|---|
| 88 | | "_arrayExpSliceAddass_a", |
|---|
| 89 | | "_arrayExpSliceAddass_d", // T[]+=T |
|---|
| 90 | | "_arrayExpSliceAddass_f", // T[]+=T |
|---|
| 91 | | "_arrayExpSliceAddass_g", |
|---|
| 92 | | "_arrayExpSliceAddass_h", |
|---|
| 93 | | "_arrayExpSliceAddass_i", |
|---|
| 94 | | "_arrayExpSliceAddass_k", |
|---|
| 95 | | "_arrayExpSliceAddass_s", |
|---|
| 96 | | "_arrayExpSliceAddass_t", |
|---|
| 97 | | "_arrayExpSliceAddass_u", |
|---|
| 98 | | "_arrayExpSliceAddass_w", |
|---|
| 99 | | |
|---|
| 100 | | "_arrayExpSliceDivass_d", // T[]/=T |
|---|
| 101 | | "_arrayExpSliceDivass_f", // T[]/=T |
|---|
| 102 | | |
|---|
| 103 | | "_arrayExpSliceMinSliceAssign_a", |
|---|
| 104 | | "_arrayExpSliceMinSliceAssign_d", // T[]=T-T[] |
|---|
| 105 | | "_arrayExpSliceMinSliceAssign_f", // T[]=T-T[] |
|---|
| 106 | | "_arrayExpSliceMinSliceAssign_g", |
|---|
| 107 | | "_arrayExpSliceMinSliceAssign_h", |
|---|
| 108 | | "_arrayExpSliceMinSliceAssign_i", |
|---|
| 109 | | "_arrayExpSliceMinSliceAssign_k", |
|---|
| 110 | | "_arrayExpSliceMinSliceAssign_s", |
|---|
| 111 | | "_arrayExpSliceMinSliceAssign_t", |
|---|
| 112 | | "_arrayExpSliceMinSliceAssign_u", |
|---|
| 113 | | "_arrayExpSliceMinSliceAssign_w", |
|---|
| 114 | | |
|---|
| 115 | | "_arrayExpSliceMinass_a", |
|---|
| 116 | | "_arrayExpSliceMinass_d", // T[]-=T |
|---|
| 117 | | "_arrayExpSliceMinass_f", // T[]-=T |
|---|
| 118 | | "_arrayExpSliceMinass_g", |
|---|
| 119 | | "_arrayExpSliceMinass_h", |
|---|
| 120 | | "_arrayExpSliceMinass_i", |
|---|
| 121 | | "_arrayExpSliceMinass_k", |
|---|
| 122 | | "_arrayExpSliceMinass_s", |
|---|
| 123 | | "_arrayExpSliceMinass_t", |
|---|
| 124 | | "_arrayExpSliceMinass_u", |
|---|
| 125 | | "_arrayExpSliceMinass_w", |
|---|
| 126 | | |
|---|
| 127 | | "_arrayExpSliceMulass_d", // T[]*=T |
|---|
| 128 | | "_arrayExpSliceMulass_f", // T[]*=T |
|---|
| 129 | | "_arrayExpSliceMulass_i", |
|---|
| 130 | | "_arrayExpSliceMulass_k", |
|---|
| 131 | | "_arrayExpSliceMulass_s", |
|---|
| 132 | | "_arrayExpSliceMulass_t", |
|---|
| 133 | | "_arrayExpSliceMulass_u", |
|---|
| 134 | | "_arrayExpSliceMulass_w", |
|---|
| 135 | | |
|---|
| 136 | | "_arraySliceExpAddSliceAssign_a", |
|---|
| 137 | | "_arraySliceExpAddSliceAssign_d", // T[]=T[]+T |
|---|
| 138 | | "_arraySliceExpAddSliceAssign_f", // T[]=T[]+T |
|---|
| 139 | | "_arraySliceExpAddSliceAssign_g", |
|---|
| 140 | | "_arraySliceExpAddSliceAssign_h", |
|---|
| 141 | | "_arraySliceExpAddSliceAssign_i", |
|---|
| 142 | | "_arraySliceExpAddSliceAssign_k", |
|---|
| 143 | | "_arraySliceExpAddSliceAssign_s", |
|---|
| 144 | | "_arraySliceExpAddSliceAssign_t", |
|---|
| 145 | | "_arraySliceExpAddSliceAssign_u", |
|---|
| 146 | | "_arraySliceExpAddSliceAssign_w", |
|---|
| 147 | | |
|---|
| 148 | | "_arraySliceExpDivSliceAssign_d", // T[]=T[]/T |
|---|
| 149 | | "_arraySliceExpDivSliceAssign_f", // T[]=T[]/T |
|---|
| 150 | | |
|---|
| 151 | | "_arraySliceExpMinSliceAssign_a", |
|---|
| 152 | | "_arraySliceExpMinSliceAssign_d", // T[]=T[]-T |
|---|
| 153 | | "_arraySliceExpMinSliceAssign_f", // T[]=T[]-T |
|---|
| 154 | | "_arraySliceExpMinSliceAssign_g", |
|---|
| 155 | | "_arraySliceExpMinSliceAssign_h", |
|---|
| 156 | | "_arraySliceExpMinSliceAssign_i", |
|---|
| 157 | | "_arraySliceExpMinSliceAssign_k", |
|---|
| 158 | | "_arraySliceExpMinSliceAssign_s", |
|---|
| 159 | | "_arraySliceExpMinSliceAssign_t", |
|---|
| 160 | | "_arraySliceExpMinSliceAssign_u", |
|---|
| 161 | | "_arraySliceExpMinSliceAssign_w", |
|---|
| 162 | | |
|---|
| 163 | | "_arraySliceExpMulSliceAddass_d", // T[] += T[]*T |
|---|
| 164 | | "_arraySliceExpMulSliceAddass_f", |
|---|
| 165 | | "_arraySliceExpMulSliceAddass_r", |
|---|
| 166 | | |
|---|
| 167 | | "_arraySliceExpMulSliceAssign_d", // T[]=T[]*T |
|---|
| 168 | | "_arraySliceExpMulSliceAssign_f", // T[]=T[]*T |
|---|
| 169 | | "_arraySliceExpMulSliceAssign_i", |
|---|
| 170 | | "_arraySliceExpMulSliceAssign_k", |
|---|
| 171 | | "_arraySliceExpMulSliceAssign_s", |
|---|
| 172 | | "_arraySliceExpMulSliceAssign_t", |
|---|
| 173 | | "_arraySliceExpMulSliceAssign_u", |
|---|
| 174 | | "_arraySliceExpMulSliceAssign_w", |
|---|
| 175 | | |
|---|
| 176 | | "_arraySliceExpMulSliceMinass_d", // T[] -= T[]*T |
|---|
| 177 | | "_arraySliceExpMulSliceMinass_f", |
|---|
| 178 | | "_arraySliceExpMulSliceMinass_r", |
|---|
| 179 | | |
|---|
| 180 | | "_arraySliceSliceAddSliceAssign_a", |
|---|
| 181 | | "_arraySliceSliceAddSliceAssign_d", // T[]=T[]+T[] |
|---|
| 182 | | "_arraySliceSliceAddSliceAssign_f", // T[]=T[]+T[] |
|---|
| 183 | | "_arraySliceSliceAddSliceAssign_g", |
|---|
| 184 | | "_arraySliceSliceAddSliceAssign_h", |
|---|
| 185 | | "_arraySliceSliceAddSliceAssign_i", |
|---|
| 186 | | "_arraySliceSliceAddSliceAssign_k", |
|---|
| 187 | | "_arraySliceSliceAddSliceAssign_r", // T[]=T[]+T[] |
|---|
| 188 | | "_arraySliceSliceAddSliceAssign_s", |
|---|
| 189 | | "_arraySliceSliceAddSliceAssign_t", |
|---|
| 190 | | "_arraySliceSliceAddSliceAssign_u", |
|---|
| 191 | | "_arraySliceSliceAddSliceAssign_w", |
|---|
| 192 | | |
|---|
| 193 | | "_arraySliceSliceAddass_a", |
|---|
| 194 | | "_arraySliceSliceAddass_d", // T[]+=T[] |
|---|
| 195 | | "_arraySliceSliceAddass_f", // T[]+=T[] |
|---|
| 196 | | "_arraySliceSliceAddass_g", |
|---|
| 197 | | "_arraySliceSliceAddass_h", |
|---|
| 198 | | "_arraySliceSliceAddass_i", |
|---|
| 199 | | "_arraySliceSliceAddass_k", |
|---|
| 200 | | "_arraySliceSliceAddass_s", |
|---|
| 201 | | "_arraySliceSliceAddass_t", |
|---|
| 202 | | "_arraySliceSliceAddass_u", |
|---|
| 203 | | "_arraySliceSliceAddass_w", |
|---|
| 204 | | |
|---|
| 205 | | "_arraySliceSliceMinSliceAssign_a", |
|---|
| 206 | | "_arraySliceSliceMinSliceAssign_d", // T[]=T[]-T[] |
|---|
| 207 | | "_arraySliceSliceMinSliceAssign_f", // T[]=T[]-T[] |
|---|
| 208 | | "_arraySliceSliceMinSliceAssign_g", |
|---|
| 209 | | "_arraySliceSliceMinSliceAssign_h", |
|---|
| 210 | | "_arraySliceSliceMinSliceAssign_i", |
|---|
| 211 | | "_arraySliceSliceMinSliceAssign_k", |
|---|
| 212 | | "_arraySliceSliceMinSliceAssign_r", // T[]=T[]-T[] |
|---|
| 213 | | "_arraySliceSliceMinSliceAssign_s", |
|---|
| 214 | | "_arraySliceSliceMinSliceAssign_t", |
|---|
| 215 | | "_arraySliceSliceMinSliceAssign_u", |
|---|
| 216 | | "_arraySliceSliceMinSliceAssign_w", |
|---|
| 217 | | |
|---|
| 218 | | "_arraySliceSliceMinass_a", |
|---|
| 219 | | "_arraySliceSliceMinass_d", // T[]-=T[] |
|---|
| 220 | | "_arraySliceSliceMinass_f", // T[]-=T[] |
|---|
| 221 | | "_arraySliceSliceMinass_g", |
|---|
| 222 | | "_arraySliceSliceMinass_h", |
|---|
| 223 | | "_arraySliceSliceMinass_i", |
|---|
| 224 | | "_arraySliceSliceMinass_k", |
|---|
| 225 | | "_arraySliceSliceMinass_s", |
|---|
| 226 | | "_arraySliceSliceMinass_t", |
|---|
| 227 | | "_arraySliceSliceMinass_u", |
|---|
| 228 | | "_arraySliceSliceMinass_w", |
|---|
| 229 | | |
|---|
| 230 | | "_arraySliceSliceMulSliceAssign_d", // T[]=T[]*T[] |
|---|
| 231 | | "_arraySliceSliceMulSliceAssign_f", // T[]=T[]*T[] |
|---|
| 232 | | "_arraySliceSliceMulSliceAssign_i", |
|---|
| 233 | | "_arraySliceSliceMulSliceAssign_k", |
|---|
| 234 | | "_arraySliceSliceMulSliceAssign_s", |
|---|
| 235 | | "_arraySliceSliceMulSliceAssign_t", |
|---|
| 236 | | "_arraySliceSliceMulSliceAssign_u", |
|---|
| 237 | | "_arraySliceSliceMulSliceAssign_w", |
|---|
| 238 | | |
|---|
| 239 | | "_arraySliceSliceMulass_d", // T[]*=T[] |
|---|
| 240 | | "_arraySliceSliceMulass_f", // T[]*=T[] |
|---|
| 241 | | "_arraySliceSliceMulass_i", |
|---|
| 242 | | "_arraySliceSliceMulass_k", |
|---|
| 243 | | "_arraySliceSliceMulass_s", |
|---|
| 244 | | "_arraySliceSliceMulass_t", |
|---|
| 245 | | "_arraySliceSliceMulass_u", |
|---|
| 246 | | "_arraySliceSliceMulass_w", |
|---|
| 247 | | }; |
|---|
| 248 | | |
|---|
| 249 | | int i = binary(name, libArrayopFuncs, sizeof(libArrayopFuncs) / sizeof(char *)); |
|---|
| 250 | | if (i == -1) |
|---|
| 251 | | { |
|---|
| 252 | | #ifdef DEBUG // Make sure our array is alphabetized |
|---|
| 253 | | for (i = 0; i < sizeof(libArrayopFuncs) / sizeof(char *); i++) |
|---|
| 254 | | { |
|---|
| 255 | | if (strcmp(name, libArrayopFuncs[i]) == 0) |
|---|
| 256 | | assert(0); |
|---|
| 257 | | } |
|---|
| | 67 | // /* Some of the array op functions are written as library functions, |
|---|
| | 68 | // * presumably to optimize them with special CPU vector instructions. |
|---|
| | 69 | // * List those library functions here, in alpha order. |
|---|
| | 70 | // */ |
|---|
| | 71 | // static const char *libArrayopFuncs[] = |
|---|
| | 72 | // { |
|---|
| | 73 | // "_arrayExpSliceAddass_a", |
|---|
| | 74 | // "_arrayExpSliceAddass_d", // T[]+=T |
|---|
| | 75 | // "_arrayExpSliceAddass_f", // T[]+=T |
|---|
| | 76 | // "_arrayExpSliceAddass_g", |
|---|
| | 77 | // "_arrayExpSliceAddass_h", |
|---|
| | 78 | // "_arrayExpSliceAddass_i", |
|---|
| | 79 | // "_arrayExpSliceAddass_k", |
|---|
| | 80 | // "_arrayExpSliceAddass_s", |
|---|
| | 81 | // "_arrayExpSliceAddass_t", |
|---|
| | 82 | // "_arrayExpSliceAddass_u", |
|---|
| | 83 | // "_arrayExpSliceAddass_w", |
|---|
| | 84 | // |
|---|
| | 85 | // "_arrayExpSliceDivass_d", // T[]/=T |
|---|
| | 86 | // "_arrayExpSliceDivass_f", // T[]/=T |
|---|
| | 87 | // |
|---|
| | 88 | // "_arrayExpSliceMinSliceAssign_a", |
|---|
| | 89 | // "_arrayExpSliceMinSliceAssign_d", // T[]=T-T[] |
|---|
| | 90 | // "_arrayExpSliceMinSliceAssign_f", // T[]=T-T[] |
|---|
| | 91 | // "_arrayExpSliceMinSliceAssign_g", |
|---|
| | 92 | // "_arrayExpSliceMinSliceAssign_h", |
|---|
| | 93 | // "_arrayExpSliceMinSliceAssign_i", |
|---|
| | 94 | // "_arrayExpSliceMinSliceAssign_k", |
|---|
| | 95 | // "_arrayExpSliceMinSliceAssign_s", |
|---|
| | 96 | // "_arrayExpSliceMinSliceAssign_t", |
|---|
| | 97 | // "_arrayExpSliceMinSliceAssign_u", |
|---|
| | 98 | // "_arrayExpSliceMinSliceAssign_w", |
|---|
| | 99 | // |
|---|
| | 100 | // "_arrayExpSliceMinass_a", |
|---|
| | 101 | // "_arrayExpSliceMinass_d", // T[]-=T |
|---|
| | 102 | // "_arrayExpSliceMinass_f", // T[]-=T |
|---|
| | 103 | // "_arrayExpSliceMinass_g", |
|---|
| | 104 | // "_arrayExpSliceMinass_h", |
|---|
| | 105 | // "_arrayExpSliceMinass_i", |
|---|
| | 106 | // "_arrayExpSliceMinass_k", |
|---|
| | 107 | // "_arrayExpSliceMinass_s", |
|---|
| | 108 | // "_arrayExpSliceMinass_t", |
|---|
| | 109 | // "_arrayExpSliceMinass_u", |
|---|
| | 110 | // "_arrayExpSliceMinass_w", |
|---|
| | 111 | // |
|---|
| | 112 | // "_arrayExpSliceMulass_d", // T[]*=T |
|---|
| | 113 | // "_arrayExpSliceMulass_f", // T[]*=T |
|---|
| | 114 | // "_arrayExpSliceMulass_i", |
|---|
| | 115 | // "_arrayExpSliceMulass_k", |
|---|
| | 116 | // "_arrayExpSliceMulass_s", |
|---|
| | 117 | // "_arrayExpSliceMulass_t", |
|---|
| | 118 | // "_arrayExpSliceMulass_u", |
|---|
| | 119 | // "_arrayExpSliceMulass_w", |
|---|
| | 120 | // |
|---|
| | 121 | // "_arraySliceExpAddSliceAssign_a", |
|---|
| | 122 | // "_arraySliceExpAddSliceAssign_d", // T[]=T[]+T |
|---|
| | 123 | // "_arraySliceExpAddSliceAssign_f", // T[]=T[]+T |
|---|
| | 124 | // "_arraySliceExpAddSliceAssign_g", |
|---|
| | 125 | // "_arraySliceExpAddSliceAssign_h", |
|---|
| | 126 | // "_arraySliceExpAddSliceAssign_i", |
|---|
| | 127 | // "_arraySliceExpAddSliceAssign_k", |
|---|
| | 128 | // "_arraySliceExpAddSliceAssign_s", |
|---|
| | 129 | // "_arraySliceExpAddSliceAssign_t", |
|---|
| | 130 | // "_arraySliceExpAddSliceAssign_u", |
|---|
| | 131 | // "_arraySliceExpAddSliceAssign_w", |
|---|
| | 132 | // |
|---|
| | 133 | // "_arraySliceExpDivSliceAssign_d", // T[]=T[]/T |
|---|
| | 134 | // "_arraySliceExpDivSliceAssign_f", // T[]=T[]/T |
|---|
| | 135 | // |
|---|
| | 136 | // "_arraySliceExpMinSliceAssign_a", |
|---|
| | 137 | // "_arraySliceExpMinSliceAssign_d", // T[]=T[]-T |
|---|
| | 138 | // "_arraySliceExpMinSliceAssign_f", // T[]=T[]-T |
|---|
| | 139 | // "_arraySliceExpMinSliceAssign_g", |
|---|
| | 140 | // "_arraySliceExpMinSliceAssign_h", |
|---|
| | 141 | // "_arraySliceExpMinSliceAssign_i", |
|---|
| | 142 | // "_arraySliceExpMinSliceAssign_k", |
|---|
| | 143 | // "_arraySliceExpMinSliceAssign_s", |
|---|
| | 144 | // "_arraySliceExpMinSliceAssign_t", |
|---|
| | 145 | // "_arraySliceExpMinSliceAssign_u", |
|---|
| | 146 | // "_arraySliceExpMinSliceAssign_w", |
|---|
| | 147 | // |
|---|
| | 148 | // "_arraySliceExpMulSliceAddass_d", // T[] += T[]*T |
|---|
| | 149 | // "_arraySliceExpMulSliceAddass_f", |
|---|
| | 150 | // "_arraySliceExpMulSliceAddass_r", |
|---|
| | 151 | // |
|---|
| | 152 | // "_arraySliceExpMulSliceAssign_d", // T[]=T[]*T |
|---|
| | 153 | // "_arraySliceExpMulSliceAssign_f", // T[]=T[]*T |
|---|
| | 154 | // "_arraySliceExpMulSliceAssign_i", |
|---|
| | 155 | // "_arraySliceExpMulSliceAssign_k", |
|---|
| | 156 | // "_arraySliceExpMulSliceAssign_s", |
|---|
| | 157 | // "_arraySliceExpMulSliceAssign_t", |
|---|
| | 158 | // "_arraySliceExpMulSliceAssign_u", |
|---|
| | 159 | // "_arraySliceExpMulSliceAssign_w", |
|---|
| | 160 | // |
|---|
| | 161 | // "_arraySliceExpMulSliceMinass_d", // T[] -= T[]*T |
|---|
| | 162 | // "_arraySliceExpMulSliceMinass_f", |
|---|
| | 163 | // "_arraySliceExpMulSliceMinass_r", |
|---|
| | 164 | // |
|---|
| | 165 | // "_arraySliceSliceAddSliceAssign_a", |
|---|
| | 166 | // "_arraySliceSliceAddSliceAssign_d", // T[]=T[]+T[] |
|---|
| | 167 | // "_arraySliceSliceAddSliceAssign_f", // T[]=T[]+T[] |
|---|
| | 168 | // "_arraySliceSliceAddSliceAssign_g", |
|---|
| | 169 | // "_arraySliceSliceAddSliceAssign_h", |
|---|
| | 170 | // "_arraySliceSliceAddSliceAssign_i", |
|---|
| | 171 | // "_arraySliceSliceAddSliceAssign_k", |
|---|
| | 172 | // "_arraySliceSliceAddSliceAssign_r", // T[]=T[]+T[] |
|---|
| | 173 | // "_arraySliceSliceAddSliceAssign_s", |
|---|
| | 174 | // "_arraySliceSliceAddSliceAssign_t", |
|---|
| | 175 | // "_arraySliceSliceAddSliceAssign_u", |
|---|
| | 176 | // "_arraySliceSliceAddSliceAssign_w", |
|---|
| | 177 | // |
|---|
| | 178 | // "_arraySliceSliceAddass_a", |
|---|
| | 179 | // "_arraySliceSliceAddass_d", // T[]+=T[] |
|---|
| | 180 | // "_arraySliceSliceAddass_f", // T[]+=T[] |
|---|
| | 181 | // "_arraySliceSliceAddass_g", |
|---|
| | 182 | // "_arraySliceSliceAddass_h", |
|---|
| | 183 | // "_arraySliceSliceAddass_i", |
|---|
| | 184 | // "_arraySliceSliceAddass_k", |
|---|
| | 185 | // "_arraySliceSliceAddass_s", |
|---|
| | 186 | // "_arraySliceSliceAddass_t", |
|---|
| | 187 | // "_arraySliceSliceAddass_u", |
|---|
| | 188 | // "_arraySliceSliceAddass_w", |
|---|
| | 189 | // |
|---|
| | 190 | // "_arraySliceSliceMinSliceAssign_a", |
|---|
| | 191 | // "_arraySliceSliceMinSliceAssign_d", // T[]=T[]-T[] |
|---|
| | 192 | // "_arraySliceSliceMinSliceAssign_f", // T[]=T[]-T[] |
|---|
| | 193 | // "_arraySliceSliceMinSliceAssign_g", |
|---|
| | 194 | // "_arraySliceSliceMinSliceAssign_h", |
|---|
| | 195 | // "_arraySliceSliceMinSliceAssign_i", |
|---|
| | 196 | // "_arraySliceSliceMinSliceAssign_k", |
|---|
| | 197 | // "_arraySliceSliceMinSliceAssign_r", // T[]=T[]-T[] |
|---|
| | 198 | // "_arraySliceSliceMinSliceAssign_s", |
|---|
| | 199 | // "_arraySliceSliceMinSliceAssign_t", |
|---|
| | 200 | // "_arraySliceSliceMinSliceAssign_u", |
|---|
| | 201 | // "_arraySliceSliceMinSliceAssign_w", |
|---|
| | 202 | // |
|---|
| | 203 | // "_arraySliceSliceMinass_a", |
|---|
| | 204 | // "_arraySliceSliceMinass_d", // T[]-=T[] |
|---|
| | 205 | // "_arraySliceSliceMinass_f", // T[]-=T[] |
|---|
| | 206 | // "_arraySliceSliceMinass_g", |
|---|
| | 207 | // "_arraySliceSliceMinass_h", |
|---|
| | 208 | // "_arraySliceSliceMinass_i", |
|---|
| | 209 | // "_arraySliceSliceMinass_k", |
|---|
| | 210 | // "_arraySliceSliceMinass_s", |
|---|
| | 211 | // "_arraySliceSliceMinass_t", |
|---|
| | 212 | // "_arraySliceSliceMinass_u", |
|---|
| | 213 | // "_arraySliceSliceMinass_w", |
|---|
| | 214 | // |
|---|
| | 215 | // "_arraySliceSliceMulSliceAssign_d", // T[]=T[]*T[] |
|---|
| | 216 | // "_arraySliceSliceMulSliceAssign_f", // T[]=T[]*T[] |
|---|
| | 217 | // "_arraySliceSliceMulSliceAssign_i", |
|---|
| | 218 | // "_arraySliceSliceMulSliceAssign_k", |
|---|
| | 219 | // "_arraySliceSliceMulSliceAssign_s", |
|---|
| | 220 | // "_arraySliceSliceMulSliceAssign_t", |
|---|
| | 221 | // "_arraySliceSliceMulSliceAssign_u", |
|---|
| | 222 | // "_arraySliceSliceMulSliceAssign_w", |
|---|
| | 223 | // |
|---|
| | 224 | // "_arraySliceSliceMulass_d", // T[]*=T[] |
|---|
| | 225 | // "_arraySliceSliceMulass_f", // T[]*=T[] |
|---|
| | 226 | // "_arraySliceSliceMulass_i", |
|---|
| | 227 | // "_arraySliceSliceMulass_k", |
|---|
| | 228 | // "_arraySliceSliceMulass_s", |
|---|
| | 229 | // "_arraySliceSliceMulass_t", |
|---|
| | 230 | // "_arraySliceSliceMulass_u", |
|---|
| | 231 | // "_arraySliceSliceMulass_w", |
|---|
| | 232 | // }; |
|---|
| | 233 | // |
|---|
| | 234 | // int i = binary(name, libArrayopFuncs, sizeof(libArrayopFuncs) / sizeof(char *)); |
|---|
| | 235 | // if (i == -1) |
|---|
| | 236 | // { |
|---|
| | 237 | // #ifdef DEBUG // Make sure our array is alphabetized |
|---|
| | 238 | // for (i = 0; i < sizeof(libArrayopFuncs) / sizeof(char *); i++) |
|---|
| | 239 | // { |
|---|
| | 240 | // if (strcmp(name, libArrayopFuncs[i]) == 0) |
|---|
| | 241 | // assert(0); |
|---|
| | 242 | // } |
|---|
| | 243 | // #endif |
|---|
| | 244 | |
|---|
| | 245 | /* Not in library, so generate it. |
|---|
| | 246 | * Construct the function body: |
|---|
| | 247 | * foreach (i; 0 .. p.length) for (size_t i = 0; i < p.length; i++) |
|---|
| | 248 | * loopbody; |
|---|
| | 249 | * return p; |
|---|
| | 250 | */ |
|---|
| | 251 | |
|---|
| | 252 | Arguments *fparams = new Arguments(); |
|---|
| | 253 | Expression *loopbody = buildArrayLoop(fparams); |
|---|
| | 254 | Argument *p = (Argument *)fparams->data[0 /*fparams->dim - 1*/]; |
|---|
| | 255 | #if DMDV1 |
|---|
| | 256 | // for (size_t i = 0; i < p.length; i++) |
|---|
| | 257 | Initializer *init = new ExpInitializer(0, new IntegerExp(0, 0, Type::tsize_t)); |
|---|
| | 258 | Dsymbol *d = new VarDeclaration(0, Type::tsize_t, Id::p, init); |
|---|
| | 259 | Statement *s1 = new ForStatement(0, |
|---|
| | 260 | new DeclarationStatement(0, d), |
|---|
| | 261 | new CmpExp(TOKlt, 0, new IdentifierExp(0, Id::p), new ArrayLengthExp(0, new IdentifierExp(0, p->ident))), |
|---|
| | 262 | new PostExp(TOKplusplus, 0, new IdentifierExp(0, Id::p)), |
|---|
| | 263 | new ExpStatement(0, loopbody)); |
|---|
| | 264 | #else |
|---|
| | 265 | // foreach (i; 0 .. p.length) |
|---|
| | 266 | Statement *s1 = new ForeachRangeStatement(0, TOKforeach, |
|---|
| | 267 | new Argument(0, NULL, Id::p, NULL), |
|---|
| | 268 | new IntegerExp(0, 0, Type::tint32), |
|---|
| | 269 | new ArrayLengthExp(0, new IdentifierExp(0, p->ident)), |
|---|
| | 270 | new ExpStatement(0, loopbody)); |
|---|