mono/arch/hppa/hppa-codegen.h

   1 #ifndef _HPPA_CODEGEN_H_
   2 #define _HPPA_CODEGEN_H_
   3
   4 typedef enum {
   5         hppa_r0 = 0,
   6         hppa_r1,
   7         hppa_r2,
   8         hppa_rp = hppa_r2,
   9         hppa_r3,
  10         hppa_r4,
  11         hppa_r5,
  12         hppa_r6,
  13         hppa_r7,
  14         hppa_r8,
  15         hppa_r9,
  16         hppa_r10,
  17         hppa_r11,
  18         hppa_r12,
  19         hppa_r13,
  20         hppa_r14,
  21         hppa_r15,
  22         hppa_r16,
  23         hppa_r17,
  24         hppa_r18,
  25         hppa_r19,
  26         hppa_r20,
  27         hppa_r21,
  28         hppa_r22,
  29         hppa_r23,
  30         hppa_r24,
  31         hppa_r25,
  32         hppa_r26,
  33         hppa_r27,
  34         hppa_r28,
  35         hppa_r29,
  36         hppa_ap = hppa_r29,
  37         hppa_r30,
  38         hppa_sp = hppa_r30,
  39         hppa_r31
  40 } HPPAIntRegister;
  41
  42 typedef enum {
  43         hppa_fr0,
  44         hppa_fr1,
  45         hppa_fr2,
  46         hppa_fr3,
  47         hppa_fr4,
  48         hppa_fr5,
  49         hppa_fr6,
  50         hppa_fr7,
  51         hppa_fr8,
  52         hppa_fr9,
  53         hppa_fr10,
  54         hppa_fr11,
  55         hppa_fr12,
  56         hppa_fr13,
  57         hppa_fr14,
  58         hppa_fr15,
  59         hppa_fr16,
  60         hppa_fr17,
  61         hppa_fr18,
  62         hppa_fr19,
  63         hppa_fr20,
  64         hppa_fr21,
  65         hppa_fr22,
  66         hppa_fr23,
  67         hppa_fr24,
  68         hppa_fr25,
  69         hppa_fr26,
  70         hppa_fr27,
  71         hppa_fr28,
  72         hppa_fr29,
  73         hppa_fr30,
  74         hppa_fr31
  75 } HPPAFloatRegister;
  76
  77 #define hppa_opcode(op) ((op) << 26)
  78 #define hppa_opcode_alu(op1, op2) (((op1) << 26) | ((op2) << 6))
  79 #define hppa_op_r1(r) ((r) << 21)
  80 #define hppa_op_r2(r) ((r) << 16)
  81 #define hppa_op_r3(r) (r)
  82
  83 /* imm5, imm11 and imm14 are encoded by putting the sign bit in the LSB */
  84 #define hppa_op_imm5(im5) ((((im5) & 0xf) << 1) | (((int)(im5)) < 0))
  85 #define hppa_op_imm11(im11) ((((im11) & 0x3ff) << 1) | (((int)(im11)) < 0))
  86 #define hppa_op_imm14(im14) ((((im14) & 0x1fff) << 1) | (((int)(im14)) < 0))
  87
  88 /* HPPA uses "selectors" for some operations. The two we need are L% and R% */
  89 /* lsel: select left 21 bits */
  90 #define hppa_lsel(v)            (((int)(v))>>11)
  91 /* rsel: select right 11 bits */
  92 #define hppa_rsel(v)            (((int)(v))&0x7ff)
  93
  94 /* imm12 is used by the conditional branch insns
  95  * w1 (bits [2..12])
  96  * w (bit 0)
  97  * value = assemble_12(w1,w) = cat(w,w1{10},w1{0..9})
  98  * (note PA bit numbering)
  99  *
 100  * if the original number is:
 101  * abcdefghijkl
 102  *
 103  *  3         2         1         0
 104  * 10987654321098765432109876543210
 105  *                    cdefghijklb a
 106  */
 107 static inline int hppa_op_imm12(int im12)
 108 {
 109         unsigned int a = im12 < 0;
 110         unsigned int b = (im12 >> 10) & 0x1;
 111         unsigned int cdefghijkl = im12 & 0x3ff;
 112
 113         return (cdefghijkl << 3) | (b << 2) | a;
 114 }
 115
 116 /*
 117  * imm17 is used by the BL insn, which has
 118  * w1 (bits [16..20])
 119  * w2 (bits [2..12])
 120  * w (bit 0)
 121  * value = assemble_17(w1,w2,w) = cat(w,w1,w2{10},w2{0..9})
 122  * (note PA bit numbering)
 123  *
 124  * if the original number is:
 125  * abcdefghijklmnopq
 126  *
 127  *  3         2         1         0
 128  * 10987654321098765432109876543210
 129  *            bcdef   hijklmnopqg a
 130  */
 131 static inline int hppa_op_imm17(int im17)
 132 {
 133         unsigned int a = im17 < 0;
 134         unsigned int bcdef = (im17 >> 11) & 0x1f;
 135         unsigned int g = (im17 >> 10) & 0x1;
 136         unsigned int hijklmnopq = im17 & 0x3ff;
 137
 138         return (bcdef << 16) | (hijklmnopq << 3) | (g << 2) | a;
 139 }
 140
 141 /* imm21 is used by addil and ldil
 142  *
 143  * value = assemble_21(x) = cat(x{20},x{9..19},x{5..6},x{0..4},x{7..8})
 144  * (note PA bit numbering)
 145  *
 146  * if the original number is:
 147  * abcdefghijklmnopqrstu
 148  *
 149  *  3         2         1         0
 150  * 10987654321098765432109876543210
 151  *            opqrsmntubcdefghijkla
 152  */
 153 static inline int hppa_op_imm21(int im21)
 154 {
 155         unsigned int a = im21 < 0;
 156         unsigned int bcdefghijkl = (im21 >> 9) & 0x7ff;
 157         unsigned int mn = (im21 >> 7) & 0x3;
 158         unsigned int opqrs = (im21 >> 2) & 0x1f;
 159         unsigned int tu = im21 & 0x3;
 160
 161         return (opqrs << 16) | (mn << 14) | (tu << 12) | (bcdefghijkl << 1) | a;
 162 }
 163
 164 /* returns 1 if VAL can fit in BITS */
 165 static inline int hppa_check_bits(int val, int bits)
 166 {
 167         /* positive offset */
 168         if (!(val & (1 << (bits - 1))) && (val >> bits) != 0)
 169                 return 0;
 170         /* negative offset */
 171         if ((val & (1 << (bits - 1))) && ((val >> bits) != (-1 >>(bits+2))))
 172                 return 0;
 173         return 1;
 174 }
 175
 176 static inline void *hppa_emit(void *inp, unsigned int insn)
 177 {
 178         unsigned int *code = inp;
 179         *code = insn;
 180         return ((char *)code) + 4;
 181 }
 182
 183 /* Table 5-3: Compare conditons */
 184 #define HPPA_CMP_COND_NEVER     (0)
 185 #define HPPA_CMP_COND_EQ        (1)
 186 #define HPPA_CMP_COND_SLT       (2)
 187 #define HPPA_CMP_COND_SLE       (3)
 188 #define HPPA_CMP_COND_ULT       (4)
 189 #define HPPA_CMP_COND_ULE       (5)
 190 #define HPPA_CMP_COND_OV        (6)
 191 #define HPPA_CMP_COND_ODD       (7)
 192
 193 /* Table 5-3: Subtaction conditions */
 194 #define HPPA_SUB_COND_NEVER     ((0 << 1) | 0)
 195 #define HPPA_SUB_COND_EQ        ((1 << 1) | 0)
 196 #define HPPA_SUB_COND_SLT       ((2 << 1) | 0)
 197 #define HPPA_SUB_COND_SLE       ((3 << 1) | 0)
 198 #define HPPA_SUB_COND_ULT       ((4 << 1) | 0)
 199 #define HPPA_SUB_COND_ULE       ((5 << 1) | 0)
 200 #define HPPA_SUB_COND_SV        ((6 << 1) | 0)
 201 #define HPPA_SUB_COND_OD        ((7 << 1) | 0)
 202 #define HPPA_SUB_COND_ALWAYS    ((0 << 1) | 1)
 203 #define HPPA_SUB_COND_NE        ((1 << 1) | 1)
 204 #define HPPA_SUB_COND_SGE       ((2 << 1) | 1)
 205 #define HPPA_SUB_COND_SGT       ((3 << 1) | 1)
 206 #define HPPA_SUB_COND_UGE       ((4 << 1) | 1)
 207 #define HPPA_SUB_COND_UGT       ((5 << 1) | 1)
 208 #define HPPA_SUB_COND_NSV       ((6 << 1) | 1)
 209 #define HPPA_SUB_COND_EV        ((7 << 1) | 1)
 210
 211 /* Table 5-4: Addition conditions */
 212 #define HPPA_ADD_COND_NEVER     ((0 << 1) | 0)
 213 #define HPPA_ADD_COND_EQ        ((1 << 1) | 0)
 214 #define HPPA_ADD_COND_LT        ((2 << 1) | 0)
 215 #define HPPA_ADD_COND_LE        ((3 << 1) | 0)
 216 #define HPPA_ADD_COND_NUV       ((4 << 1) | 0)
 217 #define HPPA_ADD_COND_ZUV       ((5 << 1) | 0)
 218 #define HPPA_ADD_COND_SV        ((6 << 1) | 0)
 219 #define HPPA_ADD_COND_OD        ((7 << 1) | 0)
 220 #define HPPA_ADD_COND_ALWAYS    ((0 << 1) | 1)
 221 #define HPPA_ADD_COND_NE        ((1 << 1) | 1)
 222 #define HPPA_ADD_COND_GE        ((2 << 1) | 1)
 223 #define HPPA_ADD_COND_GT        ((3 << 1) | 1)
 224 #define HPPA_ADD_COND_UV        ((4 << 1) | 1)
 225 #define HPPA_ADD_COND_VNZ       ((5 << 1) | 1)
 226 #define HPPA_ADD_COND_NSV       ((6 << 1) | 1)
 227 #define HPPA_ADD_COND_EV        ((7 << 1) | 1)
 228
 229 /* Table 5-5: Logical instruction conditions */
 230 #define HPPA_LOGICAL_COND_NEVER                 ((0 << 1) | 0)
 231 #define HPPA_LOGICAL_COND_ZERO                  ((1 << 1) | 0)
 232 #define HPPA_LOGICAL_COND_MSB_SET               ((2 << 1) | 0)
 233 #define HPPA_LOGICAL_COND_MSB_SET_OR_ZERO       ((3 << 1) | 0)
 234 #define HPPA_LOGICAL_COND_LSB_SET               ((7 << 1) | 0)
 235 #define HPPA_LOGICAL_COND_ALWAYS                ((0 << 1) | 1)
 236 #define HPPA_LOGICAL_COND_NZ                    ((1 << 1) | 1)
 237 #define HPPA_LOGICAL_COND_MSB_CLR               ((2 << 1) | 1)
 238 #define HPPA_LOGICAL_COND_MSB_CLR_AND_NZ        ((3 << 1) | 1)
 239 #define HPPA_LOGICAL_COND_LSB_CLR               ((7 << 1) | 1)
 240
 241 /* Table 5-6: Unit Conditions */
 242 #define HPPA_UNIT_COND_NEVER    ((0 << 1) | 0)
 243 #define HPPA_UNIT_COND_SBZ      ((2 << 1) | 0)
 244 #define HPPA_UNIT_COND_SHZ      ((3 << 1) | 0)
 245 #define HPPA_UNIT_COND_SDC      ((4 << 1) | 0)
 246 #define HPPA_UNIT_COND_SBC      ((6 << 1) | 0)
 247 #define HPPA_UNIT_COND_SHC      ((7 << 1) | 0)
 248 #define HPPA_UNIT_COND_ALWAYS   ((0 << 1) | 1)
 249 #define HPPA_UNIT_COND_NBZ      ((2 << 1) | 1)
 250 #define HPPA_UNIT_COND_NHZ      ((3 << 1) | 1)
 251 #define HPPA_UNIT_COND_NDC      ((4 << 1) | 1)
 252 #define HPPA_UNIT_COND_NBC      ((6 << 1) | 1)
 253 #define HPPA_UNIT_COND_NHC      ((7 << 1) | 1)
 254
 255 /* Table 5-7: Shift/Extract/Deposit Conditions */
 256 #define HPPA_BIT_COND_NEVER     (0)
 257 #define HPPA_BIT_COND_ZERO      (1)
 258 #define HPPA_BIT_COND_MSB_SET   (2)
 259 #define HPPA_BIT_COND_LSB_SET   (3)
 260 #define HPPA_BIT_COND_ALWAYS    (4)
 261 #define HPPA_BIT_COND_SOME_SET  (5)
 262 #define HPPA_BIT_COND_MSB_CLR   (6)
 263 #define HPPA_BIT_COND_LSB_CLR   (7)
 264
 265 #define hppa_mtsar(p, r)                                \
 266         p = hppa_emit (p, hppa_opcode(0x00) | hppa_op_r1(11) | hppa_op_r2(r) | (0xC2 << 5))
 267
 268 #define hppa_bl_full(p, n, target, t) do {              \
 269         g_assert (hppa_check_bits (target, 17));        \
 270         p = hppa_emit (p, hppa_opcode(0x3A) | hppa_op_r1(t) | hppa_op_imm17(((int)(((target) - 8)>>2))) | ((n) << 1)); \
 271 } while (0)
 272
 273 #define hppa_bl(p, target, t) hppa_bl_full(p, 0, target, t)
 274 #define hppa_bl_n(p, target, t) hppa_bl_full(p, 1, target, t)
 275
 276 #define hppa_bv(p, x, b)                                \
 277         p = hppa_emit (p, hppa_opcode(0x3A) | hppa_op_r1(b) | hppa_op_r2(x) | (6 << 13))
 278
 279 #define hppa_blr(p, x, t)                               \
 280         p = hppa_emit (p, hppa_opcode(0x3A) | hppa_op_r1(t) | hppa_op_r2(x) | (2 << 13))
 281
 282 /* hardcoded sr = sr4 */
 283 #define hppa_ble_full(p, n, d, b)                       \
 284         p = hppa_emit (p, hppa_opcode(0x39) | hppa_op_r1(b) | hppa_op_imm17(((int)(d)) >> 2) | (1 << 13) | ((n) << 1))
 285
 286 #define hppa_ble(p, d, b) hppa_ble_full(p, 0, d, b)
 287 #define hppa_ble_n(p, d, b) hppa_ble_full(p, 1, d, b)
 288
 289 #define hppa_be_full(p, n, d, b)                        \
 290         p = hppa_emit (p, hppa_opcode(0x38) | hppa_op_r1(b) | hppa_op_imm17(((int)(d)) >> 2) | (1 << 13) | ((n) << 1))
 291
 292 #define hppa_be(p, d, b) hppa_be_full(p, 0, d, b)
 293 #define hppa_be_n(p, d, b) hppa_be_full(p, 1, d, b)
 294
 295 #define hppa_bb_full(p, cond, n, r, b, t)               \
 296         p = hppa_emit (p, hppa_opcode(0x31) | hppa_op_r1(b) | hppa_op_r2(r) | ((cond) << 13) | ((n) << 1) | hppa_op_imm12((int)(t)))
 297
 298 #define hppa_bb(p, cond, r, b, t) hppa_bb_full(p, cond, 0, r, b, t)
 299 #define hppa_bb_n(p, cond, r, b, t) hppa_bb_full(p, cond, 1, r, b, t)
 300
 301
 302 #define hppa_movb(p, r1, r2, cond, target) do {         \
 303         g_assert (hppa_check_bits (target, 12));        \
 304         p = hppa_emit (p, hppa_opcode(0x32) | hppa_op_r1(r2) | hppa_op_r2(r1) | ((cond) << 13) | hppa_op_imm12(((int)(target)))); \
 305 } while (0)
 306
 307 #define hppa_movib(p, i, r, cond, target) do {          \
 308         g_assert (hppa_check_bits (target, 12));        \
 309         p = hppa_emit (p, hppa_opcode(0x33) | hppa_op_r1(r) | (hppa_op_imm5(((int)(i))) << 16) | ((cond) << 13) | hppa_op_imm12(((int)(target)))); \
 310 } while (0)
 311
 312 #define hppa_combt(p, r1, r2, cond, target) do {        \
 313         g_assert (hppa_check_bits (target, 12));        \
 314         p = hppa_emit (p, hppa_opcode(0x20) | hppa_op_r1(r2) | hppa_op_r2(r1) | ((cond) << 13) | hppa_op_imm12(((int)(target)))); \
 315 } while (0)
 316
 317 #define hppa_combf(p, r1, r2, cond, target) do {        \
 318         g_assert (hppa_check_bits (target, 12));        \
 319         p = hppa_emit (p, hppa_opcode(0x22) | hppa_op_r1(r2) | hppa_op_r2(r1) | ((cond) << 13) | hppa_op_imm12(((int)(target)))); \
 320 } while (0)
 321
 322 #define hppa_combit(p, i, r, cond, target) do {         \
 323         g_assert (hppa_check_bits (target, 12));        \
 324         p = hppa_emit (p, hppa_opcode(0x21) | hppa_op_r1(r) | (hppa_op_imm5(((int)(i))) << 16) | ((cond) << 13) | hppa_op_imm12(((int)(target)))); \
 325 } while (0)
 326
 327 #define hppa_combif(p, i, r, cond, target) do {         \
 328         g_assert (hppa_check_bits (target, 12));        \
 329         p = hppa_emit (p, hppa_opcode(0x23) | hppa_op_r1(r) | (hppa_op_imm5(((int)(i))) << 16) | ((cond) << 13) | hppa_op_imm12(((int)(target)))); \
 330 } while (0)
 331
 332 /* TODO: addbt, addbf, addbit, addbif */
 333
 334 /* Load/store insns */
 335 #define hppa_ld_disp(p, op, d, b, t) do {               \
 336         g_assert (hppa_check_bits (d, 14));             \
 337         p = hppa_emit (p, hppa_opcode(op) | hppa_op_r1(b) | hppa_op_r2(t) | hppa_op_imm14(((int)(d)))); \
 338 } while (0)
 339
 340 #define hppa_ldb(p, d, b, t) hppa_ld_disp(p, 0x10, d, b, t)
 341 #define hppa_ldh(p, d, b, t) hppa_ld_disp(p, 0x11, d, b, t)
 342 #define hppa_ldw(p, d, b, t) hppa_ld_disp(p, 0x12, d, b, t)
 343
 344 #define hppa_ldwm(p, d, b, t) \
 345         p = hppa_emit (p, hppa_opcode(0x13) | hppa_op_r1(b) | hppa_op_r2(t) | hppa_op_imm14(d)); \
 346
 347 #define hppa_ldbx(p, x, b, t) hppa_ld_indexed(p, 0, x, b, t)
 348
 349 #define hppa_st_disp(p, op, r, d, b) do {               \
 350         g_assert (hppa_check_bits (d, 14));             \
 351         p = hppa_emit (p, hppa_opcode(op) | hppa_op_r1(b) | hppa_op_r2(r) | hppa_op_imm14(((int)(d)))); \
 352 } while (0)
 353
 354 #define hppa_stb(p, r, d, b) hppa_st_disp(p, 0x18, r, d, b)
 355 #define hppa_sth(p, r, d, b) hppa_st_disp(p, 0x19, r, d, b)
 356 #define hppa_stw(p, r, d, b) hppa_st_disp(p, 0x1A, r, d, b)
 357
 358 #define hppa_stwm(p, r, d, b) \
 359         p = hppa_emit (p, hppa_opcode(0x1B) | hppa_op_r1(b) | hppa_op_r2(r) | hppa_op_imm14(d))
 360
 361 #define hppa_ldbx(p, x, b, t) hppa_ld_indexed(p, 0, x, b, t)
 362
 363 /* s = 0, u = 0, cc = 0, m = 0 */
 364 #define hppa_ld_indexed(p, op, x, b, t)                 \
 365         p = hppa_emit (p, hppa_opcode(0x03) | hppa_op_r1(b) | hppa_op_r2(x) | hppa_op_r3(t) | (op << 6))
 366
 367 #define hppa_ldbx(p, x, b, t) hppa_ld_indexed(p, 0, x, b, t)
 368 #define hppa_ldhx(p, x, b, t) hppa_ld_indexed(p, 1, x, b, t)
 369 #define hppa_ldwx(p, x, b, t) hppa_ld_indexed(p, 2, x, b, t)
 370
 371 #define hppa_ldil(p, i, t)                              \
 372         p = hppa_emit (p, hppa_opcode(0x08) | hppa_op_r1(t) | hppa_op_imm21(((int)(i))))
 373
 374 #define hppa_ldo(p, d, b, t)                            \
 375         p = hppa_emit (p, hppa_opcode(0x0D) | hppa_op_r1(b) | hppa_op_r2(t) | hppa_op_imm14((int)(d)))
 376
 377 #define hppa_set(p, imm, t) do {                        \
 378         if (hppa_check_bits ((int)(imm), 14))           \
 379                 hppa_ldo (p, (int)(imm), hppa_r0, t); \
 380         else {                                          \
 381                 hppa_ldil (p, hppa_lsel (imm), t); \
 382                 hppa_ldo (p, hppa_rsel (imm), t, t); \
 383         }                                               \
 384 } while (0)
 385
 386 /* addil's destination is always r1 */
 387 #define hppa_addil(p, i, r)                             \
 388         p = hppa_emit (p, hppa_opcode(0x0A) | hppa_op_r1(r) | hppa_op_imm21(i))
 389
 390 #define hppa_alu_op(p, op, cond, r1, r2, t)     \
 391         p = hppa_emit (p, hppa_opcode_alu(0x02, op) | hppa_op_r1(r2) | hppa_op_r2(r1) | hppa_op_r3(t) | ((cond) << 12))
 392
 393 #define hppa_add_cond(p, cond, r1, r2, t) hppa_alu_op(p, 0x18, cond, r1, r2, t)
 394 #define hppa_add(p, r1, r2, t) hppa_add_cond(p, HPPA_ADD_COND_NEVER, r1, r2, t)
 395 #define hppa_addl_cond(p, cond, r1, r2, t) hppa_alu_op(p, 0x28, cond, r1, r2, t)
 396 #define hppa_addl(p, r1, r2, t) hppa_addl_cond(p, HPPA_ADD_COND_NEVER, r1, r2, t)
 397 #define hppa_addo_cond(p, cond, r1, r2, t) hppa_alu_op(p, 0x38, cond, r1, r2, t)
 398 #define hppa_addo(p, r1, r2, t) hppa_addo_cond(p, HPPA_ADD_COND_NEVER, r1, r2, t)
 399 #define hppa_addc_cond(p, cond, r1, r2, t) hppa_alu_op(p, 0x1C, cond, r1, r2, t)
 400 #define hppa_addc(p, r1, r2, t) hppa_addc_cond(p, HPPA_ADD_COND_NEVER, r1, r2, t)
 401 #define hppa_addco_cond(p, cond, r1, r2, t) hppa_alu_op(p, 0x3C, cond, r1, r2, t)
 402 #define hppa_addco(p, r1, r2, t) hppa_addco_cond(p, HPPA_ADD_COND_NEVER, r1, r2, t)
 403 #define hppa_sh1add_cond(p, cond, r1, r2, t) hppa_alu_op(p, 0x19, cond, r1, r2, t)
 404 #define hppa_sh1add(p, r1, r2, t) hppa_sh1add_cond(p, HPPA_ADD_COND_NEVER, r1, r2, t)
 405 #define hppa_sh1addl_cond(p, cond, r1, r2, t) hppa_alu_op(p, 0x29, cond, r1, r2, t)
 406 #define hppa_sh1addl(p, r1, r2, t) hppa_sh1addl_cond(p, HPPA_ADD_COND_NEVER, r1, r2, t)
 407 #define hppa_sh1addo_cond(p, cond, r1, r2, t) hppa_alu_op(p, 0x39, cond, r1, r2, t)
 408 #define hppa_sh1addo(p, r1, r2, t) hppa_sh1addo_cond(p, HPPA_ADD_COND_NEVER, r1, r2, t)
 409 #define hppa_sh2add_cond(p, cond, r1, r2, t) hppa_alu_op(p, 0x1A, cond, r1, r2, t)
 410 #define hppa_sh2add(p, r1, r2, t) hppa_sh2add_cond(p, HPPA_ADD_COND_NEVER, r1, r2, t)
 411 #define hppa_sh2addl_cond(p, cond, r1, r2, t) hppa_alu_op(p, 0x2A, cond, r1, r2, t)
 412 #define hppa_sh2addl(p, r1, r2, t) hppa_sh2addl_cond(p, HPPA_ADD_COND_NEVER, r1, r2, t)
 413 #define hppa_sh2addo_cond(p, cond, r1, r2, t) hppa_alu_op(p, 0x3A, cond, r1, r2, t)
 414 #define hppa_sh2addo(p, r1, r2, t) hppa_sh2addo_cond(p, HPPA_ADD_COND_NEVER, r1, r2, t)
 415 #define hppa_sh3add_cond(p, cond, r1, r2, t) hppa_alu_op(p, 0x1B, cond, r1, r2, t)
 416 #define hppa_sh3add(p, r1, r2, t) hppa_sh3add_cond(p, HPPA_ADD_COND_NEVER, r1, r2, t)
 417 #define hppa_sh3addl_cond(p, cond, r1, r2, t) hppa_alu_op(p, 0x2B, cond, r1, r2, t)
 418 #define hppa_sh3addl(p, r1, r2, t) hppa_add_cond(p, HPPA_ADD_COND_NEVER, r1, r2, t)
 419 #define hppa_sh3addo_cond(p, cond, r1, r2, t) hppa_alu_op(p, 0x3B, cond, r1, r2, t)
 420 #define hppa_sh3addo(p, r1, r2, t) hppa_sh3addo_cond(p, HPPA_ADD_COND_NEVER, r1, r2, t)
 421
 422 #define hppa_sub_cond(p, cond, r1, r2, t) hppa_alu_op(p, 0x10, cond, r1, r2, t)
 423 #define hppa_sub(p, r1, r2, t) hppa_sub_cond(p, HPPA_SUB_COND_NEVER, r1, r2, t)
 424 #define hppa_subo_cond(p, cond, r1, r2, t) hppa_alu_op(p, 0x30, cond, r1, r2, t)
 425 #define hppa_subo(p, r1, r2, t) hppa_subo_cond(p, HPPA_SUB_COND_NEVER, r1, r2, t)
 426 #define hppa_subb_cond(p, cond, r1, r2, t) hppa_alu_op(p, 0x14, cond, r1, r2, t)
 427 #define hppa_subb(p, r1, r2, t) hppa_subb_cond(p, HPPA_SUB_COND_NEVER, r1, r2, t)
 428 #define hppa_subbo_cond(p, cond, r1, r2, t) hppa_alu_op(p, 0x34, cond, r1, r2, t)
 429 #define hppa_subbo(p, r1, r2, t) hppa_subbo_cond(p, HPPA_SUB_COND_NEVER, r1, r2, t)
 430 #define hppa_subt_cond(p, cond, r1, r2, t) hppa_alu_op(p, 0x13, cond, r1, r2, t)
 431 #define hppa_subt(p, r1, r2, t) hppa_subt_cond(p, HPPA_SUB_COND_NEVER, r1, r2, t)
 432 #define hppa_subto_cond(p, cond, r1, r2, t) hppa_alu_op(p, 0x33, cond, r1, r2, t)
 433 #define hppa_subto(p, r1, r2, t) hppa_subto_cond(p, HPPA_SUB_COND_NEVER, r1, r2, t)
 434 #define hppa_ds_cond(p, cond, r1, r2, t) hppa_alu_op(p, 0x11, cond, r1, r2, t)
 435 #define hppa_ds(p, r1, r2, t) hppa_ds_cond(p, HPPA_SUB_COND_NEVER, r1, r2, t)
 436 #define hppa_comclr_cond(p, cond, r1, r2, t) hppa_alu_op(p, 0x22, cond, r1, r2, t)
 437 #define hppa_comclr(p, r1, r2, t) hppa_comclr_cond(p, HPPA_SUB_COND_NEVER, r1, r2, t)
 438
 439 #define hppa_or_cond(p, cond, r1, r2, t) hppa_alu_op(p, 0x09, cond, r1, r2, t)
 440 #define hppa_or(p, r1, r2, t) hppa_or_cond(p, HPPA_LOGICAL_COND_NEVER, r1, r2, t)
 441 #define hppa_copy(p, r1, r2) hppa_or(p, r1, hppa_r0, r2)
 442 #define hppa_nop(p) hppa_or(p, hppa_r0, hppa_r0, hppa_r0)
 443 #define hppa_xor_cond(p, cond, r1, r2, t) hppa_alu_op(p, 0x0A, cond, r1, r2, t)
 444 #define hppa_xor(p, r1, r2, t) hppa_xor_cond(p, HPPA_LOGICAL_COND_NEVER, r1, r2, t)
 445 #define hppa_and_cond(p, cond, r1, r2, t) hppa_alu_op(p, 0x08, cond, r1, r2, t)
 446 #define hppa_and(p, r1, r2, t) hppa_and_cond(p, HPPA_LOGICAL_COND_NEVER, r1, r2, t)
 447 #define hppa_andcm_cond(p, cond, r1, r2, t) hppa_alu_op(p, 0x00, cond, r1, r2, t)
 448 #define hppa_andcm(p, r1, r2, t) hppa_andcm_cond(p, HPPA_LOGICAL_COND_NEVER, r1, r2, t)
 449
 450 #define hppa_uxor_cond(p, cond, r1, r2, t) hppa_alu_op(p, 0x0E, cond, r1, r2, t)
 451 #define hppa_uxor(p, r1, r2, t) hppa_uxor_cond(p, HPPA_UNIT_COND_NEVER, r1, r2, t)
 452 #define hppa_uaddcm_cond(p, cond, r1, r2, t) hppa_alu_op(p, 0x26, cond, r1, r2, t)
 453 #define hppa_uaddcm(p, r1, r2, t) hppa_uaddcm_cond(p, HPPA_UNIT_COND_NEVER, r1, r2, t)
 454 #define hppa_uaddcmt_cond(p, cond, r1, r2, t) hppa_alu_op(p, 0x27, cond, r1, r2, t)
 455 #define hppa_uaddcmt(p, r1, r2, t) hppa_uaddcmt_cond(p, HPPA_UNIT_COND_NEVER, r1, r2, t)
 456 #define hppa_dcor_cond(p, cond, r1, r2, t) hppa_alu_op(p, 0x2E, cond, r1, r2, t)
 457 #define hppa_dcor(p, r1, r2, t) hppa_dcor_cond(p, HPPA_UNIT_COND_NEVER, r1, r2, t)
 458 #define hppa_idcor_cond(p, cond, r1, r2, t) hppa_alu_op(p, 0x2F, cond, r1, r2, t)
 459 #define hppa_idcor(p, r1, r2, t) hppa_idcor_cond(p, HPPA_UNIT_COND_NEVER, r1, r2, t)
 460
 461 #define hppa_addi(p, i, r, t)                           \
 462         p = hppa_emit (p, hppa_opcode(0x2D) | hppa_op_r1(r) | hppa_op_r2(t) | hppa_op_imm11(((int)(i))))
 463
 464 #define hppa_subi(p, i, r, t)                           \
 465         p = hppa_emit (p, hppa_opcode(0x25) | hppa_op_r1(r) | hppa_op_r2(t) | hppa_op_imm11(((int)(i))))
 466
 467 #define hppa_not(p, r, t) hppa_subi(p, -1, r, t)
 468
 469 #define hppa_comiclr(p, i, r, t)                        \
 470         p = hppa_emit (p, hppa_opcode(0x24) | hppa_op_r1(r) | hppa_op_r2(t) | hppa_op_imm11(((int)(i))))
 471
 472 #define hppa_vshd(p, r1, r2, t)                         \
 473         p = hppa_emit (p, hppa_opcode(0x34) | hppa_op_r1(r2) | hppa_op_r2(r1) | hppa_op_r3(t))
 474
 475 /* shift is a register */
 476 #define hppa_lshr(p, r, shift, t)                       \
 477         do {                                            \
 478                 hppa_mtsar(p, shift);                   \
 479                 hppa_vshd(p, hppa_r0, r, t);            \
 480         } while (0)
 481
 482 /* shift is a constant */
 483 #define hppa_shd(p, r1, r2, shift, t)                   \
 484         p = hppa_emit (p, hppa_opcode(0x34) | hppa_op_r1(r2) | hppa_op_r2(r1) | hppa_op_r3(t) | (2 << 10) | ((31 - (shift)) << 5))
 485
 486 #define hppa_vextru(p, r, len, t)                       \
 487         p = hppa_emit (p, hppa_opcode(0x34) | hppa_op_r1(r) | hppa_op_r2(t) | (4 << 10) | (32 - (len)))
 488
 489 #define hppa_vextrs(p, r, len, t)                       \
 490         p = hppa_emit (p, hppa_opcode(0x34) | hppa_op_r1(r) | hppa_op_r2(t) | (5 << 10) | (32 - (len)))
 491
 492 /* shift is a register */
 493 #define hppa_shr(p, r, shift, t)                        \
 494         do {                                            \
 495                 hppa_subi(p, 31, shift, t);             \
 496                 hppa_mtsar(p, t);                       \
 497                 hppa_vextrs(p, r, 32, t);               \
 498         } while (0)
 499
 500 /* shift is a constant */
 501 #define hppa_extru(p, r, shift, len, t)                 \
 502         p = hppa_emit (p, hppa_opcode(0x34) | hppa_op_r1(r) | hppa_op_r2(t) | (6 << 10) | ((shift) << 5) | (32 - (len)))
 503
 504 #define hppa_extrs(p, r, shift, len, t)                 \
 505         p = hppa_emit (p, hppa_opcode(0x34) | hppa_op_r1(r) | hppa_op_r2(t) | (7 << 10) | ((shift) << 5) | (32 - (len)))
 506
 507 #define hppa_vdep(p, r, len, t)                         \
 508         p = hppa_emit (p, hppa_opcode(0x35) | hppa_op_r1(r) | hppa_op_r2(t) | (1 << 10) | (32 - (len)))
 509
 510 #define hppa_dep(p, r, pos, len, t)                     \
 511         p = hppa_emit (p, hppa_opcode(0x35) | hppa_op_r1(t) | hppa_op_r2(r) | (3 << 10) | ((31 - (pos)) << 5) | (32 - (len)))
 512
 513 #define hppa_vdepi(p, i, len, t)                        \
 514         p = hppa_emit (p, hppa_opcode(0x35) | hppa_op_r1(t) | (hppa_op_imm5(((int)(i))) << 16) | (5 << 10) | (32 - (len)))
 515
 516 #define hppa_depi(p, i, pos, len, t)                    \
 517         p = hppa_emit (p, hppa_opcode(0x35) | hppa_op_r1(t) | (hppa_op_imm5(((int)(i))) << 16) | (7 << 10) | ((31 - (pos)) << 5) | (32 - (len)))
 518
 519 #define hppa_zvdep(p, r, len, t)                        \
 520         p = hppa_emit (p, hppa_opcode(0x35) | hppa_op_r1(t) | hppa_op_r2(r) | (0 << 10) | (32 - (len)))
 521
 522 /* shift is a register */
 523 #define hppa_shl(p, r, shift, t)                        \
 524         do {                                            \
 525                 hppa_subi(p, 31, shift, t);             \
 526                 hppa_mtsar(p, t);                       \
 527                 hppa_zvdep(p, r, 32, t);                \
 528         } while (0)
 529
 530 #define hppa_zdep(p, r, pos, len, t)                    \
 531         p = hppa_emit (p, hppa_opcode(0x35) | hppa_op_r1(t) | hppa_op_r2(r) | (2 << 10) | ((31 - (pos)) << 5) | (32 - (len)))
 532
 533 #define hppa_zvdepi(p, i, len, t)                       \
 534         p = hppa_emit (p, hppa_opcode(0x35) | hppa_op_r1(t) | (hppa_op_imm5(((int)(i))) << 16) | (4 << 10) | (32 - (len)))
 535
 536 #define hppa_zdepi(p, i, pos, len, t)                   \
 537         p = hppa_emit (p, hppa_opcode(0x35) | hppa_op_r1(t) | (hppa_op_imm5(((int)(i))) << 16) | (6 << 10) | ((31 - (pos)) << 5) | (32 - (len)))
 538
 539 /* FPU insns */
 540 /* These are valid for op == 0x0C only, for op == 0x0E there is an extra bit for
 541  * r and t */
 542 #define hppa_fpu_class0(p, r, sub, fmt, t)              \
 543         p = hppa_emit (p, hppa_opcode(0x0C) | hppa_op_r1(r) | hppa_op_r3(t) | ((sub) << 13) | ((fmt) << 11))
 544
 545 #define hppa_fpu_class1(p, r, sub, df, sf, t)           \
 546         p = hppa_emit (p, hppa_opcode(0x0C) | hppa_op_r1(r) | hppa_op_r3(t) | ((sub) << 15) | ((df) << 13) | ((sf) << 11) | (1 << 9))
 547
 548 #define hppa_fpu_class2(p, r1, r2, sub, fmt, n, cond)   \
 549         p = hppa_emit (p, hppa_opcode(0x0C) | hppa_op_r1(r1) | hppa_op_r2(r2) | hppa_op_r3(cond) | ((sub) << 13) | ((fmt) << 11) | (2 << 9) | ((n) << 5))
 550
 551 #define hppa_fpu_class3(p, r1, r2, sub, fmt, t)         \
 552         p = hppa_emit (p, hppa_opcode(0x0C) | hppa_op_r1(r1) | hppa_op_r2(r2) | hppa_op_r3(t) | ((sub) << 13) | ((fmt) << 11) | (3 << 9))
 553
 554 #define HPPA_FP_FMT_SGL 0
 555 #define HPPA_FP_FMT_DBL 1
 556 #define HPPA_FP_FMT_QUAD 3
 557
 558 #define hppa_fcpy(p, fmt, r, t) hppa_fpu_class0(p, r, 2, fmt, t)
 559 #define hppa_fabs(p, fmt, r, t) hppa_fpu_class0(p, r, 3, fmt, t)
 560 #define hppa_fsqrt(p, fmt, r, t) hppa_fpu_class0(p, r, 4, fmt, t)
 561 #define hppa_frnd(p, fmt, r, t) hppa_fpu_class0(p, r, 5, fmt, t)
 562
 563 #define hppa_fcnvff(p, sf, df, r, t) hppa_fpu_class1(p, r, 0, df, sf, t)
 564 #define hppa_fcnvxf(p, sf, df, r, t) hppa_fpu_class1(p, r, 1, df, sf, t)
 565 #define hppa_fcnvfx(p, sf, df, r, t) hppa_fpu_class1(p, r, 2, df, sf, t)
 566 #define hppa_fcnvfxt(p, sf, df, r, t) hppa_fpu_class1(p, r, 3, df, sf, t)
 567
 568 #define hppa_fcmp(p, fmt, cond, r1, r2) hppa_fpu_class2(p, r1, r2, 0, fmt, 0, cond)
 569 #define hppa_ftest(p, cond) hppa_fpu_class2(p, 0, 0, 1, 0, 1, cond)
 570
 571 #define hppa_fadd(p, fmt, r1, r2, t) hppa_fpu_class3(p, r1, r2, 0, fmt, t)
 572 #define hppa_fsub(p, fmt, r1, r2, t) hppa_fpu_class3(p, r1, r2, 1, fmt, t)
 573 #define hppa_fmul(p, fmt, r1, r2, t) hppa_fpu_class3(p, r1, r2, 2, fmt, t)
 574 #define hppa_fdiv(p, fmt, r1, r2, t) hppa_fpu_class3(p, r1, r2, 3, fmt, t)
 575
 576 /* Note: fmpyadd and fmpysub have different fmt encodings as the other
 577  * FP ops
 578  */
 579 #define hppa_fmpyadd(p, fmt, rm1, rm2, tm, ra, ta)      \
 580         p = hppa_emit (p, hppa_opcode(0x06) | hppa_op_r1(rm1) | hppa_op_r2(rm2) | hppa_op_r3(tm) | ((ta) << 11) | ((ra) << 6) | ((fmt) << 5))
 581
 582 #define hppa_fmpyadd_sgl(p, rm1, rm2, tm, ra, ta)       \
 583         hppa_fmpyadd(p, 1, rm1, rm2, tm, ra, ta)
 584
 585 #define hppa_fmpyadd_dbl(p, rm1, rm2, tm, ra, ta)       \
 586         hppa_fmpyadd(p, 0, rm1, rm2, tm, ra, ta)
 587
 588 #define hppa_fmpysub(p, fmt, rm1, rm2, tm, ra, ta)      \
 589         p = hppa_emit (p, hppa_opcode(0x06) | hppa_op_r1(rm1) | hppa_op_r2(rm2) | hppa_op_r3(tm) | ((ta) << 11) | ((ra) << 6) | ((fmt) << 5))
 590
 591 #define hppa_fmpysub_sgl(p, rm1, rm2, tm, ra, ta)       \
 592         hppa_fmpysub(p, 1, rm1, rm2, tm, ra, ta)
 593
 594 #define hppa_fmpysub_dbl(p, rm1, rm2, tm, ra, ta)       \
 595         hppa_fmpysub(p, 0, rm1, rm2, tm, ra, ta)
 596
 597 #define hppa_xmpyu(p, r1, r2, t)                        \
 598         p = hppa_emit (p, hppa_opcode(0x0E) | hppa_op_r1(r1) | hppa_op_r2(r2) | hppa_op_r3(t) | (2 << 13) | (3 << 9) | (1 << 8))
 599
 600 #define hppa_fldwx(p, x, b, t, half)                    \
 601         p = hppa_emit (p, hppa_opcode(0x09) | hppa_op_r1(b) | hppa_op_r2(x) | hppa_op_r3(t) | ((half) << 6))
 602
 603 #define hppa_flddx(p, x, b, t)                          \
 604         p = hppa_emit (p, hppa_opcode(0x0B) | hppa_op_r1(b) | hppa_op_r2(x) | hppa_op_r3(t))
 605
 606 #define hppa_fstwx(p, r, half, x, b)                    \
 607         p = hppa_emit (p, hppa_opcode(0x09) | hppa_op_r1(b) | hppa_op_r2(x) | hppa_op_r3(r) | ((half) << 6) | (1 << 9))
 608
 609 #define hppa_fstdx(p, r, x, b)                          \
 610         p = hppa_emit (p, hppa_opcode(0x0B) | hppa_op_r1(b) | hppa_op_r2(x) | hppa_op_r3(r) | (1 << 9))
 611
 612 #define hppa_fldws(p, d, b, t, half)                    \
 613         p = hppa_emit (p, hppa_opcode(0x09) | hppa_op_r1(b) | (hppa_op_imm5(((int)(d))) << 16) | hppa_op_r3(t) | ((half) << 6) | (1 << 12))
 614
 615 #define hppa_fldds(p, d, b, t)                          \
 616         p = hppa_emit (p, hppa_opcode(0x0B) | hppa_op_r1(b) | (hppa_op_imm5(((int)(d))) << 16) | hppa_op_r3(t) | (1 << 12))
 617
 618 #define hppa_fstws(p, r, half, d, b)                    \
 619         p = hppa_emit (p, hppa_opcode(0x09) | hppa_op_r1(b) | (hppa_op_imm5(((int)(d))) << 16) | hppa_op_r3(r) | ((half) << 6) | (1 << 12) | (1 << 9))
 620
 621 #define hppa_fstds(p, r, d, b)                          \
 622         p = hppa_emit (p, hppa_opcode(0x0B) | hppa_op_r1(b) | (hppa_op_imm5(((int)(d))) << 16) | hppa_op_r3(r) | (1 << 12) | (1 << 9))
 623
 624
 625 /* Not yet converted old macros - used by interpreter */
 626 #define hppa_ldd_with_flags(p, disp, base, dest, m, a)  \
 627         do {                                            \
 628                 unsigned int *c = (unsigned int *)(p);  \
 629                 int neg = (disp) < 0;                   \
 630                 int im10a = (disp) >> 3;                \
 631                 g_assert(((disp) & 7) == 0);            \
 632                 *c++ = (0x50000000 | (((im10a) & 0x3ff) << 4) | ((base) << 21) | ((dest) << 16) | neg | (m ? 0x8 : 0) | (a ? 0x4 : 0)); \
 633                 p = (void *)c;                          \
 634         } while (0)
 635
 636 #define hppa_ldd(p, disp, base, dest) \
 637         hppa_ldd_with_flags(p, disp, base, dest, 0, 0)
 638
 639 #define hppa_ldd_mb(p, disp, base, dest) \
 640         hppa_ldd_with_flags(p, disp, base, dest, 1, 1)
 641
 642 #define hppa_std_with_flags(p, src, disp, base, m, a)   \
 643         do {                                            \
 644                 unsigned int *c = (unsigned int *)(p);  \
 645                 int neg = (disp) < 0;                   \
 646                 int im10a = (disp) >> 3;                \
 647                 g_assert(((disp) & 7) == 0);            \
 648                 *c++ = (0x70000000 | (((im10a) & 0x3ff) << 4) | ((base) << 21) | ((src) << 16) | neg | (m ? 0x8 : 0) | (a ? 0x4 : 0)); \
 649                 p = (void *)c;                          \
 650         } while (0)
 651
 652 #define hppa_std(p, disp, base, dest) \
 653         hppa_std_with_flags(p, disp, base, dest, 0, 0)
 654
 655 #define hppa_std_ma(p, disp, base, dest) \
 656         hppa_std_with_flags(p, disp, base, dest, 1, 0)
 657
 658 #define hppa_fldd_with_flags(p, disp, base, dest, m, a) \
 659         do {                                            \
 660                 unsigned int *c = (unsigned int *)(p);  \
 661                 int neg = (disp) < 0;                   \
 662                 int im10a = (disp) >> 3;                \
 663                 *c++ = (0x50000002 | (((im10a) & 0x3ff) << 4) | ((base) << 21) | ((dest) << 16) | neg | (m ? 0x8 : 0) | (a ? 0x4 : 0)); \
 664                 p = (void *)c;                          \
 665         } while (0)
 666
 667 #define hppa_fldd(p, disp, base, dest) \
 668         hppa_fldd_with_flags(p, disp, base, dest, 0, 0)
 669
 670 #define hppa_fstd_with_flags(p, src, disp, base, m, a)  \
 671         do {                                            \
 672                 unsigned int *c = (unsigned int *)(p);  \
 673                 int neg = (disp) < 0;                   \
 674                 int im10a = (disp) >> 3;                \
 675                 *c++ = (0x70000002 | (((im10a) & 0x3ff) << 4) | ((base) << 21) | ((src) << 16) | neg | (m ? 0x8 : 0) | (a ? 0x4 : 0)); \
 676                 p = (void *)c;                          \
 677         } while (0)
 678
 679 #define hppa_fstd(p, disp, base, dest) \
 680         hppa_fstd_with_flags(p, disp, base, dest, 0, 0)
 681
 682
 683 #define hppa_fldw_with_flags(p, im11a, base, dest, r)   \
 684         do {                                            \
 685                 unsigned int *c = (unsigned int *)(p);  \
 686                 int neg = (disp) < 0;                   \
 687                 int im11a = (disp) >> 2;                \
 688                 *c++ = (0x5c000000 | (((im11a) & 0x7ff) << 3) | ((base) << 21) | ((dest) << 16) | neg | ((r) ? 0x2 : 0)); \
 689                 p = (void *)c;                          \
 690         } while (0)
 691
 692 #define hppa_fldw(p, disp, base, dest) \
 693         hppa_fldw_with_flags(p, disp, base, dest, 1)
 694
 695 #define hppa_fstw_with_flags(p, src, disp, base, r)     \
 696         do {                                            \
 697                 unsigned int *c = (unsigned int *)(p);  \
 698                 int neg = (disp) < 0;                   \
 699                 int im11a = (disp) >> 2;                \
 700                 *c++ = (0x7c000000 | (((im11a) & 0x7ff) << 3) | ((base) << 21) | ((src) << 16) | neg | ((r) ? 0x2 : 0)); \
 701                 p = (void *)c;                          \
 702         } while (0)
 703
 704 #define hppa_fstw(p, src, disp, base) \
 705         hppa_fstw_with_flags(p, src, disp, base, 1)
 706
 707 /* only works on right half SP registers */
 708 #define hppa_fcnv(p, src, ssng, dest, dsng)             \
 709         do {                                            \
 710                 unsigned int *c = (unsigned int *)(p);  \
 711                 *c++ = (0x38000200 | ((src) << 21) | ((ssng) ? 0x80 : 0x800) | (dest) | ((dsng) ? 0x40 : 0x2000)); \
 712                 p = (void *)c;                          \
 713         } while (0)
 714
 715 #define hppa_fcnv_sng_dbl(p, src, dest) \
 716         hppa_fcnv(p, src, 1, dest, 0)
 717
 718 #define hppa_fcnv_dbl_sng(p, src, dest) \
 719         hppa_fcnv(p, src, 0, dest, 1)
 720
 721 #define hppa_extrdu(p, src, pos, len, dest)             \
 722         do {                                            \
 723                 unsigned int *c = (unsigned int *)(p);  \
 724                 *c++ = (0xd8000000 | ((src) << 21) | ((dest) << 16) | ((pos) > 32 ? 0x800 : 0) | (((pos) & 31) << 5) | ((len) > 32 ? 0x1000 : 0) | (32 - (len & 31))); \
 725                 p = (void *)c;                          \
 726         } while (0)
 727
 728 #define hppa_bve(p, reg, link) \
 729         do { \
 730                 *(p) = (0xE8001000 | ((link ? 7 : 6) << 13) | ((reg) << 21)); \
 731                 p++; \
 732         } while (0)
 733
 734 #define hppa_blve(p, reg) \
 735         hppa_bve(p, reg, 1)
 736
 737 #endif