| blob | 6b300041a479d340c401b02868d39529b9431d14 |
1 /*
2 * Copyright (C) 2024 Mikulas Patocka
3 *
4 * This file is part of Ajla.
5 *
6 * Ajla is free software: you can redistribute it and/or modify it under the
7 * terms of the GNU General Public License as published by the Free Software
8 * Foundation, either version 3 of the License, or (at your option) any later
9 * version.
10 *
11 * Ajla is distributed in the hope that it will be useful, but WITHOUT ANY
12 * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
13 * A PARTICULAR PURPOSE. See the GNU General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License along with
16 * Ajla. If not, see <https://www.gnu.org/licenses/>.
17 */
19 #define PARISC_N 0x2U
21 #define PARISC_COND_64 0x0020U
22 #define PARISC_COND_NEVER 0x0000U
23 #define PARISC_COND_ALWAYS 0x1000U
24 #define PARISC_COND_EQUAL 0x2000U
25 #define PARISC_COND_NOT_EQUAL 0x3000U
26 #define PARISC_COND_L_S 0x4000U
27 #define PARISC_COND_GE_S 0x5000U
28 #define PARISC_COND_LE_S 0x6000U
29 #define PARISC_COND_G_S 0x7000U
30 #define PARISC_COND_L_U 0x8000U
31 #define PARISC_COND_GE_U 0x9000U
32 #define PARISC_COND_LE_U 0xa000U
33 #define PARISC_COND_G_U 0xb000U
34 #define PARISC_COND_SV 0xc000U
35 #define PARISC_COND_NSV 0xd000U
36 #define PARISC_COND_OD 0xe000U
37 #define PARISC_COND_EV 0xf000U
38 #define PARISC_COND_NEG 0x1000U
40 #define PARISC_LDSID 0x000010a0U
41 #define PARISC_MTSP 0x00001820U
42 #define PARISC_MTSAR 0x01601840U
43 #define PARISC_MTSARCM 0x016018c0U
44 #define PARISC_ANDCM 0x08000000U
45 #define PARISC_AND 0x08000200U
46 #define PARISC_OR 0x08000240U
47 #define PARISC_NOP 0x08000240U
48 #define PARISC_XOR 0x08000280U
49 #define PARISC_SUB 0x08000400U
50 #define PARISC_SUB_B 0x08000500U
51 #define PARISC_SUB_DB 0x08000520U
52 #define PARISC_ADD 0x08000600U
53 #define PARISC_ADD_C 0x08000700U
54 #define PARISC_ADD_DC 0x08000720U
55 #define PARISC_CMPCLR 0x08000880U
56 #define PARISC_UADDCM 0x08000980U
57 #define PARISC_ADD_L 0x08000a00U
58 #define PARISC_SHLADD_L_1 0x08000a40U
59 #define PARISC_SHLADD_L_2 0x08000a80U
60 #define PARISC_SHLADD_L_3 0x08000ac0U
62 #define PARISC_LD_ST 0x0c000000U
63 #define PARISC_LD_ST_B 0x00000000U
64 #define PARISC_LD_ST_H 0x00000040U
65 #define PARISC_LD_ST_W 0x00000080U
66 #define PARISC_LD_ST_D 0x000000c0U
67 #define PARISC_LD_ST_IMM 0x00001000U
68 #define PARISC_LD_ST_MA 0x00000020U
69 #define PARISC_LD_ST_MB 0x00002020U
70 #define PARISC_LD_ST_LD 0x00000000U
71 #define PARISC_LD_ST_ST 0x00000200U
72 #define PARISC_LD_SCALE 0x00002000U
73 #define PARISC_LDIL 0x20000000U
74 #define PARISC_ADDIL 0x28000000U
75 #define PARISC_LDO 0x34000000U
77 #define PARISC_LDB_LONG 0x40000000U
78 #define PARISC_LDH_LONG 0x44000000U
79 #define PARISC_LDW_LONG 0x48000000U
80 #define PARISC_LDW_M 0x4c000000U
81 #define PARISC_LDD 0x50000000U
82 #define PARISC_STB_LONG 0x60000000U
83 #define PARISC_STH_LONG 0x64000000U
84 #define PARISC_STW_LONG 0x68000000U
85 #define PARISC_STW_M 0x6c000000U
86 #define PARISC_STD 0x70000000U
87 #define PARISC_LDD_STD_MA 0x00000008U
88 #define PARISC_LDD_STD_MB 0x0000000cU
90 #define PARISC_CMPB 0x80000000U
91 #define PARISC_CMPIB 0x84000000U
92 #define PARISC_CMPB_NOT 0x88000000U
93 #define PARISC_CMPIB_NOT 0x8c000000U
94 #define PARISC_CMPICLR 0x90000000U
95 #define PARISC_CMPICLR_64 0x00000800U
96 #define PARISC_SUBI 0x94000000U
97 #define PARISC_CMPB_64 0x9c000000U
98 #define PARISC_ADDB 0xa0000000U
99 #define PARISC_ADDB_NOT 0xa8000000U
100 #define PARISC_ADDI 0xb4000000U
101 #define PARISC_CMPB_64_NOT 0xbc000000U
103 #define PARISC_BB_1 0xc4004000U
104 #define PARISC_BB_64_1 0xc4006000U
105 #define PARISC_BB_0 0xc400c000U
106 #define PARISC_BB_64_0 0xc400e000U
107 #define PARISC_SHRPW_SAR 0xd0000000U
108 #define PARISC_SHRPD_SAR 0xd0000200U
109 #define PARISC_EXTRW_U_SAR 0xd0001000U
110 #define PARISC_EXTRD_U_SAR 0xd0001200U
111 #define PARISC_EXTRW_S_SAR 0xd0001400U
112 #define PARISC_EXTRD_S_SAR 0xd0001600U
113 #define PARISC_EXTRW_U 0xd0001800U
114 #define PARISC_EXTRW_S 0xd0001c00U
115 #define PARISC_DEPW_Z_SAR 0xd4000000U
116 #define PARISC_DEPD_Z_SAR 0xd4000200U
117 #define PARISC_DEPW_SAR 0xd4000400U
118 #define PARISC_DEPD_SAR 0xd4000600U
119 #define PARISC_DEPW_Z 0xd4000800U
120 #define PARISC_DEPW 0xd4000c00U
121 #define PARISC_DEPWI_Z_SAR 0xd4001000U
122 #define PARISC_DEPDI_Z_SAR 0xd4001200U
123 #define PARISC_DEPWI_SAR 0xd4001400U
124 #define PARISC_DEPDI_SAR 0xd4001600U
125 #define PARISC_DEPWI_Z 0xd4001800U
126 #define PARISC_DEPWI 0xd4001c00U
127 #define PARISC_EXTRD_U 0xd8001800U
128 #define PARISC_EXTRD_S 0xd8001c00U
129 #define PARISC_BE 0xe0000000U
130 #define PARISC_BL 0xe8000000U
131 #define PARISC_BLR 0xe8004000U
132 #define PARISC_BL_L 0xe800a000U
133 #define PARISC_BV 0xe800c000U
134 #define PARISC_BVE_RET 0xe800d000U
135 #define PARISC_BVE_CALL 0xe800f000U
136 #define PARISC_CMPIB_64 0xec000000U
137 #define PARISC_DEPD_Z 0xf0001000U
138 #define PARISC_DEPD 0xf0001400U
139 #define PARISC_DEPDI_Z 0xf4000000U
140 #define PARISC_DEPDI 0xf4000400U
142 #define PARISC_FP_DOUBLE 0x00000800U
143 #define PARISC_FLDW 0x24001000U
144 #define PARISC_FSTW 0x24001200U
145 #define PARISC_FLDD 0x2c001000U
146 #define PARISC_FSTD 0x2c001200U
147 #define PARISC_FCMP 0x30000400U
148 #define PARISC_FCMP_P 0x02U
149 #define PARISC_FCMP_NE 0x04U
150 #define PARISC_FCMP_AE 0x08U
151 #define PARISC_FCMP_A 0x0cU
152 #define PARISC_FCMP_BE 0x10U
153 #define PARISC_FCMP_B 0x14U
154 #define PARISC_FCMP_E 0x18U
155 #define PARISC_FCMP_NP 0x1cU
156 #define PARISC_FADD 0x30000600U
157 #define PARISC_FTEST 0x30002420U
158 #define PARISC_FSUB 0x30002600U
159 #define PARISC_FCPY 0x30004000U
160 #define PARISC_FMPY 0x30004600U
161 #define PARISC_FDIV 0x30006600U
162 #define PARISC_FCNVXF 0x30008200U
163 #define PARISC_FCNVXF_FROM_LONG 0x00000800U
164 #define PARISC_FCNVXF_TO_DOUBLE 0x00002000U
165 #define PARISC_FSQRT 0x30008000U
166 #define PARISC_FNEG 0x3000c000U
167 #define PARISC_FCNVFXT 0x30018200U
168 #define PARISC_FCNVFXT_FROM_DOUBLE 0x00000800U
169 #define PARISC_FCNVFXT_TO_LONG 0x00002000U
170 #define PARISC_FLDD_LONG 0x50000002U
171 #define PARISC_FLDW_LONG 0x5c000000U
172 #define PARISC_FSTD_LONG 0x70000002U
173 #define PARISC_FSTW_LONG 0x7c000000U
175 static const int32_t cmp_sub_cond[0x12] = {
176 PARISC_COND_SV, PARISC_COND_NSV, PARISC_COND_L_U, PARISC_COND_GE_U,
177 PARISC_COND_EQUAL, PARISC_COND_NOT_EQUAL, PARISC_COND_LE_U, PARISC_COND_G_U,
178 PARISC_COND_L_S, PARISC_COND_GE_S, -1, -1,
179 PARISC_COND_L_S, PARISC_COND_GE_S, PARISC_COND_LE_S, PARISC_COND_G_S,
180 PARISC_COND_EV, PARISC_COND_OD,
181 };
183 static unsigned cmp_swap_arguments(unsigned cond)
184 {
185 switch (cond) {
186 case COND_B: return COND_A;
187 case COND_AE: return COND_BE;
188 case COND_E: return COND_E;
189 case COND_NE: return COND_NE;
190 case COND_BE: return COND_AE;
191 case COND_A: return COND_B;
192 case COND_L: return COND_G;
193 case COND_GE: return COND_LE;
194 case COND_LE: return COND_GE;
195 case COND_G: return COND_L;
196 }
197 internal(file_line, "cmp_swap_arguments: can't swap the condition %u", cond);
198 return 0;
199 }
201 static bool attr_w cgen_2reg(struct codegen_context *ctx, uint32_t mc, unsigned r1, unsigned rt)
202 {
203 mc |= (uint32_t)r1 << 21;
204 mc |= (uint32_t)rt << 16;
205 cgen_four(mc);
206 return true;
207 }
209 static bool attr_w cgen_3reg(struct codegen_context *ctx, uint32_t mc, unsigned r1, unsigned r2, unsigned rt)
210 {
211 mc |= (uint32_t)r1 << 16;
212 mc |= (uint32_t)r2 << 21;
213 mc |= rt;
214 cgen_four(mc);
215 return true;
216 }
218 static uint32_t attr_unused low_sign_ext_5(unsigned bit5)
219 {
220 return ((bit5 & 0x10) >> 4) |
221 ((bit5 & 0x0f) << 1);
222 }
224 static uint32_t low_sign_ext_11(unsigned bit11)
225 {
226 return ((bit11 & 0x400) >> 10) |
227 ((bit11 & 0x3ff) << 1);
228 }
230 static uint32_t low_sign_ext_14(unsigned bit14)
231 {
232 return ((bit14 & 0x2000) >> 13) |
233 ((bit14 & 0x1fff) << 1);
234 }
236 static uint32_t assemble_12(uint32_t bit12)
237 {
238 return ((bit12 & 0x800) >> 11) |
239 ((bit12 & 0x400) >> 8) |
240 ((bit12 & 0x3ff) << 3);
241 }
243 static uint32_t assemble_17(uint32_t bit17)
244 {
245 return ((bit17 & 0x10000) >> 16) |
246 ((bit17 & 0x0f800) << 5) |
247 ((bit17 & 0x00400) >> 8) |
248 ((bit17 & 0x003ff) << 3);
249 }
251 static uint32_t assemble_21(uint32_t bit21)
252 {
253 return ((bit21 & 0x100000) >> 20) |
254 ((bit21 & 0x0ffe00) >> 8) |
255 ((bit21 & 0x000180) << 7) |
256 ((bit21 & 0x00007c) << 14) |
257 ((bit21 & 0x000003) << 12);
258 }
260 static uint32_t assemble_22(uint32_t bit22)
261 {
262 return ((bit22 & 0x200000) >> 21) |
263 ((bit22 & 0x1f0000) << 5) |
264 ((bit22 & 0x00f800) << 5) |
265 ((bit22 & 0x000400) >> 8) |
266 ((bit22 & 0x0003ff) << 3);
267 }
269 static bool attr_w cgen_ret(struct codegen_context *ctx)
270 {
271 uint32_t mc;
272 if (!PA_20 && PA_SPACES) {
273 mc = PARISC_LDSID;
274 mc |= (uint32_t)R_RP << 21;
275 mc |= R_CG_SCRATCH;
276 cgen_four(mc);
277 mc = PARISC_MTSP;
278 mc |= (uint32_t)R_CG_SCRATCH << 16;
279 cgen_four(mc);
280 mc = PARISC_BE;
281 mc |= (uint32_t)R_RP << 21;
282 mc |= PARISC_N;
283 cgen_four(mc);
284 } else {
285 mc = PA_20 ? PARISC_BVE_RET : PARISC_BV;
286 mc |= (uint32_t)R_RP << 21;
287 mc |= PARISC_N;
288 cgen_four(mc);
289 }
290 cgen_four(PARISC_NOP);
291 return true;
292 }
294 static bool attr_w cgen_call(struct codegen_context *ctx, unsigned length)
295 {
296 if (length <= JMP_SHORT) {
297 g(add_relocation(ctx, JMP_SHORT, 0, NULL));
298 cgen_four(PARISC_BL | ((uint32_t)R_RP << 21) | PARISC_N);
299 cgen_four(PARISC_NOP);
300 } else if (length == JMP_LONG && PA_20) {
301 g(add_relocation(ctx, JMP_LONG, 0, NULL));
302 cgen_four(PARISC_BL_L | PARISC_N);
303 cgen_four(PARISC_NOP);
304 } else {
305 g(add_relocation(ctx, JMP_EXTRA_LONG, 0, NULL));
306 cgen_four(PARISC_LDIL | ((uint32_t)R_CG_SCRATCH << 21));
307 g(cgen_2reg(ctx, PARISC_LDO, R_CG_SCRATCH, R_CG_SCRATCH));
308 g(cgen_2reg(ctx, PARISC_BLR | PARISC_N, R_RP, R_CG_SCRATCH));
309 g(cgen_2reg(ctx, PARISC_BLR | PARISC_N, R_RP, R_CG_SCRATCH));
310 cgen_four(PARISC_NOP);
311 }
312 return true;
313 }
315 static bool attr_w cgen_call_indirect(struct codegen_context *ctx)
316 {
317 uint32_t mc;
318 unsigned reg = cget_one(ctx);
320 mc = PARISC_LDD | low_sign_ext_14(0x10);
321 g(cgen_2reg(ctx, mc, reg, R_31));
323 cgen_four(PARISC_BVE_CALL | ((uint32_t)R_31 << 21));
325 mc = PARISC_LDD | low_sign_ext_14(0x18);
326 g(cgen_2reg(ctx, mc, reg, R_DP));
328 return true;
329 }
331 static bool attr_w cgen_ld_st(struct codegen_context *ctx, bool ld, unsigned size, uint8_t reg, uint8_t *address)
332 {
333 int64_t imm = 0;
334 uint32_t mc;
336 if (address[0] == ARG_ADDRESS_1) {
337 imm = get_imm(&address[2]);
338 if (ld) {
339 switch (size) {
340 case OP_SIZE_1: mc = PARISC_LDB_LONG; break;
341 case OP_SIZE_2: mc = PARISC_LDH_LONG; break;
342 case OP_SIZE_4: mc = PARISC_LDW_LONG; break;
343 case OP_SIZE_8: mc = PARISC_LDD; break;
344 default: goto invalid;
345 }
346 } else {
347 switch (size) {
348 case OP_SIZE_1: mc = PARISC_STB_LONG; break;
349 case OP_SIZE_2: mc = PARISC_STH_LONG; break;
350 case OP_SIZE_4: mc = PARISC_STW_LONG; break;
351 case OP_SIZE_8: mc = PARISC_STD; break;
352 default: goto invalid;
353 }
354 }
355 mc |= low_sign_ext_14(imm);
356 g(cgen_2reg(ctx, mc, address[1], reg));
357 return true;
358 }
359 if (address[0] == ARG_ADDRESS_1_PRE_I || address[0] == ARG_ADDRESS_1_POST_I) {
360 imm = get_imm(&address[2]);
361 if (size == OP_SIZE_4) {
362 if (imm >= 0 && address[0] == ARG_ADDRESS_1_PRE_I)
363 goto invalid;
364 if (imm < 0 && address[0] == ARG_ADDRESS_1_POST_I)
365 goto invalid;
366 }
367 if (ld) {
368 switch (size) {
369 case OP_SIZE_4: mc = PARISC_LDW_M; break;
370 case OP_SIZE_8: mc = PARISC_LDD | (address[0] == ARG_ADDRESS_1_PRE_I ? PARISC_LDD_STD_MB : PARISC_LDD_STD_MA); break;
371 default: goto invalid;
372 }
373 } else {
374 switch (size) {
375 case OP_SIZE_4: mc = PARISC_STW_M; break;
376 case OP_SIZE_8: mc = PARISC_STD | (address[0] == ARG_ADDRESS_1_PRE_I ? PARISC_LDD_STD_MB : PARISC_LDD_STD_MA); break;
377 default: goto invalid;
378 }
379 }
380 mc |= low_sign_ext_14(imm);
381 g(cgen_2reg(ctx, mc, address[1], reg));
382 return true;
383 }
384 if (address[0] >= ARG_ADDRESS_2 && address[0] <= ARG_ADDRESS_2_8 && ld) {
385 imm = get_imm(&address[3]);
386 if (unlikely(imm != 0))
387 goto invalid;
388 mc = PARISC_LD_ST | PARISC_LD_ST_LD;
389 if (address[0] == ARG_ADDRESS_2) {
390 } else if (address[0] == ARG_ADDRESS_2_4 && size == OP_SIZE_4) {
391 mc |= PARISC_LD_SCALE;
392 } else if (address[0] == ARG_ADDRESS_2_8 && size == OP_SIZE_8) {
393 mc |= PARISC_LD_SCALE;
394 } else {
395 goto invalid;
396 }
397 switch (size) {
398 case OP_SIZE_1: mc |= PARISC_LD_ST_B; break;
399 case OP_SIZE_2: mc |= PARISC_LD_ST_H; break;
400 case OP_SIZE_4: mc |= PARISC_LD_ST_W; break;
401 case OP_SIZE_8: mc |= PARISC_LD_ST_D; break;
402 default: goto invalid;
403 }
404 g(cgen_3reg(ctx, mc, address[2], address[1], reg));
405 return true;
406 }
407 invalid:
408 internal(file_line, "cgen_ld_st: invalid address: %x, %02x, %02x, %"PRIxMAX"", size, reg, address[0], (uintmax_t)imm);
409 return false;
410 }
412 static bool attr_w cgen_fp_ld_st(struct codegen_context *ctx, bool ld, unsigned size, uint8_t reg, uint8_t *address)
413 {
414 int64_t imm = 0;
415 uint32_t mc;
417 if (unlikely(address[0] != ARG_ADDRESS_1))
418 goto invalid;
420 imm = get_imm(&address[2]);
421 if (imm >= -0x10 && imm < 0x10) {
422 if (ld)
423 mc = size == OP_SIZE_4 ? PARISC_FLDW : PARISC_FLDD;
424 else
425 mc = size == OP_SIZE_4 ? PARISC_FSTW : PARISC_FSTD;
426 mc |= low_sign_ext_5(imm) << 16;
427 mc |= reg & 0x1f;
428 mc |= (uint32_t)address[1] << 21;
429 cgen_four(mc);
430 return true;
431 } else {
432 if (ld)
433 mc = size == OP_SIZE_4 ? PARISC_FLDW_LONG : PARISC_FLDD_LONG;
434 else
435 mc = size == OP_SIZE_4 ? PARISC_FSTW_LONG : PARISC_FSTD_LONG;
436 mc |= low_sign_ext_14(imm);
437 g(cgen_2reg(ctx, mc, address[1], reg & 0x1f));
438 return true;
439 }
441 invalid:
442 internal(file_line, "cgen_fp_ld_st: invalid address: %x, %02x, %02x, %"PRIxMAX"", size, reg, address[0], (uintmax_t)imm);
443 return false;
444 }
446 static bool attr_w cgen_mov_args(struct codegen_context *ctx, unsigned size, uint8_t *arg1, uint8_t *arg2)
447 {
448 int64_t imm;
449 uint32_t mc;
451 if (arg1[0] < 0x20) {
452 if (arg2[0] < 0x20) {
453 if (size < OP_SIZE_NATIVE) {
454 if (OP_SIZE_NATIVE == OP_SIZE_4) {
455 switch (size) {
456 case OP_SIZE_1:
457 mc = PARISC_EXTRW_U ^ 0x3f8U;
458 break;
459 case OP_SIZE_2:
460 mc = PARISC_EXTRW_U ^ 0x3f0U;
461 break;
462 default:
463 internal(file_line, "cgen_mov_args: invalid op size %u", size);
464 }
465 } else {
466 switch (size) {
467 case OP_SIZE_1:
468 mc = PARISC_EXTRD_U ^ 0x13f8U;
469 break;
470 case OP_SIZE_2:
471 mc = PARISC_EXTRD_U ^ 0x13f0U;
472 break;
473 case OP_SIZE_4:
474 mc = PARISC_EXTRD_U ^ 0x13e0U;
475 break;
476 default:
477 internal(file_line, "cgen_mov_args: invalid op size %u", size);
478 }
479 }
480 g(cgen_2reg(ctx, mc, arg2[0], arg1[0]));
481 return true;
482 }
483 g(cgen_3reg(ctx, PARISC_OR, arg2[0], 0, arg1[0]));
484 return true;
485 }
486 if (arg2[0] == ARG_IMM) {
487 imm = get_imm(&arg2[1]);
488 if (imm >= -0x2000 && imm < 0x2000) {
489 mc = PARISC_LDO;
490 mc |= low_sign_ext_14(imm);
491 g(cgen_2reg(ctx, mc, R_ZERO, arg1[0]));
492 return true;
493 }
494 if (imm & 0x7ff)
495 goto invalid;
496 mc = PARISC_LDIL;
497 mc |= (uint32_t)arg1[0] << 21;
498 mc |= assemble_21((uint64_t)imm >> 11);
499 cgen_four(mc);
500 return true;
501 }
502 return cgen_ld_st(ctx, true, size, arg1[0], arg2);
503 }
505 if (arg2[0] < 0x20) {
506 return cgen_ld_st(ctx, false, size, arg2[0], arg1);
507 }
508 if (arg2[0] == ARG_IMM) {
509 imm = get_imm(&arg2[1]);
510 if (unlikely(imm != 0))
511 goto invalid;
512 return cgen_ld_st(ctx, false, size, R_ZERO, arg1);
513 }
515 if (reg_is_fp(arg1[0]) && arg2[0] == ARG_ADDRESS_1) {
516 return cgen_fp_ld_st(ctx, true, size, arg1[0], arg2);
517 }
518 if (reg_is_fp(arg2[0]) && arg1[0] == ARG_ADDRESS_1) {
519 return cgen_fp_ld_st(ctx, false, size, arg2[0], arg1);
520 }
521 if (reg_is_fp(arg1[0]) && reg_is_fp(arg2[0])) {
522 mc = PARISC_FCPY;
523 switch (size) {
524 case OP_SIZE_4: break;
525 case OP_SIZE_8: mc |= PARISC_FP_DOUBLE; break;
526 default: internal(file_line, "cgen_fp_alu: invalid size %u", size);
527 }
528 g(cgen_3reg(ctx, mc, 0, arg2[0] & 0x1f, arg1[0] & 0x1f));
529 return true;
530 }
532 invalid:
533 internal(file_line, "cgen_mov_args: invalid arguments %02x, %02x", arg1[0], arg2[0]);
534 return false;
535 }
537 static bool attr_w cgen_mov(struct codegen_context *ctx, unsigned size)
538 {
539 uint8_t *arg1 = ctx->code_position;
540 uint8_t *arg2 = arg1 + arg_size(*arg1);
541 ctx->code_position = arg2 + arg_size(*arg2);
542 return cgen_mov_args(ctx, size, arg1, arg2);
543 }
545 static bool attr_w cgen_movsx(struct codegen_context *ctx, unsigned size)
546 {
547 uint32_t mc;
548 uint8_t *arg1 = ctx->code_position;
549 uint8_t *arg2 = arg1 + arg_size(*arg1);
550 ctx->code_position = arg2 + arg_size(*arg2);
551 if (unlikely(arg1[0] >= 0x20) || unlikely(arg2[0] >= 0x20))
552 internal(file_line, "cgen_movsx: invalid arguments %02x, %02x", arg1[0], arg2[0]);
554 if (size < OP_SIZE_NATIVE) {
555 if (OP_SIZE_NATIVE == OP_SIZE_4) {
556 switch (size) {
557 case OP_SIZE_1:
558 mc = PARISC_EXTRW_S ^ 0x3f8U;
559 break;
560 case OP_SIZE_2:
561 mc = PARISC_EXTRW_S ^ 0x3f0U;
562 break;
563 default:
564 internal(file_line, "cgen_movsx: invalid op size %u", size);
565 }
566 } else {
567 switch (size) {
568 case OP_SIZE_1:
569 mc = PARISC_EXTRD_S ^ 0x13f8U;
570 break;
571 case OP_SIZE_2:
572 mc = PARISC_EXTRD_S ^ 0x13f0U;
573 break;
574 case OP_SIZE_4:
575 mc = PARISC_EXTRD_S ^ 0x13e0U;
576 break;
577 default:
578 internal(file_line, "cgen_movsx: invalid op size %u", size);
579 }
580 }
581 g(cgen_2reg(ctx, mc, arg2[0], arg1[0]));
582 return true;
583 } else {
584 return cgen_mov_args(ctx, size, arg1, arg2);
585 }
586 }
588 static bool attr_w cgen_cmp_dest_reg(struct codegen_context *ctx, unsigned size, unsigned cond)
589 {
590 int32_t fc;
591 uint32_t mc;
592 uint8_t *arg1 = ctx->code_position;
593 uint8_t *arg2 = arg1 + arg_size(*arg1);
594 uint8_t *arg3 = arg2 + arg_size(*arg2);
595 ctx->code_position = arg3 + arg_size(*arg3);
597 if (arg3[0] == ARG_IMM) {
598 cond = cmp_swap_arguments(cond);
599 }
601 fc = cmp_sub_cond[cond];
602 fc ^= PARISC_COND_NEG;
604 if (arg3[0] == ARG_IMM) {
605 int64_t imm = get_imm(&arg3[1]);
606 mc = PARISC_CMPICLR;
607 if (size == OP_SIZE_8)
608 mc |= PARISC_CMPICLR_64;
609 mc |= fc;
610 mc |= low_sign_ext_11(imm);
611 g(cgen_2reg(ctx, mc, arg2[0], arg1[0]));
612 } else {
613 mc = PARISC_CMPCLR;
614 if (size == OP_SIZE_8)
615 mc |= PARISC_COND_64;
616 mc |= fc;
617 g(cgen_3reg(ctx, mc, arg2[0], arg3[0], arg1[0]));
618 }
620 mc = PARISC_LDO;
621 mc |= low_sign_ext_14(1);
622 g(cgen_2reg(ctx, mc, R_ZERO, arg1[0]));
624 return true;
625 }
627 static bool attr_w cgen_alu(struct codegen_context *ctx, unsigned size, unsigned writes_flags, unsigned alu, bool trap, unsigned length)
628 {
629 uint32_t mc;
630 uint8_t *arg1 = ctx->code_position;
631 uint8_t *arg2 = arg1 + arg_size(*arg1);
632 uint8_t *arg3 = arg2 + arg_size(*arg2);
633 ctx->code_position = arg3 + arg_size(*arg3);
635 if (unlikely(arg1[0] >= 0x20) || unlikely(arg2[0] >= 0x20))
636 goto invalid;
638 if (arg3[0] == ARG_IMM && !trap) {
639 int64_t imm = get_imm(&arg3[1]);
640 if (unlikely(writes_flags))
641 goto invalid;
642 switch (alu) {
643 case ALU_SUB:
644 imm = -(uint64_t)imm;
645 /*-fallthrough*/
646 case ALU_ADD:
647 if (imm >= -0x2000 && imm < 0x2000) {
648 mc = PARISC_LDO;
649 mc |= low_sign_ext_14(imm);
650 g(cgen_2reg(ctx, mc, arg2[0], arg1[0]));
651 return true;
652 } else if (!(imm & 0x7ff) && arg1[0] == R_1) {
653 mc = PARISC_ADDIL;
654 mc |= (uint32_t)arg2[0] << 21;
655 mc |= assemble_21((uint64_t)imm >> 11);
656 cgen_four(mc);
657 return true;
658 } else {
659 goto invalid;
660 }
661 default:
662 goto invalid;
663 }
664 }
666 switch (alu) {
667 case ALU_ADD: mc = writes_flags ? PARISC_ADD : PARISC_ADD_L;
668 break;
669 case ALU_OR: ajla_assert_lo(!writes_flags, (file_line, "cgen_alu: or must not write flags"));
670 mc = PARISC_OR;
671 break;
672 case ALU_ADC: ajla_assert_lo(writes_flags, (file_line, "cgen_alu: adc must write flags"));
673 mc = size == OP_SIZE_4 ? PARISC_ADD_C : PARISC_ADD_DC;
674 break;
675 case ALU_SBB: ajla_assert_lo(writes_flags, (file_line, "cgen_alu: sbb must write flags"));
676 mc = size == OP_SIZE_4 ? PARISC_SUB_B : PARISC_SUB_DB;
677 break;
678 case ALU_AND: ajla_assert_lo(!writes_flags, (file_line, "cgen_alu: and must not write flags"));
679 mc = PARISC_AND;
680 break;
681 case ALU_SUB: ajla_assert_lo(writes_flags, (file_line, "cgen_alu: sub must write flags"));
682 mc = PARISC_SUB;
683 break;
684 case ALU_XOR: ajla_assert_lo(!writes_flags, (file_line, "cgen_alu: xor must not write flags"));
685 mc = PARISC_XOR;
686 break;
687 case ALU_ANDN: ajla_assert_lo(!writes_flags, (file_line, "cgen_alu: andn must not write flags"));
688 mc = PARISC_ANDCM;
689 break;
690 default: goto invalid;
691 }
693 if (alu == ALU_ADD && arg3[0] == ARG_SHIFTED_REGISTER) {
694 uint8_t *args;
695 if (unlikely((arg3[1] >> 6) != 0))
696 goto invalid;
697 if (unlikely((arg3[1] & ARG_SHIFT_AMOUNT)) >= 4)
698 goto invalid;
699 mc |= (uint32_t)(arg3[1] & ARG_SHIFT_AMOUNT) << 6;
700 arg3 += 2;
701 args = arg3;
702 arg3 = arg2;
703 arg2 = args;
704 }
706 if (unlikely(arg3[0] >= 0x20))
707 goto invalid;
709 #ifdef ARCH_PARISC32
710 if (alu == ALU_ADD && size == OP_SIZE_4 && arg1[0] == arg2[0] && trap && length == JMP_SHORTEST) {
711 bool need_nop;
712 mc = PARISC_ADDB;
713 mc |= PARISC_COND_SV;
714 mc |= PARISC_N;
715 g(add_relocation(ctx, JMP_SHORTEST, ctx->code_position - arg1, &need_nop));
716 g(cgen_2reg(ctx, mc, arg1[0], arg3[0]));
717 if (unlikely(need_nop))
718 cgen_four(PARISC_NOP);
719 return true;
720 }
721 #endif
723 if (trap) {
724 if (length == JMP_EXTRA_LONG || (length == JMP_LONG && !PA_20))
725 mc |= PARISC_COND_SV;
726 else
727 mc |= PARISC_COND_NSV;
728 if (size == OP_SIZE_8)
729 mc |= PARISC_COND_64;
730 }
732 g(cgen_3reg(ctx, mc, arg2[0], arg3[0], arg1[0]));
734 if (trap) {
735 if (length <= JMP_SHORT) {
736 g(add_relocation(ctx, JMP_SHORT, ctx->code_position - arg1, NULL));
737 cgen_four(PARISC_BL | PARISC_N);
738 } else if (length == JMP_LONG && PA_20) {
739 g(add_relocation(ctx, JMP_LONG, ctx->code_position - arg1, NULL));
740 cgen_four(PARISC_BL_L | PARISC_N);
741 } else {
742 cgen_four(PARISC_BL | PARISC_N | assemble_12(3));
743 g(add_relocation(ctx, JMP_EXTRA_LONG, ctx->code_position - arg1, NULL));
744 cgen_four(PARISC_LDIL | ((uint32_t)R_CG_SCRATCH << 21));
745 g(cgen_2reg(ctx, PARISC_LDO, R_CG_SCRATCH, R_CG_SCRATCH));
746 g(cgen_2reg(ctx, PARISC_BLR | PARISC_N, R_ZERO, R_CG_SCRATCH));
747 g(cgen_2reg(ctx, PARISC_BLR | PARISC_N, R_ZERO, R_CG_SCRATCH));
748 }
749 }
751 return true;
753 invalid:
754 internal(file_line, "cgen_alu: invalid arguments %02x, %02x, %02x, %u, %u", arg1[0], arg2[0], arg3[0], alu, writes_flags);
755 return false;
756 }
758 static bool attr_w cgen_alu1(struct codegen_context *ctx, unsigned size, unsigned writes_flags, unsigned alu, bool trap, unsigned length)
759 {
760 uint32_t mc;
761 unsigned r1, r2, rt;
762 uint8_t *arg1 = ctx->code_position;
763 uint8_t *arg2 = arg1 + arg_size(*arg1);
764 ctx->code_position = arg2 + arg_size(*arg2);
766 if (unlikely(arg1[0] >= 0x20) || unlikely(arg2[0] >= 0x20))
767 goto invalid;
769 switch (alu) {
770 case ALU1_NOT: ajla_assert_lo(!writes_flags, (file_line, "cgen_alu1: not must not write flags"));
771 mc = PARISC_UADDCM;
772 r1 = R_ZERO;
773 r2 = arg2[0];
774 rt = arg1[0];
775 break;
776 case ALU1_NEG: ajla_assert_lo(writes_flags, (file_line, "cgen_alu1: neg must write flags"));
777 mc = PARISC_SUB;
778 r1 = R_ZERO;
779 r2 = arg2[0];
780 rt = arg1[0];
781 break;
782 case ALU1_INC:
783 case ALU1_DEC: ajla_assert_lo(writes_flags, (file_line, "cgen_alu1: inc/dec must write flags"));
784 if (trap && size == OP_SIZE_8) {
785 mc = PARISC_LDO;
786 mc |= low_sign_ext_14(alu == ALU1_INC ? 1 : -1);
787 g(cgen_2reg(ctx, mc, R_ZERO, R_CG_SCRATCH));
789 mc = PARISC_ADD;
790 r1 = arg2[0];
791 r2 = R_CG_SCRATCH;
792 rt = arg1[0];
793 } else {
794 mc = PARISC_ADDI;
795 mc |= low_sign_ext_11(alu == ALU1_INC ? 1 : -1);
796 r1 = arg1[0];
797 r2 = arg2[0];
798 rt = 0;
799 }
800 break;
801 default: goto invalid;
802 }
804 if (trap) {
805 if (length == JMP_EXTRA_LONG || (length == JMP_LONG && !PA_20))
806 mc |= PARISC_COND_SV;
807 else
808 mc |= PARISC_COND_NSV;
809 if (size == OP_SIZE_8)
810 mc |= PARISC_COND_64;
811 }
813 g(cgen_3reg(ctx, mc, r1, r2, rt));
815 if (trap) {
816 if (length <= JMP_SHORT) {
817 g(add_relocation(ctx, JMP_SHORT, ctx->code_position - arg1, NULL));
818 cgen_four(PARISC_BL | PARISC_N);
819 } else if (length == JMP_LONG && PA_20) {
820 g(add_relocation(ctx, JMP_LONG, ctx->code_position - arg1, NULL));
821 cgen_four(PARISC_BL_L | PARISC_N);
822 } else {
823 cgen_four(PARISC_BL | PARISC_N | assemble_12(3));
824 g(add_relocation(ctx, JMP_EXTRA_LONG, ctx->code_position - arg1, NULL));
825 cgen_four(PARISC_LDIL | ((uint32_t)R_CG_SCRATCH << 21));
826 g(cgen_2reg(ctx, PARISC_LDO, R_CG_SCRATCH, R_CG_SCRATCH));
827 g(cgen_2reg(ctx, PARISC_BLR | PARISC_N, R_ZERO, R_CG_SCRATCH));
828 g(cgen_2reg(ctx, PARISC_BLR | PARISC_N, R_ZERO, R_CG_SCRATCH));
829 }
830 }
832 return true;
834 invalid:
835 internal(file_line, "cgen_alu1: invalid arguments %02x, %02x, %u, %u", arg1[0], arg2[0], alu, writes_flags);
836 return false;
837 }
839 static bool attr_w cgen_sar(struct codegen_context *ctx, bool sar_complement, uint8_t reg)
840 {
841 uint32_t mc;
842 if (!sar_complement) {
843 mc = PARISC_MTSAR;
844 mc |= (uint32_t)reg << 16;
845 cgen_four(mc);
846 } else if (PA_20) {
847 mc = PARISC_MTSARCM;
848 mc |= (uint32_t)reg << 16;
849 cgen_four(mc);
850 } else {
851 mc = PARISC_LDO;
852 mc |= low_sign_ext_14(-1);
853 g(cgen_2reg(ctx, mc, 0, R_CG_SCRATCH));
854 mc = PARISC_XOR;
855 g(cgen_3reg(ctx, mc, R_CG_SCRATCH, reg, R_CG_SCRATCH));
856 mc = PARISC_MTSAR;
857 mc |= (uint32_t)R_CG_SCRATCH << 16;
858 cgen_four(mc);
859 }
860 return true;
861 }
863 static bool attr_w cgen_rot(struct codegen_context *ctx, unsigned size, unsigned rot)
864 {
865 uint32_t mc;
866 uint8_t *arg1 = ctx->code_position;
867 uint8_t *arg2 = arg1 + arg_size(*arg1);
868 uint8_t *arg3 = arg2 + arg_size(*arg2);
869 ctx->code_position = arg3 + arg_size(*arg3);
870 if (arg3[0] == ARG_IMM) {
871 int64_t imm = get_imm(&arg3[1]);
872 unsigned sh = imm & (size == OP_SIZE_4 ? 31 : 63);
873 if (size == OP_SIZE_4) {
874 switch (rot) {
875 case ROT_SHL:
876 mc = PARISC_DEPW_Z;
877 mc |= sh | (sh << 5);
878 break;
879 case ROT_SHR:
880 mc = PARISC_EXTRW_U;
881 mc |= sh | ((31 - sh) << 5);
882 break;
883 case ROT_SAR:
884 mc = PARISC_EXTRW_S;
885 mc |= sh | ((31 - sh) << 5);
886 break;
887 default:
888 goto invalid;
889 }
890 } else {
891 switch (rot) {
892 case ROT_SHL:
893 mc = PARISC_DEPD_Z;
894 mc |= (sh & 31) | ((sh & 31) << 5);
895 if (sh & 32)
896 mc ^= 0x1800;
897 break;
898 case ROT_SHR:
899 mc = PARISC_EXTRD_U;
900 mc |= (sh & 31) | ((31 - (sh & 31)) << 5);
901 if (sh & 32)
902 mc ^= 0x1800;
903 break;
904 case ROT_SAR:
905 mc = PARISC_EXTRD_S;
906 mc |= (sh & 31) | ((31 - (sh & 31)) << 5);
907 if (sh & 32)
908 mc ^= 0x1800;
909 break;
910 default:
911 goto invalid;
912 }
913 }
914 if (rot == ROT_SHL)
915 g(cgen_2reg(ctx, mc, arg1[0], arg2[0]));
916 else
917 g(cgen_2reg(ctx, mc, arg2[0], arg1[0]));
918 return true;
919 } else if (arg3[0] < 0x20) {
920 bool sar_complement = rot != ROT_SHR;
921 g(cgen_sar(ctx, sar_complement, arg3[0]));
922 if (size == OP_SIZE_4) {
923 switch (rot) {
924 case ROT_SHL:
925 mc = PARISC_DEPW_Z_SAR;
926 break;
927 case ROT_SHR:
928 mc = PARISC_SHRPW_SAR;
929 break;
930 case ROT_SAR:
931 mc = PARISC_EXTRW_S_SAR;
932 break;
933 default:
934 goto invalid;
935 }
936 } else {
937 switch (rot) {
938 case ROT_SHL:
939 mc = PARISC_DEPD_Z_SAR | 0x100;
940 break;
941 case ROT_SHR:
942 mc = PARISC_SHRPD_SAR;
943 break;
944 case ROT_SAR:
945 mc = PARISC_EXTRD_S_SAR | 0x100;
946 break;
947 default:
948 goto invalid;
949 }
950 }
951 if (rot == ROT_SHL) {
952 g(cgen_2reg(ctx, mc, arg1[0], arg2[0]));
953 } else if (rot == ROT_SHR) {
954 g(cgen_3reg(ctx, mc, R_ZERO, arg2[0], arg1[0]));
955 } else {
956 g(cgen_2reg(ctx, mc, arg2[0], arg1[0]));
957 }
958 return true;
959 }
961 invalid:
962 internal(file_line, "cgen_rot: invalid arguments %02x, %02x, %02x, %u, %u", arg1[0], arg2[0], arg3[0], size, rot);
963 return false;
964 }
966 static bool attr_w cgen_btx(struct codegen_context *ctx, unsigned size, unsigned aux)
967 {
968 uint32_t mc;
969 uint8_t *arg1 = ctx->code_position;
970 uint8_t *arg2 = arg1 + arg_size(*arg1);
971 uint8_t *arg3 = arg2 + arg_size(*arg2);
972 ctx->code_position = arg3 + arg_size(*arg3);
974 if (aux == BTX_BTS || aux == BTX_BTR) {
975 if (arg1[0] != arg2[0]) {
976 g(cgen_3reg(ctx, PARISC_OR, arg2[0], 0, arg1[0]));
977 }
978 }
980 if (arg3[0] == ARG_IMM) {
981 int64_t imm = get_imm(&arg3[1]);
982 unsigned bit = imm & (size == OP_SIZE_4 ? 31 : 63);
983 if (size == OP_SIZE_4) {
984 switch (aux) {
985 case BTX_BTS:
986 case BTX_BTR:
987 mc = PARISC_DEPWI;
988 mc |= 31U | (bit << 5);
989 g(cgen_2reg(ctx, mc, arg1[0], low_sign_ext_5(aux == BTX_BTS)));
990 return true;
991 case BTX_BTEXT:
992 mc = PARISC_EXTRW_U;
993 mc |= 31U | ((31 - bit) << 5);
994 g(cgen_2reg(ctx, mc, arg2[0], arg1[0]));
995 return true;
996 default:
997 goto invalid;
998 }
999 } else {
1000 switch (aux) {
1001 case BTX_BTS:
1002 case BTX_BTR:
1003 mc = PARISC_DEPDI;
1004 mc |= 31U | ((bit & 0x1f) << 5) | ((bit & 0x20) << 6);
1005 g(cgen_2reg(ctx, mc, arg1[0], low_sign_ext_5(aux == BTX_BTS)));
1006 return true;
1007 case BTX_BTEXT:
1008 mc = PARISC_EXTRD_U;
1009 mc |= 31U | (((63 - bit) & 0x1f) << 5) | (((63 - bit) & 0x20) << 6);
1010 g(cgen_2reg(ctx, mc, arg2[0], arg1[0]));
1011 return true;
1012 default:
1013 goto invalid;
1014 }
1015 }
1016 } else {
1017 g(cgen_sar(ctx, true, arg3[0]));
1018 if (size == OP_SIZE_4) {
1019 switch (aux) {
1020 case BTX_BTS:
1021 case BTX_BTR:
1022 mc = PARISC_DEPWI_SAR;
1023 mc |= 31U;
1024 g(cgen_2reg(ctx, mc, arg1[0], low_sign_ext_5(aux == BTX_BTS)));
1025 return true;
1026 case BTX_BTEXT:
1027 mc = PARISC_EXTRW_U_SAR;
1028 mc |= 31U;
1029 g(cgen_2reg(ctx, mc, arg2[0], arg1[0]));
1030 return true;
1031 default:
1032 goto invalid;
1033 }
1034 } else {
1035 switch (aux) {
1036 case BTX_BTS:
1037 case BTX_BTR:
1038 mc = PARISC_DEPDI_SAR;
1039 mc |= 31U;
1040 g(cgen_2reg(ctx, mc, arg1[0], low_sign_ext_5(aux == BTX_BTS)));
1041 return true;
1042 case BTX_BTEXT:
1043 mc = PARISC_EXTRD_U_SAR;
1044 mc |= 31U;
1045 g(cgen_2reg(ctx, mc, arg2[0], arg1[0]));
1046 return true;
1047 default:
1048 goto invalid;
1049 }
1050 }
1051 }
1053 invalid:
1054 internal(file_line, "cgen_btx: invalid arguments %02x, %02x, %02x, %u, %u", arg1[0], arg2[0], arg3[0], size, aux);
1055 return false;
1056 }
1058 static bool attr_w cgen_cmp_cmov(struct codegen_context *ctx, unsigned op_size, unsigned cond)
1059 {
1060 int32_t fc;
1061 uint32_t mc;
1062 int64_t imm;
1063 uint8_t *arg1 = ctx->code_position;
1064 uint8_t *arg2 = arg1 + arg_size(*arg1);
1065 uint8_t *arg3 = arg2 + arg_size(*arg2);
1066 uint8_t *arg4 = arg3 + arg_size(*arg3);
1067 uint8_t *arg5 = arg4 + arg_size(*arg4);
1068 ctx->code_position = arg5 + arg_size(*arg5);
1070 if (arg3[0] == ARG_IMM) {
1071 cond = cmp_swap_arguments(cond);
1072 }
1074 fc = cmp_sub_cond[cond];
1075 fc ^= PARISC_COND_NEG;
1077 if (arg5[0] == ARG_IMM) {
1078 imm = get_imm(&arg5[1]);
1079 mc = PARISC_CMPICLR;
1080 mc |= fc;
1081 mc |= low_sign_ext_11(imm);
1082 g(cgen_2reg(ctx, mc, arg4[0], R_ZERO));
1083 } else {
1084 mc = PARISC_CMPCLR;
1085 mc |= fc;
1086 g(cgen_3reg(ctx, mc, arg4[0], arg5[0], R_ZERO));
1087 }
1089 g(cgen_mov_args(ctx, op_size, arg1, arg3));
1091 return true;
1092 }
1094 static bool attr_w cgen_movr(struct codegen_context *ctx, unsigned cond)
1095 {
1096 int32_t fc;
1097 uint32_t mc;
1098 uint8_t *arg1 = ctx->code_position;
1099 uint8_t *arg2 = arg1 + arg_size(*arg1);
1100 uint8_t *arg3 = arg2 + arg_size(*arg2);
1101 uint8_t *arg4 = arg3 + arg_size(*arg3);
1102 ctx->code_position = arg4 + arg_size(*arg4);
1104 fc = cmp_sub_cond[cond];
1105 fc ^= PARISC_COND_NEG;
1107 if (unlikely(arg1[0] != arg2[0]) || unlikely(arg1[0] >= 0x20))
1108 internal(file_line, "cgen_movr: invalid arguments");
1110 mc = PARISC_ADD_L;
1111 mc |= fc;
1112 if (OP_SIZE_NATIVE == OP_SIZE_8)
1113 mc |= PARISC_COND_64;
1115 g(cgen_3reg(ctx, mc, R_ZERO, arg3[0], R_ZERO));
1117 g(cgen_mov_args(ctx, OP_SIZE_NATIVE, arg1, arg4));
1119 return true;
1120 }
1122 static bool attr_w cgen_fp_cmp_cond(struct codegen_context *ctx, unsigned op_size, unsigned aux)
1123 {
1124 uint32_t mc;
1125 unsigned cond;
1126 uint8_t *arg1 = ctx->code_position;
1127 uint8_t *arg2 = arg1 + arg_size(*arg1);
1128 ctx->code_position = arg2 + arg_size(*arg2);
1129 switch (aux) {
1130 case FP_COND_P: cond = PARISC_FCMP_P; break;
1131 case FP_COND_NP: cond = PARISC_FCMP_NP; break;
1132 case FP_COND_E: cond = PARISC_FCMP_E; break;
1133 case FP_COND_NE: cond = PARISC_FCMP_NE; break;
1134 case FP_COND_A: cond = PARISC_FCMP_A; break;
1135 case FP_COND_BE: cond = PARISC_FCMP_BE; break;
1136 case FP_COND_B: cond = PARISC_FCMP_B; break;
1137 case FP_COND_AE: cond = PARISC_FCMP_AE; break;
1138 default: internal(file_line, "cgen_fp_cmp_cond: invalid condition %u", aux);
1139 return false;
1140 }
1141 mc = PARISC_FCMP;
1142 if (op_size == OP_SIZE_8)
1143 mc |= PARISC_FP_DOUBLE;
1144 g(cgen_3reg(ctx, mc, arg1[0] & 0x1f, arg2[0] & 0x1f, cond));
1145 return true;
1146 }
1148 static bool attr_w cgen_fp_test_reg(struct codegen_context *ctx)
1149 {
1150 unsigned reg = cget_one(ctx);
1151 uint32_t mc;
1153 mc = PARISC_LDO;
1154 mc |= low_sign_ext_14(1);
1155 g(cgen_2reg(ctx, mc, R_ZERO, reg));
1157 cgen_four(PARISC_FTEST);
1159 mc = PARISC_LDO;
1160 mc |= low_sign_ext_14(0);
1161 g(cgen_2reg(ctx, mc, R_ZERO, reg));
1163 return true;
1164 }
1166 static bool attr_w cgen_fp_alu(struct codegen_context *ctx, unsigned op_size, unsigned aux)
1167 {
1168 uint32_t mc;
1169 uint8_t *arg1 = ctx->code_position;
1170 uint8_t *arg2 = arg1 + arg_size(*arg1);
1171 uint8_t *arg3 = arg2 + arg_size(*arg2);
1172 ctx->code_position = arg3 + arg_size(*arg3);
1173 switch (aux) {
1174 case FP_ALU_ADD: mc = PARISC_FADD; break;
1175 case FP_ALU_SUB: mc = PARISC_FSUB; break;
1176 case FP_ALU_MUL: mc = PARISC_FMPY; break;
1177 case FP_ALU_DIV: mc = PARISC_FDIV; break;
1178 default: internal(file_line, "cgen_fp_alu: invalid alu %u", aux);
1179 }
1180 switch (op_size) {
1181 case OP_SIZE_4: break;
1182 case OP_SIZE_8: mc |= PARISC_FP_DOUBLE; break;
1183 default: internal(file_line, "cgen_fp_alu: invalid size %u", op_size);
1184 }
1185 g(cgen_3reg(ctx, mc, arg3[0] & 0x1f, arg2[0] & 0x1f, arg1[0] & 0x1f));
1186 return true;
1187 }
1189 static bool attr_w cgen_fp_alu1(struct codegen_context *ctx, unsigned op_size, unsigned aux)
1190 {
1191 uint32_t mc;
1192 uint8_t *arg1 = ctx->code_position;
1193 uint8_t *arg2 = arg1 + arg_size(*arg1);
1194 ctx->code_position = arg2 + arg_size(*arg2);
1195 switch (aux) {
1196 case FP_ALU1_NEG: mc = PARISC_FNEG; break;
1197 case FP_ALU1_SQRT: mc = PARISC_FSQRT; break;
1198 default: internal(file_line, "cgen_fp_alu1: invalid alu %u", aux);
1199 }
1200 switch (op_size) {
1201 case OP_SIZE_4: break;
1202 case OP_SIZE_8: mc |= PARISC_FP_DOUBLE; break;
1203 default: internal(file_line, "cgen_fp_alu: invalid size %u", op_size);
1204 }
1205 g(cgen_3reg(ctx, mc, 0, arg2[0] & 0x1f, arg1[0] & 0x1f));
1206 return true;
1207 }
1209 static bool attr_w cgen_fp_to_int(struct codegen_context *ctx, unsigned int_op_size, unsigned fp_op_size)
1210 {
1211 uint32_t mc;
1212 uint8_t *arg1 = ctx->code_position;
1213 uint8_t *arg2 = arg1 + arg_size(*arg1);
1214 ctx->code_position = arg2 + arg_size(*arg2);
1216 mc = PARISC_FCNVFXT;
1217 if (int_op_size == OP_SIZE_8)
1218 mc |= PARISC_FCNVFXT_TO_LONG;
1219 if (fp_op_size == OP_SIZE_8)
1220 mc |= PARISC_FCNVFXT_FROM_DOUBLE;
1221 mc |= arg1[0] & 0x1f;
1222 mc |= (uint32_t)(arg2[0] & 0x1f) << 21;
1223 cgen_four(mc);
1224 return true;
1225 }
1227 static bool attr_w cgen_fp_from_int(struct codegen_context *ctx, unsigned int_op_size, unsigned fp_op_size)
1228 {
1229 uint32_t mc;
1230 uint8_t *arg1 = ctx->code_position;
1231 uint8_t *arg2 = arg1 + arg_size(*arg1);
1232 ctx->code_position = arg2 + arg_size(*arg2);
1234 mc = PARISC_FCNVXF;
1235 if (int_op_size == OP_SIZE_8)
1236 mc |= PARISC_FCNVXF_FROM_LONG;
1237 if (fp_op_size == OP_SIZE_8)
1238 mc |= PARISC_FCNVXF_TO_DOUBLE;
1239 mc |= arg1[0] & 0x1f;
1240 mc |= (uint32_t)(arg2[0] & 0x1f) << 21;
1241 cgen_four(mc);
1242 return true;
1243 }
1245 static bool attr_w cgen_cond_jmp(struct codegen_context *ctx, uint32_t mc, unsigned length, unsigned reg1, unsigned reg2, int reloc_offset)
1246 {
1247 if (length == JMP_SHORTEST) {
1248 bool need_nop;
1249 mc |= PARISC_N;
1250 g(add_relocation(ctx, JMP_SHORTEST, reloc_offset, &need_nop));
1251 g(cgen_2reg(ctx, mc, reg2, reg1));
1252 if (unlikely(need_nop))
1253 cgen_four(PARISC_NOP);
1254 } else if (length == JMP_SHORT) {
1255 mc |= PARISC_N;
1256 g(cgen_2reg(ctx, mc, reg2, reg1));
1257 g(add_relocation(ctx, JMP_SHORT, reloc_offset, NULL));
1258 cgen_four(PARISC_BL | PARISC_N);
1259 } else if (length == JMP_LONG && PA_20) {
1260 mc |= PARISC_N;
1261 g(cgen_2reg(ctx, mc, reg2, reg1));
1262 g(add_relocation(ctx, JMP_LONG, reloc_offset, NULL));
1263 cgen_four(PARISC_BL_L | PARISC_N);
1264 } else {
1265 mc |= PARISC_N;
1266 mc |= assemble_12(3);
1267 g(cgen_2reg(ctx, mc, reg2, reg1));
1268 g(add_relocation(ctx, JMP_EXTRA_LONG, reloc_offset, NULL));
1269 cgen_four(PARISC_LDIL | ((uint32_t)R_CG_SCRATCH << 21));
1270 g(cgen_2reg(ctx, PARISC_LDO, R_CG_SCRATCH, R_CG_SCRATCH));
1271 g(cgen_2reg(ctx, PARISC_BLR | PARISC_N, R_ZERO, R_CG_SCRATCH));
1272 g(cgen_2reg(ctx, PARISC_BLR | PARISC_N, R_ZERO, R_CG_SCRATCH));
1273 }
1274 return true;
1275 }
1277 static bool attr_w cgen_jmp_12regs(struct codegen_context *ctx, unsigned size, unsigned cond, unsigned length, unsigned reg1, unsigned reg2, int reloc_offset)
1278 {
1279 int32_t fc;
1280 uint32_t mc;
1281 fc = cmp_sub_cond[cond];
1282 if (length > JMP_SHORTEST)
1283 fc ^= PARISC_COND_NEG;
1284 if (size == OP_SIZE_4)
1285 mc = !(fc & PARISC_COND_NEG) ? PARISC_CMPB : PARISC_CMPB_NOT;
1286 else
1287 mc = !(fc & PARISC_COND_NEG) ? PARISC_CMPB_64 : PARISC_CMPB_64_NOT;
1288 mc |= ((uint32_t)fc & ~PARISC_COND_NEG);
1289 g(cgen_cond_jmp(ctx, mc, length, reg1, reg2, reloc_offset));
1290 return true;
1291 }
1293 static bool attr_w cgen_jmp(struct codegen_context *ctx, unsigned length)
1294 {
1295 if (length <= JMP_SHORT) {
1296 g(add_relocation(ctx, JMP_SHORT, 0, NULL));
1297 cgen_four(PARISC_BL | PARISC_N);
1298 } else if (length == JMP_LONG && PA_20) {
1299 g(add_relocation(ctx, JMP_LONG, 0, NULL));
1300 cgen_four(PARISC_BL_L | PARISC_N);
1301 } else {
1302 g(add_relocation(ctx, JMP_EXTRA_LONG, 0, NULL));
1303 cgen_four(PARISC_LDIL | ((uint32_t)R_CG_SCRATCH << 21));
1304 g(cgen_2reg(ctx, PARISC_LDO, R_CG_SCRATCH, R_CG_SCRATCH));
1305 g(cgen_2reg(ctx, PARISC_BLR | PARISC_N, R_ZERO, R_CG_SCRATCH));
1306 g(cgen_2reg(ctx, PARISC_BLR | PARISC_N, R_ZERO, R_CG_SCRATCH));
1307 }
1308 return true;
1309 }
1311 static bool attr_w cgen_jmp_reg(struct codegen_context *ctx, unsigned size, unsigned cond, unsigned length)
1312 {
1313 unsigned reg = cget_one(ctx);
1314 return cgen_jmp_12regs(ctx, size, cond, length, reg, 0, 1);
1315 }
1317 static bool attr_w cgen_jmp_reg_bit(struct codegen_context *ctx, unsigned size, unsigned bit, bool jnz, unsigned length)
1318 {
1319 uint32_t mc;
1320 unsigned reg = cget_one(ctx);
1321 if (length > JMP_SHORTEST)
1322 jnz = !jnz;
1323 if (size == OP_SIZE_4 || bit < 32) {
1324 bit = 31 - bit;
1325 mc = jnz ? PARISC_BB_1 : PARISC_BB_0;
1326 } else {
1327 bit = 63 - bit;
1328 mc = jnz ? PARISC_BB_64_1 : PARISC_BB_64_0;
1329 }
1330 g(cgen_cond_jmp(ctx, mc, length, reg, bit, 1));
1331 return true;
1332 }
1334 static bool attr_w cgen_jmp_2regs(struct codegen_context *ctx, unsigned size, unsigned cond, unsigned length)
1335 {
1336 uint8_t *arg1 = ctx->code_position;
1337 uint8_t *arg2 = arg1 + arg_size(*arg1);
1338 ctx->code_position = arg2 + arg_size(*arg2);
1339 if (arg2[0] < 0x20)
1340 return cgen_jmp_12regs(ctx, size, cond, length, arg1[0], arg2[0], 2);
1341 if (arg2[0] == ARG_IMM) {
1342 int64_t imm = get_imm(&arg2[1]);
1343 uint32_t mc;
1344 int32_t fc;
1345 cond = cmp_swap_arguments(cond);
1346 fc = cmp_sub_cond[cond];
1347 if (length > JMP_SHORTEST)
1348 fc ^= PARISC_COND_NEG;
1349 if (size == OP_SIZE_4) {
1350 mc = fc & PARISC_COND_NEG ? PARISC_CMPIB_NOT : PARISC_CMPIB;
1351 mc |= fc & ~PARISC_COND_NEG;
1352 } else {
1353 mc = PARISC_CMPIB_64;
1354 switch (fc) {
1355 case PARISC_COND_EQUAL: mc |= 1 << 13; break;
1356 case PARISC_COND_NOT_EQUAL: mc |= 5 << 13; break;
1357 case PARISC_COND_L_S: mc |= 2 << 13; break;
1358 case PARISC_COND_GE_S: mc |= 6 << 13; break;
1359 case PARISC_COND_LE_S: mc |= 3 << 13; break;
1360 case PARISC_COND_G_S: mc |= 7 << 13; break;
1361 case PARISC_COND_L_U: mc |= 0 << 13; break;
1362 case PARISC_COND_GE_U: mc |= 4 << 13; break;
1363 default: internal(file_line, "cgen_jmp_2regs: unsupported condition %x", fc);
1364 }
1365 }
1366 g(cgen_cond_jmp(ctx, mc, length, low_sign_ext_5(imm), arg1[0], 10));
1367 return true;
1368 }
1369 internal(file_line, "cgen_jmp_2regs: invalid arguments %02x, %02x", arg1[0], arg2[0]);
1370 return false;
1371 }
1373 static bool attr_w cgen_jmp_fp_test(struct codegen_context *ctx, unsigned length)
1374 {
1375 cgen_four(PARISC_FTEST);
1376 if (length <= JMP_SHORT) {
1377 g(add_relocation(ctx, JMP_SHORT, 0, NULL));
1378 cgen_four(PARISC_BL | PARISC_N);
1379 } else if (length == JMP_LONG && PA_20) {
1380 g(add_relocation(ctx, JMP_LONG, 0, NULL));
1381 cgen_four(PARISC_BL_L | PARISC_N);
1382 } else {
1383 cgen_four(PARISC_BL | PARISC_N | assemble_12(0));
1384 cgen_four(PARISC_BL | PARISC_N | assemble_12(3));
1385 g(add_relocation(ctx, JMP_EXTRA_LONG, 0, NULL));
1386 cgen_four(PARISC_LDIL | ((uint32_t)R_CG_SCRATCH << 21));
1387 g(cgen_2reg(ctx, PARISC_LDO, R_CG_SCRATCH, R_CG_SCRATCH));
1388 g(cgen_2reg(ctx, PARISC_BLR | PARISC_N, R_ZERO, R_CG_SCRATCH));
1389 g(cgen_2reg(ctx, PARISC_BLR | PARISC_N, R_ZERO, R_CG_SCRATCH));
1390 }
1391 return true;
1392 }
1394 static bool attr_w cgen_jmp_indirect(struct codegen_context *ctx, unsigned reg)
1395 {
1396 uint32_t mc;
1397 #ifdef ARCH_PARISC32
1398 if (PA_20) {
1399 if (PA_SPACES) {
1400 mc = PARISC_BVE_RET;
1401 mc |= (uint32_t)reg << 21;
1402 cgen_four(mc);
1403 mc = PARISC_STW_LONG;
1404 mc |= low_sign_ext_14(-0x18);
1405 g(cgen_2reg(ctx, mc, R_SP, R_RP));
1406 } else {
1407 mc = PARISC_BVE_RET;
1408 mc |= (uint32_t)reg << 21;
1409 mc |= PARISC_N;
1410 cgen_four(mc);
1411 }
1412 } else {
1413 if (PA_SPACES) {
1414 mc = PARISC_LDSID;
1415 mc |= (uint32_t)reg << 21;
1416 mc |= R_CG_SCRATCH;
1417 cgen_four(mc);
1418 mc = PARISC_MTSP;
1419 mc |= (uint32_t)R_CG_SCRATCH << 16;
1420 cgen_four(mc);
1421 mc = PARISC_BE;
1422 mc |= (uint32_t)reg << 21;
1423 cgen_four(mc);
1424 mc = PARISC_STW_LONG;
1425 mc |= low_sign_ext_14(-0x18);
1426 g(cgen_2reg(ctx, mc, R_SP, R_RP));
1427 } else {
1428 mc = PARISC_BV;
1429 mc |= (uint32_t)reg << 21;
1430 mc |= PARISC_N;
1431 cgen_four(mc);
1432 }
1433 }
1434 #else
1435 mc = PARISC_BV;
1436 mc |= (uint32_t)reg << 21;
1437 mc |= PARISC_N;
1438 cgen_four(mc);
1439 #endif
1440 if (unlikely(!ctx->fn))
1441 cgen_four(PARISC_NOP);
1442 return true;
1443 }
1445 static bool attr_w cgen_call_millicode(struct codegen_context attr_unused *ctx)
1446 {
1447 #ifdef ARCH_PARISC32
1448 uint32_t mc;
1449 unsigned reg = R_SCRATCH_NA_1;
1450 unsigned bit;
1452 mc = PARISC_BB_0;
1453 bit = 31 - 1;
1454 mc |= assemble_12(1);
1455 mc |= PARISC_N;
1456 g(cgen_2reg(ctx, mc, bit, reg));
1458 mc = PARISC_LD_ST;
1459 mc |= PARISC_LD_ST_W;
1460 mc |= PARISC_LD_ST_IMM;
1461 mc |= PARISC_LD_ST_LD;
1462 g(cgen_3reg(ctx, mc, low_sign_ext_5(2), reg, R_19));
1463 g(cgen_3reg(ctx, mc, low_sign_ext_5(-2), reg, reg));
1465 g(cgen_jmp_indirect(ctx, reg));
1466 #endif
1467 return true;
1468 }
1470 static bool attr_w resolve_relocation(struct codegen_context *ctx, struct relocation *reloc)
1471 {
1472 uint32_t mc;
1473 uint32_t mc4[4];
1474 int64_t offs = (int64_t)(ctx->label_to_pos[reloc->label_id] >> 2) - (int64_t)(reloc->position >> 2) - 2;
1475 switch (reloc->length) {
1476 case JMP_SHORTEST:
1477 if (unlikely(offs < -0x800) || unlikely(offs >= 0x800))
1478 return false;
1479 memcpy(&mc, ctx->mcode + reloc->position, 4);
1480 mc &= ~0x00001ffdU;
1481 mc |= assemble_12(offs);
1482 memcpy(ctx->mcode + reloc->position, &mc, 4);
1483 return true;
1484 case JMP_SHORT:
1485 if (unlikely(offs < -0x10000) || unlikely(offs >= 0x10000))
1486 return false;
1487 memcpy(&mc, ctx->mcode + reloc->position, 4);
1488 mc &= ~0x001f1ffdU;
1489 mc |= assemble_17(offs);
1490 memcpy(ctx->mcode + reloc->position, &mc, 4);
1491 return true;
1492 case JMP_LONG:
1493 if (unlikely(offs < -0x200000) || unlikely(offs >= 0x200000))
1494 return false;
1495 memcpy(&mc, ctx->mcode + reloc->position, 4);
1496 mc &= ~0x03ff1ffdU;
1497 mc |= assemble_22(offs);
1498 memcpy(ctx->mcode + reloc->position, &mc, 4);
1499 return true;
1500 case JMP_EXTRA_LONG:
1501 offs -= 2;
1502 if (unlikely(offs != (int32_t)offs))
1503 return false;
1504 memcpy(&mc4, ctx->mcode + reloc->position, 16);
1505 mc4[0] &= ~0x001fffffU;
1506 mc4[0] |= assemble_21((uint64_t)offs >> 1 >> 11);
1507 mc4[1] &= ~0x00003fffU;
1508 mc4[1] |= low_sign_ext_14(((uint64_t)offs >> 1) & 0x7ff);
1509 if (offs & 1)
1510 mc4[2] = PARISC_NOP;
1511 else
1512 mc4[3] = PARISC_NOP;
1513 memcpy(ctx->mcode + reloc->position, &mc4, 16);
1514 return true;
1515 default:
1516 internal(file_line, "resolve_relocation: invalid relocation length %u", reloc->length);
1517 }
1518 return false;
1519 }
1521 static bool attr_w cgen_insn(struct codegen_context *ctx, uint32_t insn)
1522 {
1523 /*debug("insn: %08x", insn);*/
1524 switch (insn_opcode(insn)) {
1525 case INSN_ENTRY:
1526 g(cgen_entry(ctx));
1527 return true;
1528 case INSN_LABEL:
1529 g(cgen_label(ctx));
1530 return true;
1531 case INSN_RET:
1532 g(cgen_ret(ctx));
1533 return true;
1534 case INSN_CALL:
1535 g(cgen_call(ctx, insn_jump_size(insn)));
1536 return true;
1537 case INSN_CALL_INDIRECT:
1538 g(cgen_call_indirect(ctx));
1539 return true;
1540 case INSN_MOV:
1541 g(cgen_mov(ctx, insn_op_size(insn)));
1542 return true;
1543 case INSN_MOVSX:
1544 g(cgen_movsx(ctx, insn_op_size(insn)));
1545 return true;
1546 case INSN_CMP_DEST_REG:
1547 if (unlikely(insn_op_size(insn) < OP_SIZE_4))
1548 goto invalid_insn;
1549 g(cgen_cmp_dest_reg(ctx, insn_op_size(insn), insn_aux(insn)));
1550 return true;
1551 case INSN_ALU:
1552 case INSN_ALU_FLAGS:
1553 if (unlikely(insn_op_size(insn) < OP_SIZE_4))
1554 goto invalid_insn;
1555 g(cgen_alu(ctx, insn_op_size(insn), insn_writes_flags(insn), insn_aux(insn), false, insn_jump_size(insn)));
1556 return true;
1557 case INSN_ALU_TRAP:
1558 case INSN_ALU_FLAGS_TRAP:
1559 if (unlikely(insn_op_size(insn) < OP_SIZE_4))
1560 goto invalid_insn;
1561 g(cgen_alu(ctx, insn_op_size(insn), insn_writes_flags(insn), insn_aux(insn), true, insn_jump_size(insn)));
1562 return true;
1563 case INSN_ALU1:
1564 if (unlikely(insn_op_size(insn) < OP_SIZE_4))
1565 goto invalid_insn;
1566 g(cgen_alu1(ctx, insn_op_size(insn), insn_writes_flags(insn), insn_aux(insn), false, insn_jump_size(insn)));
1567 return true;
1568 case INSN_ALU1_TRAP:
1569 if (unlikely(insn_op_size(insn) < OP_SIZE_4))
1570 goto invalid_insn;
1571 g(cgen_alu1(ctx, insn_op_size(insn), insn_writes_flags(insn), insn_aux(insn), true, insn_jump_size(insn)));
1572 return true;
1573 case INSN_ROT:
1574 if (unlikely(insn_op_size(insn) < OP_SIZE_4) || unlikely(insn_writes_flags(insn) != 0))
1575 goto invalid_insn;
1576 g(cgen_rot(ctx, insn_op_size(insn), insn_aux(insn)));
1577 return true;
1578 case INSN_BTX:
1579 if (unlikely(insn_op_size(insn) < OP_SIZE_4))
1580 goto invalid_insn;
1581 g(cgen_btx(ctx, insn_op_size(insn), insn_aux(insn)));
1582 return true;
1583 case INSN_CMP_CMOV:
1584 if (unlikely(insn_writes_flags(insn) != 0))
1585 goto invalid_insn;
1586 g(cgen_cmp_cmov(ctx, insn_op_size(insn), insn_aux(insn)));
1587 return true;
1588 case INSN_MOVR:
1589 if (unlikely(insn_op_size(insn) != OP_SIZE_NATIVE) || unlikely(insn_writes_flags(insn) != 0))
1590 goto invalid_insn;
1591 g(cgen_movr(ctx, insn_aux(insn)));
1592 return true;
1593 case INSN_FP_CMP_COND:
1594 g(cgen_fp_cmp_cond(ctx, insn_op_size(insn), insn_aux(insn)));
1595 return true;
1596 case INSN_FP_TEST_REG:
1597 g(cgen_fp_test_reg(ctx));
1598 return true;
1599 case INSN_FP_ALU:
1600 g(cgen_fp_alu(ctx, insn_op_size(insn), insn_aux(insn)));
1601 return true;
1602 case INSN_FP_ALU1:
1603 g(cgen_fp_alu1(ctx, insn_op_size(insn), insn_aux(insn)));
1604 return true;
1605 case INSN_FP_TO_INT32:
1606 case INSN_FP_TO_INT64:
1607 g(cgen_fp_to_int(ctx, insn_opcode(insn) == INSN_FP_TO_INT32 ? OP_SIZE_4 : OP_SIZE_8, insn_op_size(insn)));
1608 return true;
1609 case INSN_FP_FROM_INT32:
1610 case INSN_FP_FROM_INT64:
1611 g(cgen_fp_from_int(ctx, insn_opcode(insn) == INSN_FP_FROM_INT32 ? OP_SIZE_4 : OP_SIZE_8, insn_op_size(insn)));
1612 return true;
1613 case INSN_JMP:
1614 g(cgen_jmp(ctx, insn_jump_size(insn)));
1615 return true;
1616 case INSN_JMP_REG:
1617 if (unlikely(insn_op_size(insn) < OP_SIZE_4))
1618 goto invalid_insn;
1619 g(cgen_jmp_reg(ctx, insn_op_size(insn), insn_aux(insn), insn_jump_size(insn)));
1620 return true;
1621 case INSN_JMP_REG_BIT:
1622 if (unlikely(insn_op_size(insn) < OP_SIZE_4))
1623 goto invalid_insn;
1624 g(cgen_jmp_reg_bit(ctx, insn_op_size(insn), insn_aux(insn) & 63, insn_aux(insn) >> 6, insn_jump_size(insn)));
1625 return true;
1626 case INSN_JMP_2REGS:
1627 if (unlikely(insn_op_size(insn) < OP_SIZE_4))
1628 goto invalid_insn;
1629 g(cgen_jmp_2regs(ctx, insn_op_size(insn), insn_aux(insn), insn_jump_size(insn)));
1630 return true;
1631 case INSN_JMP_FP_TEST:
1632 g(cgen_jmp_fp_test(ctx, insn_jump_size(insn)));
1633 return true;
1634 case INSN_JMP_INDIRECT:
1635 g(cgen_jmp_indirect(ctx, cget_one(ctx)));
1636 return true;
1637 case INSN_CALL_MILLICODE:
1638 g(cgen_call_millicode(ctx));
1639 return true;
1640 default:
1641 invalid_insn:
1642 internal(file_line, "cgen_insn: invalid insn %08x", insn);
1643 return false;
1644 }
1645 }