1 /* src/vm/jit/s390/codegen.h - code generation macros for s390
3 Copyright (C) 1996-2005, 2006, 2007, 2008, 2010
4 CACAOVM - Verein zur Foerderung der freien virtuellen Maschine CACAO
6 This file is part of CACAO.
8 This program is free software; you can redistribute it and/or
9 modify it under the terms of the GNU General Public License as
10 published by the Free Software Foundation; either version 2, or (at
11 your option) any later version.
13 This program is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
35 #include "vm/jit/jit.hpp"
38 /* MCODECHECK(icnt) */
40 #define MCODECHECK(icnt) \
42 if ((cd->mcodeptr + (icnt)) > cd->mcodeend) \
43 codegen_increase(cd); \
46 #define ALIGNCODENOP \
48 while (((ptrint) cd->mcodeptr) & 2) { \
51 while (((ptrint) cd->mcodeptr) & 4) { \
56 /* some patcher defines *******************************************************/
58 #define PATCHER_CALL_SIZE 2 /* size in bytes of a patcher call */
59 #define PATCHER_NOPS M_NOP3
61 /* branch defines ************************************************************/
65 if (CODEGENDATA_HAS_FLAG_LONGBRANCHES(cd)) { \
66 M_NOP2; M_NOP2; /* brc */ \
67 M_NOP2; M_NOP2; M_NOP2; M_NOP2; M_NOP2; M_NOP2; M_NOP2; M_NOP2; /* ild */ \
68 M_NOP2; /* ar, bcr */ \
76 * Make all this inline functions !!!!!!!!!!
79 /* macros to create code ******************************************************/
82 * N_foo: defines the instrucition foo as in `ESA/390 Principles of operations'
83 * SZ_foo: defines the size of the instruction N_foo
84 * DD_foo: defines a condition code as used by s390 GCC
85 * M_foo: defines the alpha like instruction used in cacao
86 * the instruction is defined by an equivalent N_ instruction
87 * CC_foo: defines a condition code as used
88 * the instruction is defined as an equivalent DD_ condition code
91 /* S390 specific code */
93 /* Argument checks for debug mode */
95 /* Some instructions with register arguments treat %r0 as "value not given".
96 * To prevent bugs, in debug mode we use a special value RN (reg none) with
97 * the meaning "value not given".
98 * In debug mode, the instructions assert that %r0 was not given as argument.
108 static inline int _OR_IMPL(const char *file, int line, int r) {
110 ((0 < r) && (r < 16)) ||
113 fprintf(stdout, "%d is not a valid register at %s:%d.\n", r, file, line);
116 return ((r == RN) ? 0 : r);
118 # define _OR(r) _OR_IMPL(__FILE__, __LINE__, r)
120 # define _SMIN(b) (-(1 << (bits - 1)))
121 # define _SMAX(b) ((1 << (b - 1)) - 1)
123 # define _UMAX(b) ((1 << b) - 1)
125 static inline int _UBITS_IMPL(const char *file, int line, int i, int bits) {
126 if (!((_UMIN(bits) <= i) && (i <= _UMAX(bits)))) {
127 fprintf(stdout, "%d (0x%X) is not an unsigned %d bit integer at %s:%d.\n", i, i, bits, file, line);
133 # define _UBITS(i, bits) _UBITS_IMPL(__FILE__, __LINE__, i, bits)
135 static inline int _SBITS_IMPL(const char *file, int line, int i, int bits) {
136 if(!((_SMIN(bits) <= i) && (i <= _SMAX(bits)))) {
137 fprintf(stdout, "%d (0x%X) is not an signed %d bit integer at %s:%d.\n", i, i, bits, file, line);
143 # define _SBITS(i, bits) _SBITS_IMPL(__FILE__, __LINE__, i, bits)
145 static inline int _BITS_IMPL(const char *file, int line, int i, int bits) {
147 ((_UMIN(bits) <= i) && (i <= _UMAX(bits))) ||
148 ((_SMIN(bits) <= i) && (i <= _SMAX(bits)))
150 fprintf(stdout, "%d (0x%X) is not an %d bit integer at %s:%d.\n", i, i, bits, file, line);
156 # define _BITS(i, bits) _BITS_IMPL(__FILE__, __LINE__, i, bits)
161 # define _BITS(x, b) (x)
162 # define _UBITS(x, b) (x)
163 # define _SBITS(x, b) (x)
167 #define _R(x) _UBITS((x), 4)
169 #define _D(x) _UBITS((x), 12)
170 /* 4 bit Immediate */
171 #define _I4(x) _BITS((x), 4)
172 #define _UI4(x) _UBITS((x), 4)
173 #define _SI4(x) _SBITS((x), 4)
174 /* 8 bit Immediate */
175 #define _I8(x) _BITS((x), 8)
176 #define _UI8(x) _UBITS((x), 8)
177 #define _SI8(x) _SBITS((x), 8)
178 /* 12 bit Immediate */
179 #define _I12(x) _BITS((x), 12)
180 #define _UI12(x) _UBITS((x), 12)
181 #define _SI12(x) _SBITS((x), 12)
182 /* 16 bit Immediate */
183 #define _I16(x) _BITS((x), 16)
184 #define _UI16(x) _UBITS((x), 16)
185 #define _SI16(x) _SBITS((x), 16)
187 #define _OP(x) _UBITS((x), 8)
188 /* Second part of opcode */
189 #define _OP4(x) _UBITS((x), 4)
190 /* Extended opcode */
191 #define _OP16(x) _UBITS((x), 16)
193 /* Instruction formats */
195 #define _CODE(t, code) \
197 *((t *) cd->mcodeptr) = (code); \
198 cd->mcodeptr += sizeof(t); \
201 #define _CODE2(code) _CODE(u2, code)
202 #define _CODE4(code) _CODE(u4, code)
204 #define _IF(cond, t, f) \
205 do { if (cond) { t ; } else { f ; } } while (0)
207 #define _IFNEG(val, neg, pos) _IF((val) < 0, neg, pos)
209 #define N_RR(op, r1, r2) \
210 _CODE2( (_OP(op) << 8) | (_R(r1) << 4) | _R(r2) )
214 static inline uint8_t N_RR_GET_OPC(uint8_t *instrp) {
218 static inline uint8_t N_RR_GET_REG1(uint8_t *instrp) {
219 return (instrp[1] >> 4) & 0xF;
222 static inline uint8_t N_RR_GET_REG2(uint8_t *instrp) {
223 return (instrp[1] & 0xF);
226 #define N_RR2(op, i) \
227 _CODE2( (_OP(op) << 8) | _I8(i) )
229 #define N_RX(op, r1, d2, x2, b2) \
230 _CODE4( (_OP(op) << 24) | (_R(r1) << 20) | (_OR(x2) << 16) | (_OR(b2) << 12) | (_D(d2) << 0) )
234 static inline uint8_t N_RX_GET_OPC(uint8_t *instrp) {
238 static inline uint8_t N_RX_GET_REG(uint8_t *instrp) {
239 return (instrp[1] >> 4) & 0xF;
242 static inline uint8_t N_RX_GET_INDEX(uint8_t *instrp) {
243 return (instrp[1] & 0xF);
246 static inline uint8_t N_RX_GET_BASE(uint8_t *instrp) {
247 return (instrp[2] >> 4) & 0xF;
250 static inline uint16_t N_RX_GET_DISP(uint8_t *instrp) {
251 return *(uint16_t *)(instrp + 2) & 0xFFF;
254 static inline void N_RX_SET_DISP(uint8_t *instrp, uint16_t disp) {
255 *(uint16_t *)(instrp + 2) |= (disp & 0xFFF);
258 #define N_RI(op1, op2, r1, i2) \
259 _CODE4( (_OP(op1) << 24) | (_R(r1) << 20) | (_OP4(op2) << 16) | (u2)_SI16(i2) )
261 static inline int16_t N_RI_GET_IMM(uint8_t *instrp) {
262 return *(int16_t *)(instrp + 2);
265 static inline void N_RI_SET_IMM(uint8_t *instrp, int16_t imm) {
266 *(int16_t *)(instrp + 2) = imm;
269 #define N_RI2(op1, op2, r1, i2) \
270 _CODE4( (_OP(op1) << 24) | (_R(r1) << 20) | (_OP4(op2) << 16) | (u2)_UI16(i2) )
274 #define N_SI(op, d1, b1, i2) \
275 _CODE4( (_OP(op) << 24) | (_OR(i2) << 16) | (_OR(b1) << 12) | _D(d1) )
279 #define N_SS(op, d1, l, b1, d2, b2) \
281 _CODE4( (_OP(op) << 24) | (_I8(l) << 16) | (_OR(b1) << 12) | _D(d1) ); \
282 _CODE2( (_OR(b2) << 12) | _D(d2) ); \
287 #define N_SS2(op, d1, l1, b1, d2, l2, b2) \
288 N_SS(op, d1, (_I4(l1) << 4) | _I4(l2), b1, d2, l2)
290 #define N_RS(op, r1, r3, d2, b2) \
291 _CODE4( (_OP(op) << 24) | (_R(r1) << 20) | (_R(r3) << 16) | (_OR(b2) << 12) | _D(d2) )
295 #define N_RSI(op, r1, r2, i2) \
296 _CODE4( ((op) << 24) | (_R(r1) << 20) | (_R(r3) << 16) | (u2)_16(i2) )
300 #define N_RRE(op, r1, r2) \
301 _CODE4( (_OP16(op) << 16) | (_R(r1) << 4) | _R(r2) )
305 #define N_S2(d2, b2) \
306 _CODE4( (_OP16(op) << 16) | (_OR(b2) << 12) | _D(d2) )
315 #define N_RXE(op, r1, d2, x2, b2) \
317 _CODE4( ((_OP16(op) >> 8) << 24) | (_R(r1) << 20) | \
318 (_R(x2) << 16) | (_R(b2) << 12) | _UI12(d2) ); \
319 _CODE2( _OP16(op) & 0xFF ); \
324 #define N_RRF(op, r1, m3, r2) \
325 _CODE4( (_OP16(op) << 16) | (_R(m3) << 12) | (_R(r1) << 4) | _R(r2) )
329 #define N_IMM_MIN -32768
330 #define N_IMM_MAX 32767
331 #define N_VALID_IMM(x) ((N_IMM_MIN <= (x)) && ((x) <= N_IMM_MAX))
332 #define ASSERT_VALID_IMM(x) assert(N_VALID_IMM(x))
335 #define N_DISP_MAX 0xFFF
336 #define N_VALID_DISP(x) ((N_DISP_MIN <= (x)) && ((x) <= N_DISP_MAX))
337 #define ASSERT_VALID_DISP(x) assert(N_VALID_DISP(x))
339 #define N_PV_OFFSET (-0xFFC)
340 #define N_DSEG_DISP(x) ((x) - N_PV_OFFSET)
341 #define N_VALID_DSEG_DISP(x) N_VALID_DISP(N_DSEG_DISP(x))
343 #define N_BRANCH_MIN (-32768 * 2)
344 #define N_BRANCH_MAX (32767 * 2)
345 #define N_VALID_BRANCH(x) ((N_BRANCH_MIN <= (x)) && ((x) <= N_BRANCH_MAX))
346 #define ASSERT_VALID_BRANCH(x) assert(N_VALID_BRANCH(x))
348 #define N_IS_EVEN_ODD(x) \
349 (((GET_HIGH_REG(x) % 2) == 0) && (GET_LOW_REG(x) == (GET_HIGH_REG(x) + 1)))
351 /* Condition codes */
377 * If most significant bits of first opcode byte are 00, then
378 * format is RR (1 byte opcode) or E (2 bytes opcode).
379 * There seems to be no opcode 0x02 or 0x02**, so we'll define
380 * our trap instruction as:
381 * +--------+--------+
383 * +--------+--------+
386 #define N_ILL(data) _CODE2(0x0200 | _UBITS(data, 8))
387 # define OPC_ILL 0x02
390 static inline uint8_t N_ILL_GET_REG(uint8_t *instrp) {
391 return (instrp[1] >> 4) & 0xF;
394 static inline uint8_t N_ILL_GET_TYPE(uint8_t *instrp) {
395 return (instrp[1] & 0xF);
398 #define N_LONG(l) _CODE4(l)
401 /* Chapter 7. General instructions */
403 #define N_AR(r1, r2) N_RR(0x1A, r1, r2)
404 #define N_A(r1, d2, x2, b2) N_RX(0x5A, r1, d2, x2, b2)
405 #define N_AH(r1, d2, x2, b2) N_RX(0x4A, r1, d2, x2, b2)
406 #define N_AHI(r1, i2) N_RI(0xA7, 0xA, r1, i2)
407 # define SZ_AHI SZ_RI
408 #define N_ALR(r1, r2) N_RR(0x1E, r1, r2)
409 #define N_AL(r1, d2, x2, b2) N_RX(0x5E, r1, d2, x2, b2)
410 #define N_NR(r1, r2) N_RR(0x14, r1, r2)
412 #define N_N(r1, d2, x2, b2) N_RX(0x54, r1, d2, x2, b2)
413 #define N_NI(d1, b1, i2) N_SI(0x94, d1, b1, i2)
414 #define N_NC(d1, l, b1, d2, b2) N_SS(0xD4, (l - 1), b1, d1, b2, d2)
415 #define N_BALR(r1, r2) N_RR(0x05, r1, _OR(r2))
416 #define N_BAL(r1, d2, x2, b2) N_RX(0x45, r1, d2, x2, b2)
417 #define N_BASR(r1, r2) N_RR(0x0D, r1, _OR(r2))
418 # define SZ_BASR SZ_RR
419 #define N_BAS(r1, d2, x2, b2) N_RX(0x4D, r1, d2, x2, b2)
420 #define N_BASSM(r1, r2) N_RR(0x0C, r1, _OR(r2))
421 #define N_BSM(r1, r2) N_RR(0x0B, r1, _OR(r2))
422 #define N_BCR(m1, r2) N_RR(0x07, m1, _OR(r2))
423 # define SZ_BCR SZ_RR
424 # define N_BR(r2) N_BCR(DD_ANY, r2)
425 #define N_BC(m1, d2, x2, b2) N_RX(0x47, m1, d2, x2, b2)
427 #define N_BCTR(r1, r2) N_RR(0x06, r1, _OR(r2))
428 #define N_BCT(r1, d2, x2, b2) N_RX(0x46, r1, d2, x2, b2)
429 #define N_BHX(r1, r2, d2, b2) N_RS(0xB6, r1, r3, d2, b2)
430 #define N_BXLE(r1, r3, d2, b2) N_RS(0xB7, r1, r3, d2, b2)
431 #define N_BRAS(r1, i2) N_RI(0xA7, 0x5, r1, (i2) / 2)
432 # define SZ_BRAS SZ_RI
433 #define N_BRC(m1, i2) N_RI(0xA7, 0x4, m1, (i2) / 2)
434 # define N_J(i2) N_BRC(DD_ANY, i2)
435 # define SZ_BRC SZ_RI
437 # define N_BRC_BACK_PATCH(brc_pos) \
439 *(u4 *)(brc_pos) |= (u4)(cd->mcodeptr - (brc_pos)) / 2; \
441 #define N_BRCT(r1, i2) N_RI(0xA7, 0x6, r1, (i2) / 2)
442 #define N_BRXH(r1, r3, i2) N_RSI(0x84, r1, r3, (i2) / 2)
443 #define N_BRXLE(r1, r3, i2) N_RSI(0x85, r1, r2, (i2) / 2)
444 #define N_CKSM(r1, r2) N_RRE(0xB241, r1, r2)
445 #define N_CR(r1, r2) N_RR(0x19, r1, r2)
447 #define N_C(r1, d2, x2, b2) N_RX(0x59, r1, d2, x2, b2)
448 #define N_CFC(d2, b2) N_S2(0xB21A, d2, b2)
449 #define N_CS(r1, r3, d2, b2) N_RS(0xBA, r1, r3, d2, b2)
450 #define N_CDS(r1, r3, d2, b2) N_RS(0xBB, r1, r3, d2, b2)
451 #define N_CH(r1, d2, x2, b2) N_CH(0x49, r1, d2, x2, b2)
452 #define N_CHI(r1, i2) N_RI(0xA7, 0xE, r1, i2)
453 #define N_CLR(r1, r2) N_RR(0x15, r1, r2)
454 #define N_CL(r1, d2, x2, b2) N_RX(0x55, r1, d2, x2, b2)
456 #define N_CLI(d1, b1, i2) N_SI(0x95, d1, b1, i2)
457 #define N_CLC(d1, l, b1, d2, b2) N_SS(0xD5, d1, (l - 1), b1, d2, b2)
458 #define N_CLM(r1, m3, d2, b2) N_RS(0xBD, r1, m3, d2, b2)
459 #define N_CLCL(r1, r2) N_RR(0x0F, r1, r2)
460 #define N_CLCLE(r1, r3, d2, b2) N_RS(0xA9, r1, r3, d2, b2)
461 #define N_CLST(r1, r2) N_RRE(0xB25D, r1, r2)
462 #define N_CUSE(r1, r2) N_RRE(0xB257, r1, r2)
463 #define N_CVB(r1, d2, x2, b2) N_RX(0x4F, r1, r2, x2, b2)
464 #define N_CVD(r1, d2, x2, b2) N_RX(0x4E, r1, d2, x2, b2)
465 #define N_CUUTF(r1, r2) N_RRE(0xB2A6, r1, r2)
466 #define N_CUTFU(r1, r2) N_RRE(0xB2A7, r1, r2)
467 #define N_CPYA(r1, r2) N_RRE(0xB240, r1, r2)
468 #define N_DR(r1, r2) N_RR(0x1D, r1, r2)
470 #define N_D(r1, d2, x2, b2) N_RX(0x5D, r1, d2, x2, b2)
471 #define N_XR(r1, r2) N_RR(0x17, r1, r2)
472 #define N_X(r1, d2, x2, b2) N_RX(0x57, r1, d2, x2, b2)
473 #define N_XI(d1, b1, i2) N_SI(0x97, d1, b1, i2)
474 #define N_XC(d1, l, b1, d2, b2) N_SS(0xD7, d1, (l - 1), b1, d2, b2)
475 #define N_EX(r1, d2, x2, b2) N_RX(0x44, r1, d2, x2, b2)
476 #define N_EAR(r1, r2) N_RRE(0xB24F, r1, r2)
477 #define N_IC(r1, d2, x2, b2) N_RX(0x43, r1, d2, x2, b2)
478 #define N_ICM(r1, m3, d2, b2) N_RS(0xBF, r1, m3, d2, b2)
479 #define N_IPM(r1) N_RRE(0xB222, r1, 0)
480 #define N_LR(r1, r2) N_RR(0x18, r1, r2)
481 #define N_L(r1, d2, x2, b2) N_RX(0x58, r1, d2, x2, b2)
484 #define N_LAM(r1, r3, d2, b2) N_RS(0x9A, r1, r3, d2, b2)
485 #define N_LA(r1, d2, x2, b2) N_RX(0x41, r1, d2, x2, b2)
486 #define N_LAE(r1, d2, x2, b2) N_RX(0x51, r1, d2, x2, b2)
487 #define N_LTR(r1, r2) N_RR(0x12, r1, r2)
488 #define N_LCR(r1, r2) N_RR(0x13, r1, r2)
489 # define SZ_LCR SZ_RR
490 #define N_LH(r1, d2, x2, b2) N_RX(0x48, r1, d2, x2, b2)
491 #define N_LHI(r1, i2) N_RI(0xA7, 0x8, r1, i2)
492 # define SZ_LHI SZ_RI
493 #define N_LM(r1, r3, d2, b2) N_RS(0x98, r1, r3, d2, b2)
494 #define N_LNR(r1, r2) N_RR(0x11, r1, r2)
495 #define N_LPR(r1, r2) N_RR(0x10, r1, r2)
496 #define N_MC(d1, b1, i2) N_SI(0xAF, d1, b1, i2)
497 #define N_MVI(d1, b1, i2) N_SI(0x92, d1, b1, i2)
498 #define N_MVC(d1, l, b1, d2, b2) N_SS(0xD2, d1, (l - 1), b1, d2, b2)
499 #define N_MVCIN(d1, l, b1, d2, b2) N_SS(0xEB, d1, (l - 1), b1, d2, b2)
500 #define N_MVCL(r1, r2) N_RR(0x0E, r1, r2)
501 #define N_MVCLE(r1, r3, d2, b2) N_RS(0xAB, r1, r3, d2, b2)
502 #define N_MVN(d1, l, b1, d2, b2) N_SS(0xD1, d1, (l - 1), b1, d2, b2)
503 #define N_MVPG(r1, r2) N_RRE(0xB254, r1, r2)
504 #define N_MVST(r1, r2) N_RRE(0xB255, r1, r2)
505 #define N_MVO(d1, l1, b1, d2, l2, b2) N_SS2(0xF1, d1, (l1 - 1), b1, d2, (l2 - 1), b2)
506 #define N_MVZ(d1, l, b1, d2, b2) N_SS(0xD3, d1, (l - 1), b1, d2, b2)
507 #define N_MR(r1, r2) N_RR(0x1C, r1, r2)
508 #define N_M(r1, d2, x2, b2) N_RX(0x5C, r1, d2, x2, b2)
509 #define N_MH(r1, d2, x2, b2) N_RX(0x4C, r1, d2, x2, b2)
510 #define N_MHI(r1, i2) N_RI(0xA7, 0xC, r1, i2)
511 #define N_MSR(r1, r2) N_RRE(0xB252, r1, r2)
512 #define N_MS(r1, d2, x2, b2) N_RX(0x71, r1, d2, x2, b2)
513 #define N_OR(r1, r2) N_RR(0x16, r1, r2)
514 #define N_O(r1, d2, x2, b2) N_RX(0x56, r1, d2, x2, b2)
515 #define N_OI(d1, b1, i2) N_SI(0x96, d1, b1, i2)
516 #define N_OC(d1, l, b1, d2, b2) N_SS(0xD6, d1, (l - 1), b1, d2, b2)
517 #define N_PACK(d1, l1, b1, d2, l2, b2) N_SS2(0xF2, d1, (l1 - 1), b1, d2, (l2 - 1), b2)
518 #define N_PLO(r1, d2, b2, r3, d4, b4) N_SS2(0xEE, d2, r1, b2, d4, r3, b4)
519 #define N_SRST(r1, r2) N_RRE(0xB25E, r1, r2)
520 #define N_SAR(r1, r2) N_RRE(0xB24E, r1, r2)
521 #define N_SPM(r1) N_RR(0x04, r1, 0x00)
522 #define N_SLDA(r1, d2, b2) N_RS(0x8F, r1, 0x00, d2, b2)
523 #define N_SLDL(r1, d2, b2) N_RS(0x8D, r1, 0x00, d2, b2)
524 #define N_SLA(r1, d2, b2) N_RS(0x8B, r1, 0x00, d2, b2)
525 #define N_SLL(r1, d2, b2) N_RS(0x89, r1, 0x00, d2, b2)
526 #define N_SRDA(r1, d2, b2) N_RS(0x8E, r1, 0x00, d2, b2)
527 #define N_SRDL(r1, d2, b2) N_RS(0x8C, r1, 0x00, d2, b2)
528 #define N_SRA(r1, d2, b2) N_RS(0x8A, r1, 0x00, d2, b2)
529 #define N_SRL(r1, d2, b2) N_RS(0x88, r1, 0x00, d2, b2)
530 #define N_ST(r1, d2, x2, b2) N_RX(0x50, r1, d2, x2, b2)
532 #define N_STAM(r1, r3, d2, b2) N_RS(0x9B, r1, r3, d2, b2)
533 #define N_STC(r1, d2, x2, b2) N_RX(0x42, r1, d2, x2, b2)
534 #define N_STCM(r1, m3, d2, b2) N_RS(0xBE, r1, m3, d2, b2)
535 #define N_STCK(d2, b2) N_S2(0xB205, d2, b2)
536 #define N_STCKE(d2, b2) N_S2(0xB278, d2, b2)
537 #define N_STH(r1, d2, x2, b2) N_RX(0x40, r1, d2, x2, b2)
538 #define N_STM(r1, r3, d2, b2) N_RS(0x90, r1, r3, d2, b2)
539 #define N_SR(r1, r2) N_RR(0x1B, r1, r2)
540 #define N_S(r1, d2, x2, b2) N_RX(0x5B, r1, d2, x2, b2)
541 #define N_SH(r1, d2, x2, b2) N_RX(0x4B, r1, d2, x2, b2)
542 #define N_SLR(r1, r2) N_RR(0x1F, r1, r2)
543 #define N_SL(r1, d2, x2, b2) N_RX(0x5F, r1, d2, x2, b2)
544 #define N_SVC(i) N_RR2(0x0A, i)
545 #define N_TS(d2, b2) N_S2(0x93, d2, b2)
546 #define N_TM(d1, b1, i2) N_SI(0x91, d1, b1, i2)
547 #define N_TMH(r1, i2) N_RI2(0xA7, 0x00, r1, i2)
548 #define N_TML(r1, i2) N_RI2(0xA7, 0x01, r1, i2)
549 #define N_TR(d1, l, b1, d2, b2) N_SS(0xDC, d1, (l - 1), b1, d2, b2)
550 #define N_TRT(d1, l, b1, d2, b2) N_SS(0xDD, d1, (l - 1), b1, d2, b2)
551 #define N_TRE(r1, r2) N_RRE(0xB2A5, r1, r2)
552 #define N_UNPK(d1, l1, b1, d2, l2, b2) N_SS2(0xF3, d1, (l1 - 1), b1, d2, (l2 - 2), b2)
553 #define N_UPT() N_E(0x0102)
555 /* Chapter 9. Floating point instructions */
557 #define N_LER(r1, r2) N_RR(0x38, r1, r2)
558 #define N_LDR(r1, r2) N_RR(0x28, r1, r2)
559 #define N_LXR(r1, r2) N_RRE(0xB365, r1, r2)
560 #define N_LE(r1, d2, x2, b2) N_RX(0x78, r1, d2, x2, b2)
561 #define N_LD(r1, d2, x2, b2) N_RX(0x68, r1, d2, x2, b2)
562 #define N_LZER(r1) N_RRE(0xB374, r1, 0x0)
563 #define N_LZDR(r1) N_RRE(0xB375, r1, 0x0)
564 #define N_LZXR(r1) N_RRE(0xB376, r1, 0x0)
565 #define N_STE(r1, d2, x2, b2) N_RX(0x70, r1, d2, x2, b2)
566 #define N_STD(r1, d2, x2, b2) N_RX(0x60, r1, d2, x2, b2)
568 /* chapter 19. Binary floating point instructions */
570 #define N_AEBR(r1, r2) N_RRE(0xB30A, r1, r2)
571 #define N_ADBR(r1, r2) N_RRE(0xB31A, r1, r2)
572 #define N_AXBR(r1, r2) N_RRE(0xB34A, r1, r2)
573 #define N_AEB(r1, d2, x2, b2) N_RXE(0xED0A, r1, d2, x2, b2)
574 #define N_ADB(r1, d2, x2, b2) N_RXE(0xED1A, r1, d2, x2, b2)
576 #define N_CEBR(r1, r2) N_RRE(0xB309, r1, r2)
577 #define N_CDBR(r1, r2) N_RRE(0xB319, r1, r2)
578 #define N_CXBR(r1, r2) N_RRE(0xB349, r1, r2)
579 #define N_CEB(r1, d2, x2, b2) N_RXE(0xED09, r1, d2, x2, b2)
580 #define N_CDB(r1, d2, x2, b2) N_RXE(0xED19, r1, d2, x2, b2)
582 #define N_CEFBR(r1, r2) N_RRE(0xB394, r1, r2)
583 #define N_CDFBR(r1, r2) N_RRE(0xB395, r1, r2)
584 #define N_CXFBR(r1, r2) N_RRE(0xB396, r1, r2)
586 #define N_CFEBR(r1, m3, r2) N_RRF(0xB398, r1, m3, r2)
587 #define N_CFDBR(r1, m3, r2) N_RRF(0xB399, r1, m3, r2)
588 #define N_CFXBR(r1, m3, r2) N_RRF(0xB39A, r1, m3, r2)
590 #define N_DEBR(r1, r2) N_RRE(0xB30D, r1, r2)
591 #define N_DDBR(r1, r2) N_RRE(0xB31D, r1, r2)
592 #define N_DXBR(r1, r2) N_RRE(0xB34D, r1, r2)
593 #define N_DEB(r1, d2, x2, b2) N_RXE(0xED0D, r1, d2, x2, b2)
594 #define N_DDB(r1, d2, x2, b2) N_RXE(0xED1D, r1, d2, x2, b2)
596 #define N_LCEBR(r1, r2) N_RRE(0xB303, r1, r2)
597 #define N_LCDBR(r1, r2) N_RRE(0xB313, r1, r2)
598 #define N_LCXBR(r1, r2) N_RRE(0xB343, r1, r2)
600 #define N_LDEBR(r1, r2) N_RRE(0xB304, r1, r2)
601 # define SZ_LDEBR SZ_RRE
602 #define N_LXDBR(r1, r2) N_RRE(0xB305, r1, r2)
603 #define N_LXEBR(r1, r2) N_RRE(0xB306, r1, r2)
605 #define N_LEDBR(r1, r2) N_RRE(0xB344, r1, r2)
606 #define N_LDXBR(r1, r2) N_RRE(0xB345, r1, r2)
607 #define N_LEXBR(r1, r2) N_RRE(0xB346, r1, r2)
609 #define N_LTEBR(r1, r2) N_RRE(0xB302, r1, r2)
610 #define N_LTDBR(r1, r2) N_RRE(0xB312, r1, r2)
611 #define N_LTXBR(r1, r2) N_RRE(0xB342, r1, r2)
613 #define N_MEEBR(r1, r2) N_RRE(0xB317, r1, r2)
614 #define N_MDBR(r1, r2) N_RRE(0xB31C, r1, r2)
615 #define N_MXBR(r1, r2) N_RRE(0xB34C, r1, r2)
616 #define N_MDEBR(r1, r2) N_RRE(0xB30C, r1, r2)
617 #define N_MXDBR(r1, r2) N_RRE(0xB307, r1, r2)
619 #define N_SEBR(r1, r2) N_RRE(0xB30B, r1, r2)
620 #define N_SDBR(r1, r2) N_RRE(0xB31B, r1, r2)
621 #define N_SXBR(r1, r2) N_RRE(0xB34B, r1, r2)
622 #define N_SEB(r1, d2, x2, b2) N_RXE(0xED0B, r1, d2, x2, b2)
623 #define N_SDB(r1, d2, x2, b2) N_RXE(0xED1B, r1, d2, x2, b2)
625 /* Alpha like instructions */
627 #define M_CALL(r2) N_BASR(R14, r2)
628 #define M_ILL(data) N_ILL(data)
629 #define M_ILL2(data1, data2) N_ILL((_UBITS(data1, 4) << 4) | _UBITS(data2, 4))
630 #define M_LONG(l) N_LONG(l)
632 #define M_ILD(r, b, d) \
634 if (N_VALID_DISP(d)) { \
636 } else if ((r == R0) && N_VALID_IMM(d)) { \
643 } else if ((r != R0) && N_VALID_IMM(d)) { \
644 N_LHI(r, d); N_L(r, 0, r, b); \
646 N_BRAS(r, SZ_BRAS + SZ_LONG); \
653 #define M_ILD_DSEG(r, d) M_ILD(r, REG_PV, N_DSEG_DISP(d))
655 #define M_ALD(r, b, d) M_ILD(r, b, d)
656 #define M_ALD_DSEG(r, d) M_ALD(r, REG_PV, N_DSEG_DISP(d))
658 #define M_LDA(r, b, d) \
660 if (N_VALID_DISP(d)) { \
662 } else if (N_VALID_IMM(d)) { \
666 N_BRAS(r, SZ_BRAS + SZ_LONG); \
672 #define M_LDA_DSEG(r, d) M_LDA(r, REG_PV, N_DSEG_DISP(d))
674 #define M_FLD(r, b, d) N_LE(r, d, RN, b)
675 #define M_FLDN(r, b, d, t) _IFNEG( \
677 N_LHI(t, d); N_LE(r, 0, t, b), \
680 #define M_FLD_DSEG(r, d, t) M_FLDN(r, REG_PV, N_DSEG_DISP(d), t)
682 #define M_DLD(r, b, d) N_LD(r, d, RN, b)
683 #define M_DLDN(r, b, d, t) _IFNEG( \
685 N_LHI(t, d); N_LD(r, 0, t, b), \
688 #define M_DLD_DSEG(r, d, t) M_DLDN(r, REG_PV, N_DSEG_DISP(d), t)
690 #define M_LLD(r, b, d) _IFNEG( \
692 N_LHI(GET_LOW_REG(r), d); \
693 N_L(GET_HIGH_REG(r), 0, GET_LOW_REG(r), b); \
694 N_L(GET_LOW_REG(r), 4, GET_LOW_REG(r), b), \
695 N_L(GET_HIGH_REG(r), (d) + 0, RN, b); N_L(GET_LOW_REG(r), (d) + 4, RN, b) \
697 #define M_LLD_DSEG(r, d) M_LLD(r, REG_PV, N_DSEG_DISP(d)
699 /* MOV(a, b) -> mov from A to B */
701 #define M_MOV(a, b) N_LR(b, a)
702 #define M_FMOV(a, b) N_LDR(b, a)
703 #define M_DMOV(a, b) M_FMOV((a), (b))
704 #define M_DST(r, b, d) _IFNEG(d, assert(0), N_STD(r, d, RN, b))
705 #define M_FST(r, b, d) _IFNEG(d, assert(0), N_STE(r, d, RN, b))
706 #define M_IST(r, b, d) _IFNEG( \
711 #define M_AST(r, b, d) M_IST(r, b, d)
712 #define M_LST(r, b, d) _IFNEG( \
715 N_ST(GET_HIGH_REG(r), (d) + 0, RN, b); N_ST(GET_LOW_REG(r), (d) + 4, RN, b) \
717 #define M_TEST(r) N_LTR(r, r)
718 #define M_BEQ(off) N_BRC(DD_E, off)
719 #define M_BNE(off) N_BRC(DD_NE, off)
720 #define M_BLE(off) N_BRC(DD_LE, off)
721 #define M_BGT(off) N_BRC(DD_H, off)
722 #define M_BLT(off) N_BRC(DD_L, off)
723 #define M_BGE(off) N_BRC(DD_HE, off)
724 #define M_BO(off) N_BRC(DD_O, off)
726 #define M_CMP(r1, r2) N_CR(r1, r2)
727 #define M_CMPU(r1, r2) N_CLR(r1, r2)
728 #define M_CLR(r) N_LHI(r, 0)
729 #define M_AADD_IMM(val, reg) N_AHI(reg, val)
730 #define M_IADD_IMM(val, reg) N_AHI(reg, val)
731 #define M_ISUB_IMM(val, reg) N_AHI(reg, -(val))
732 #define M_ASUB_IMM(val, reg) N_AHI(reg, -(val))
733 #define M_RET N_BCR(DD_ANY, R14)
734 #define M_BSR(ret_reg, disp) N_BRAS(ret_reg, disp)
735 #define M_BR(disp) N_BRC(DD_ANY, disp)
736 #define M_JMP(rs, rd) _IF(rs == RN, N_BCR(DD_ANY, rd), N_BASR(rs, rd))
737 #define M_NOP N_BC(0, 0, RN, RN)
738 #define M_NOP2 N_BCR(0, RN)
739 #define M_NOP3 N_BCR(0, 1)
740 #define M_JSR(reg_ret, reg_addr) N_BASR(reg_ret, reg_addr)
741 #define M_ICMP(a, b) N_CR(a, b)
742 #define M_ICMPU(a, b) N_CLR(a, b)
743 #define M_ICMP_IMM(a, b) N_CHI(a, b)
744 #define M_ACMP(a, b) N_CR(a, b)
745 #define M_CVTIF(src, dst) N_CEFBR(dst, src)
746 #define M_CVTID(src, dst) N_CDFBR(dst, src)
747 #define M_FMUL(a, dest) N_MEEBR(dest, a)
748 #define M_FSUB(a, dest) N_SEBR(dest, a)
749 #define M_FADD(a, dest) N_AEBR(dest, a)
750 #define M_FDIV(a, dest) N_DEBR(dest, a)
751 #define M_DMUL(a, dest) N_MDBR(dest, a)
752 #define M_DSUB(a, dest) N_SDBR(dest, a)
753 #define M_DADD(a, dest) N_ADBR(dest, a)
754 #define M_DDIV(a, dest) N_DDBR(dest, a)
755 #define M_CVTFI(src, dst) N_CFEBR(dst, 5, src)
756 #define M_CVTDI(src, dst) N_CFDBR(dst, 5, src)
757 #define M_IADD(a, dest) N_AR(dest, a)
758 #define M_AADD(a, dest) N_AR(dest, a)
759 #define M_ISUB(a, dest) N_SR(dest, a)
760 #define M_ASUB(a, dest) N_SR(dest, a)
761 #define M_IAND(a, dest) N_NR(dest, a)
762 #define M_IOR(a, dest) N_OR(dest, a)
763 #define M_IXOR(a, dest) N_XR(dest, a)
764 #define M_CVTFD(src,dst) N_LDEBR(dst, src)
765 #define M_CVTDF(src,dst) N_LEDBR(dst, src)
767 #define M_SLL_IMM(imm, reg) N_SLL(reg, imm, RN)
768 #define M_SLA_IMM(imm, reg) N_SLA(reg, imm, RN)
770 #define M_SLDL_IMM(imm, reg) N_SLDL(reg, imm, RN)
771 #define M_SLDA_IMM(imm, reg) N_SLDA(reg, imm, RN)
773 #define M_SRL_IMM(imm, reg) N_SRL(reg, imm, RN)
774 #define M_SRA_IMM(imm, reg) N_SRA(reg, imm, RN)
776 #define M_SRDL_IMM(imm, reg) N_SRDL(reg, imm, RN)
777 #define M_SRDA_IMM(imm, reg) N_SRDA(reg, imm, RN)
779 #define M_SLL(op, dst) N_SLL(dst, 0, op)
780 #define M_SLA(op, dst) N_SLA(dst, 0, op)
782 #define M_SLDL(op, dst) N_SLDL(dst, 0, op)
783 #define M_SLDA(op, dst) N_SLDA(dst, 0, op)
785 #define M_SRL(op, dst) N_SRL(dst, 0, op)
786 #define M_SRA(op, dst) N_SRA(dst, 0, op)
788 #define M_SRDL(op, dst) N_SRDL(dst, 0, op)
789 #define M_SRDA(op, dst) N_SRDA(dst, 0, op)
791 #define M_IMUL_IMM(val, reg) N_MHI(reg, val)
792 #define M_IMUL(a, dest) N_MSR(dest, a)
794 #define M_INEG(a, dest) N_LCR(dest, a)
796 #define M_FCMP(a, b) N_CEBR(a, b)
797 #define M_DCMP(a, b) N_CDBR(a, b)
799 #define M_FMOVN(r, dst) N_LCEBR(dst, r)
800 #define M_DMOVN(r, dst) N_LCDBR(dst, r)
802 #define ICONST(reg, i) \
804 if (N_VALID_IMM(i)) { \
807 disp = dseg_add_s4(cd, (i)); \
808 M_ILD_DSEG(reg, disp); \
812 #define LCONST(reg,c) \
814 ICONST(GET_HIGH_REG((reg)), (s4) ((s8) (c) >> 32)); \
815 ICONST(GET_LOW_REG((reg)), (s4) ((s8) (c))); \
818 #define M_ISUB_IMM32(imm, tmpreg, reg) \
820 if (N_VALID_IMM(imm)) { \
821 M_ISUB_IMM(imm, reg); \
823 ICONST(tmpreg, imm); \
824 M_ISUB(tmpreg, reg); \
828 #define M_ASUB_IMM32(imm, tmpreg, reg) M_ISUB_IMM32(imm, tmpreg, reg)
830 #endif /* _CODEGEN_H */
833 * These are local overrides for various environment variables in Emacs.
834 * Please do not remove this and leave it at the end of the file, where
835 * Emacs will automagically detect them.
836 * ---------------------------------------------------------------------
839 * indent-tabs-mode: t