c1-hppa.inc

   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  */
  18
  19 #define PA_20                           cpu_test_feature(CPU_FEATURE_pa20)
  20
  21 #if defined(ARCH_PARISC64)
  22 #define ARCH_PARISC_USE_STUBS
  23 #elif defined(__hpux)
  24 #define ARCH_PARISC_USE_STUBS
  25 #endif
  26
  27 #define OP_SIZE_NATIVE                  (PA_20 ? OP_SIZE_8 : OP_SIZE_4)
  28
  29 #ifdef ARCH_PARISC32
  30 #define OP_SIZE_ADDRESS                 OP_SIZE_4
  31 #else
  32 #define OP_SIZE_ADDRESS                 OP_SIZE_8
  33 #endif
  34
  35 #define JMP_LIMIT                       JMP_EXTRA_LONG
  36
  37 #define UNALIGNED_TRAP                  1
  38
  39 #define ALU_WRITES_FLAGS(alu, im)       (!(im) && ((alu) == ALU_ADC || (alu) == ALU_SUB || (alu) == ALU_SBB) ? 3 : 0)
  40 #define ALU1_WRITES_FLAGS(alu)          ((alu) == ALU1_NEG || (alu) == ALU1_INC || (alu) == ALU1_DEC ? 3 : 0)
  41 #define ROT_WRITES_FLAGS(alu, size, im) 0
  42 #define COND_IS_LOGICAL(cond)           0
  43
  44 #define ARCH_PARTIAL_ALU(size)          0
  45 #define ARCH_IS_3ADDRESS(alu, f)        1
  46 #define ARCH_IS_3ADDRESS_IMM(alu, f)    1
  47 #define ARCH_IS_3ADDRESS_ROT(alu, size) 1
  48 #define ARCH_IS_3ADDRESS_ROT_IMM(alu)   1
  49 #define ARCH_IS_2ADDRESS(alu)           1
  50 #define ARCH_IS_3ADDRESS_FP             1
  51 #define ARCH_HAS_JMP_2REGS(cond)        1
  52 #define ARCH_HAS_FLAGS                  0
  53 #define ARCH_SUPPORTS_TRAPS             1
  54 #define ARCH_TRAP_BEFORE                0
  55 #define ARCH_PREFERS_SX(size)           0
  56 #define ARCH_HAS_BWX                    1
  57 #define ARCH_HAS_MUL                    0
  58 #define ARCH_HAS_DIV                    0
  59 #define ARCH_HAS_ANDN                   1
  60 #define ARCH_HAS_SHIFTED_ADD(bits)      ((bits) <= 3)
  61 #define ARCH_HAS_BTX(btx, size, cnst)   (((btx) == BTX_BTS || (btx) == BTX_BTR || (btx) == BTX_BTEXT) && (((size) >= OP_SIZE_4)))
  62 #define ARCH_SHIFT_SIZE                 OP_SIZE_4
  63 #define ARCH_BOOL_SIZE                  OP_SIZE_NATIVE
  64 #define ARCH_HAS_FP_GP_MOV              0
  65 #define ARCH_NEEDS_BARRIER              0
  66
  67 #define i_size(size)                    OP_SIZE_NATIVE
  68 #define i_size_rot(size)                maximum(size, OP_SIZE_4)
  69 #define i_size_cmp(size)                maximum(size, OP_SIZE_4)
  70
  71 #define R_ZERO          0x00
  72 #define R_1             0x01
  73 #define R_RP            0x02
  74 #define R_3             0x03
  75 #define R_4             0x04
  76 #define R_5             0x05
  77 #define R_6             0x06
  78 #define R_7             0x07
  79 #define R_8             0x08
  80 #define R_9             0x09
  81 #define R_10            0x0a
  82 #define R_11            0x0b
  83 #define R_12            0x0c
  84 #define R_13            0x0d
  85 #define R_14            0x0e
  86 #define R_15            0x0f
  87 #define R_16            0x10
  88 #define R_17            0x11
  89 #define R_18            0x12
  90 #define R_19            0x13
  91 #define R_20            0x14
  92 #define R_21            0x15
  93 #define R_22            0x16
  94 #define R_23            0x17
  95 #define R_24            0x18
  96 #define R_25            0x19
  97 #define R_26            0x1a
  98 #define R_DP            0x1b
  99 #define R_RET0          0x1c
 100 #define R_RET1          0x1d
 101 #define R_SP            0x1e
 102 #define R_31            0x1f
 103
 104 #define R_FSTATUS       0x20
 105 #define R_F4            0x24
 106 #define R_F5            0x25
 107 #define R_F6            0x26
 108 #define R_F7            0x27
 109 #define R_F8            0x28
 110 #define R_F9            0x29
 111 #define R_F10           0x2a
 112 #define R_F11           0x2b
 113 #define R_F12           0x2c
 114 #define R_F13           0x2d
 115 #define R_F14           0x2e
 116 #define R_F15           0x2f
 117 #define R_F16           0x30
 118 #define R_F17           0x31
 119 #define R_F18           0x32
 120 #define R_F19           0x33
 121 #define R_F20           0x34
 122 #define R_F21           0x35
 123 #define R_F22           0x36
 124 #define R_F23           0x37
 125 #define R_F24           0x38
 126 #define R_F25           0x39
 127 #define R_F26           0x3a
 128 #define R_F27           0x3b
 129 #define R_F28           0x3c
 130 #define R_F29           0x3d
 131 #define R_F30           0x3e
 132 #define R_F31           0x3f
 133
 134 #define R_FRAME         R_3
 135 #define R_UPCALL        R_4
 136 #define R_TIMESTAMP     R_5
 137
 138 #define R_SCRATCH_1     R_26
 139 #define R_SCRATCH_2     R_25
 140 #define R_SCRATCH_3     R_24
 141 #define R_SCRATCH_4     R_SAVED_2
 142
 143 #define R_SCRATCH_NA_1  R_22
 144 #define R_SCRATCH_NA_2  R_21
 145 #ifdef HAVE_BITWISE_FRAME
 146 #define R_SCRATCH_NA_3  R_20
 147 #endif
 148 #define R_CMP_RESULT    R_19
 149
 150 #define R_CG_SCRATCH    R_31
 151
 152 #define R_SAVED_1       R_6
 153 #define R_SAVED_2       R_7
 154
 155 #define R_ARG0          R_26
 156 #define R_ARG1          R_25
 157 #define R_ARG2          R_24
 158 #define R_ARG3          R_23
 159
 160 #define R_CONST_IMM     R_1
 161 #define R_OFFSET_IMM    R_RP
 162
 163 #define FR_SCRATCH_1    R_F4
 164 #define FR_SCRATCH_2    R_F5
 165
 166 #define SUPPORTED_FP    0x6
 167
 168 #ifdef ARCH_PARISC32
 169 #define FRAME_SIZE      0x80
 170 /*
 171  * 0-64         - register save area
 172  * 64-96        - outgoing parameters
 173  * 96-128       - frame marker
 174  */
 175 #else
 176 #define FRAME_SIZE      0xd0
 177 /*
 178  * 0-128        - register save area
 179  * 128-128      - unused
 180  * 128-192      - outgoing parameters
 181  * 192-208      - frame marker
 182  */
 183 #endif
 184
 185 #ifdef ARCH_PARISC32
 186 #define RP_OFFS -0x14
 187 #else
 188 #define RP_OFFS -0x10
 189 #endif
 190
 191 static bool reg_is_fp(unsigned reg)
 192 {
 193         return reg >= R_FSTATUS && reg < R_F31;
 194 }
 195
 196 static const uint8_t regs_saved[] = {
 197 #if !(defined(ARCH_PARISC32) && defined(__HP_cc))
 198         R_8,
 199 #endif
 200         R_9, R_10, R_11, R_12, R_13, R_14, R_15, R_16, R_17, R_18 };
 201 static const uint8_t regs_volatile[] = { R_23, R_RET1,
 202 #if defined(ARCH_PARISC64)
 203         R_DP,
 204 #endif
 205 #ifndef HAVE_BITWISE_FRAME
 206         R_20,
 207 #endif
 208 };
 209 static const uint8_t fp_saved[] = { 0 };
 210 #define n_fp_saved 0U
 211 static const uint8_t fp_volatile[] = { R_F6, R_F7, R_F8, R_F9, R_F10, R_F11, R_F22, R_F23, R_F24, R_F25, R_F26, R_F27, R_F28, R_F29, R_F30, R_F31 };
 212 #define reg_is_saved(r) ((r) >= R_3 && (r) <= R_18)
 213
 214 static bool attr_w gen_load_constant(struct codegen_context *ctx, unsigned reg, uint64_t c)
 215 {
 216         unsigned r = R_ZERO;
 217         int32_t c1, c2, c3, c4;
 218         c1 = c & 0x3fffULL;
 219         if (c1 & 0x2000)
 220                 c1 |= 0xffffc000U;
 221         if (c1 < 0)
 222                 c += 0x4000ULL;
 223         c2 = (c & 0xffffc000ULL) >> 14;
 224         if (c2 & 0x20000)
 225                 c2 |= 0xfffc0000U;
 226         if (c2 < 0)
 227                 c += 0x100000000ULL;
 228         c >>= 32;
 229         c3 = c & 0x3fffULL;
 230         if (c3 & 0x2000)
 231                 c3 |= 0xffffc000U;
 232         if (c3 < 0)
 233                 c += 0x4000ULL;
 234         c4 = (c & 0xffffc000ULL) >> 14;
 235         if (c4 & 0x20000)
 236                 c4 |= 0xfffc0000U;
 237         if (OP_SIZE_NATIVE == OP_SIZE_8) {
 238                 if (c4) {
 239                         gen_insn(INSN_MOV, OP_SIZE_NATIVE, 0, 0);
 240                         gen_one(reg);
 241                         gen_one(ARG_IMM);
 242                         gen_eight((uint64_t)c4 << 14);
 243                         r = reg;
 244                 }
 245                 if (c3) {
 246                         gen_insn(INSN_ALU, OP_SIZE_NATIVE, ALU_ADD, 0);
 247                         gen_one(reg);
 248                         gen_one(r);
 249                         gen_one(ARG_IMM);
 250                         gen_eight(c3);
 251                         r = reg;
 252                 }
 253                 if (r != R_ZERO) {
 254                         gen_insn(INSN_ROT, OP_SIZE_NATIVE, ROT_SHL, 0);
 255                         gen_one(reg);
 256                         gen_one(reg);
 257                         gen_one(ARG_IMM);
 258                         gen_eight(32);
 259                 }
 260         }
 261         if (c2) {
 262                 if (r == R_ZERO) {
 263                         gen_insn(INSN_MOV, OP_SIZE_NATIVE, 0, 0);
 264                         gen_one(reg);
 265                         gen_one(ARG_IMM);
 266                         gen_eight((uint64_t)c2 << 14);
 267                         r = reg;
 268                 } else {
 269                         gen_insn(INSN_ALU, OP_SIZE_NATIVE, ALU_ADD, 0);
 270                         gen_one(R_CONST_IMM);
 271                         gen_one(r);
 272                         gen_one(ARG_IMM);
 273                         gen_eight((uint64_t)c2 << 14);
 274                         r = R_CONST_IMM;
 275                 }
 276         }
 277         if (c1 || r != reg) {
 278                 gen_insn(INSN_ALU, OP_SIZE_NATIVE, ALU_ADD, 0);
 279                 gen_one(reg);
 280                 gen_one(r);
 281                 gen_one(ARG_IMM);
 282                 gen_eight(c1);
 283         }
 284         return true;
 285 }
 286
 287 static bool is_direct_const(int64_t imm, unsigned purpose, unsigned size);
 288
 289 static bool attr_w gen_address(struct codegen_context *ctx, unsigned base, int64_t imm, unsigned purpose, unsigned size)
 290 {
 291         ctx->base_reg = base;
 292         ctx->offset_imm = imm;
 293         ctx->offset_reg = false;
 294         switch (purpose) {
 295                 case IMM_PURPOSE_LDR_OFFSET:
 296                 case IMM_PURPOSE_LDR_SX_OFFSET:
 297                 case IMM_PURPOSE_STR_OFFSET:
 298                 case IMM_PURPOSE_MVI_CLI_OFFSET:
 299                         if (size == OP_SIZE_8) {
 300                                 if (imm & 7)
 301                                         break;
 302                         }
 303                         if (likely(imm >= -0x2000) && likely(imm < 0x2000))
 304                                 return true;
 305                         break;
 306                 case IMM_PURPOSE_VLDR_VSTR_OFFSET:
 307                         if (likely(imm >= -0x10) && likely(imm < 0x10))
 308                                 return true;
 309                         if (!PA_20)
 310                                 break;
 311                         if (unlikely((imm & ((1 << size) - 1)) != 0))
 312                                 break;
 313                         if (likely(imm >= -0x2000) && likely(imm < 0x2000))
 314                                 return true;
 315                         break;
 316                 default:
 317                         internal(file_line, "gen_address: invalid purpose %u (imm %"PRIxMAX", size %u)", purpose, (uintmax_t)imm, size);
 318         }
 319
 320         if (is_direct_const(imm, IMM_PURPOSE_ADD, OP_SIZE_ADDRESS)) {
 321                 gen_insn(INSN_ALU, OP_SIZE_ADDRESS, ALU_ADD, 0);
 322                 gen_one(R_OFFSET_IMM);
 323                 gen_one(base);
 324                 gen_one(ARG_IMM);
 325                 gen_eight(imm);
 326
 327                 ctx->base_reg = R_OFFSET_IMM;
 328                 ctx->offset_imm = 0;
 329
 330                 return true;
 331         }
 332
 333         g(gen_load_constant(ctx, R_OFFSET_IMM, imm));
 334
 335         if (purpose == IMM_PURPOSE_LDR_OFFSET || purpose == IMM_PURPOSE_LDR_SX_OFFSET) {
 336                 ctx->offset_reg = true;
 337                 return true;
 338         }
 339
 340         gen_insn(INSN_ALU, OP_SIZE_ADDRESS, ALU_ADD, 0);
 341         gen_one(R_OFFSET_IMM);
 342         gen_one(R_OFFSET_IMM);
 343         gen_one(base);
 344
 345         ctx->base_reg = R_OFFSET_IMM;
 346         ctx->offset_imm = 0;
 347
 348         return true;
 349 }
 350
 351 static bool is_direct_const(int64_t imm, unsigned purpose, unsigned size)
 352 {
 353         int64_t imm_copy = imm;
 354         switch (purpose) {
 355                 case IMM_PURPOSE_STORE_VALUE:
 356                         if (!imm)
 357                                 return true;
 358                         break;
 359                 case IMM_PURPOSE_SUB:
 360                 case IMM_PURPOSE_SUB_TRAP:
 361                         imm_copy = -(uint64_t)imm_copy;
 362                         /*-fallthrough*/
 363                 case IMM_PURPOSE_ADD:
 364                 case IMM_PURPOSE_CMP:
 365                 case IMM_PURPOSE_CMP_LOGICAL:
 366                 case IMM_PURPOSE_MOVR:
 367                 case IMM_PURPOSE_ADD_TRAP:
 368                         if (likely(imm_copy >= -1024) && likely(imm_copy < 1024))
 369                                 return true;
 370                         break;
 371                 case IMM_PURPOSE_JMP_2REGS:
 372 #ifdef ARCH_PARISC32
 373                         if (likely(imm >= -16) && likely(imm < 16))
 374                                 return true;
 375 #endif
 376                         break;
 377                 case IMM_PURPOSE_AND:
 378                 case IMM_PURPOSE_OR:
 379                 case IMM_PURPOSE_XOR:
 380                 case IMM_PURPOSE_ANDN:
 381                 case IMM_PURPOSE_TEST:
 382                         if (!imm)
 383                                 return true;
 384                         break;
 385                 case IMM_PURPOSE_BITWISE:
 386                         return true;
 387                 default:
 388                         internal(file_line, "is_direct_const: invalid purpose %u (imm %"PRIxMAX", size %u)", purpose, (uintmax_t)imm, size);
 389         }
 390         return false;
 391 }
 392
 393 static bool attr_w gen_imm(struct codegen_context *ctx, int64_t imm, unsigned purpose, unsigned size)
 394 {
 395         if (is_direct_const(imm, purpose, size)) {
 396                 ctx->const_imm = imm;
 397                 ctx->const_reg = false;
 398         } else {
 399                 g(gen_load_constant(ctx, R_CONST_IMM, imm));
 400                 ctx->const_reg = true;
 401         }
 402         return true;
 403 }
 404
 405 static bool attr_w gen_entry(struct codegen_context *ctx)
 406 {
 407         int i;
 408
 409         gen_insn(INSN_MOV, OP_SIZE_ADDRESS, 0, 0);
 410         gen_one(ARG_ADDRESS_1);
 411         gen_one(R_SP);
 412         gen_eight(RP_OFFS);
 413         gen_one(R_RP);
 414
 415         gen_insn(INSN_MOV, OP_SIZE_ADDRESS, 0, 0);
 416         gen_one(ARG_ADDRESS_1_POST_I);
 417         gen_one(R_SP);
 418         gen_eight(FRAME_SIZE);
 419         gen_one(R_3);
 420
 421         for (i = R_4; i <= R_18; i++) {
 422                 int offs = -FRAME_SIZE + ((i - R_3) << OP_SIZE_ADDRESS);
 423                 gen_insn(INSN_MOV, OP_SIZE_ADDRESS, 0, 0);
 424                 gen_one(ARG_ADDRESS_1);
 425                 gen_one(R_SP);
 426                 gen_eight(offs);
 427                 gen_one(i);
 428         }
 429
 430         gen_insn(INSN_MOV, OP_SIZE_NATIVE, 0, 0);
 431         gen_one(R_FRAME);
 432         gen_one(R_ARG0);
 433
 434         gen_insn(INSN_MOV, OP_SIZE_NATIVE, 0, 0);
 435         gen_one(R_UPCALL);
 436         gen_one(R_ARG1);
 437
 438         gen_insn(INSN_MOV, OP_SIZE_NATIVE, 0, 0);
 439         gen_one(R_TIMESTAMP);
 440         gen_one(R_ARG2);
 441
 442         gen_insn(INSN_JMP_INDIRECT, 0, 0, 0);
 443         gen_one(R_ARG3);
 444
 445         return true;
 446 }
 447
 448 static bool attr_w gen_escape_arg(struct codegen_context *ctx, ip_t ip, uint32_t escape_label)
 449 {
 450         g(gen_load_constant(ctx, R_SCRATCH_1, ip));
 451
 452         gen_insn(INSN_JMP, 0, 0, 0);
 453         gen_four(escape_label);
 454
 455         return true;
 456 }
 457
 458 static bool attr_w gen_escape(struct codegen_context *ctx)
 459 {
 460         int i;
 461
 462         gen_insn(INSN_MOV, OP_SIZE_NATIVE, 0, 0);
 463         gen_one(R_RET0);
 464         gen_one(R_FRAME);
 465
 466         gen_insn(INSN_MOV, OP_SIZE_NATIVE, 0, 0);
 467         gen_one(R_RET1);
 468         gen_one(R_SCRATCH_1);
 469
 470         gen_insn(INSN_MOV, OP_SIZE_ADDRESS, 0, 0);
 471         gen_one(R_RP);
 472         gen_one(ARG_ADDRESS_1);
 473         gen_one(R_SP);
 474         gen_eight(-FRAME_SIZE + RP_OFFS);
 475
 476         for (i = R_4; i <= R_18; i++) {
 477                 int offs = -FRAME_SIZE + ((i - R_3) << OP_SIZE_ADDRESS);
 478                 gen_insn(INSN_MOV, OP_SIZE_ADDRESS, 0, 0);
 479                 gen_one(i);
 480                 gen_one(ARG_ADDRESS_1);
 481                 gen_one(R_SP);
 482                 gen_eight(offs);
 483         }
 484
 485         gen_insn(INSN_MOV, OP_SIZE_ADDRESS, 0, 0);
 486         gen_one(R_3);
 487         gen_one(ARG_ADDRESS_1_PRE_I);
 488         gen_one(R_SP);
 489         gen_eight(-FRAME_SIZE);
 490
 491         gen_insn(INSN_RET, 0, 0, 0);
 492
 493         return true;
 494 }
 495
 496 static bool attr_w gen_upcall_argument(struct codegen_context attr_unused *ctx, unsigned attr_unused arg)
 497 {
 498         return true;
 499 }
 500
 501 static bool attr_w gen_get_upcall_pointer(struct codegen_context *ctx, unsigned offset, unsigned reg)
 502 {
 503         g(gen_address(ctx, R_UPCALL, offset, IMM_PURPOSE_LDR_OFFSET, OP_SIZE_NATIVE));
 504         gen_insn(INSN_MOV, OP_SIZE_ADDRESS, 0, 0);
 505         gen_one(reg);
 506         gen_address_offset();
 507
 508         return true;
 509 }
 510
 511 static bool attr_w gen_upcall(struct codegen_context *ctx, unsigned offset, unsigned n_args)
 512 {
 513 #ifdef ARCH_PARISC32
 514         uint32_t label = alloc_call_label(ctx);
 515         if (unlikely(!label))
 516                 return false;
 517
 518         g(gen_get_upcall_pointer(ctx, offset, R_SCRATCH_NA_1));
 519
 520         gen_insn(INSN_CALL, 0, 0, 0);
 521         gen_four(label);
 522 #else
 523         g(gen_get_upcall_pointer(ctx, offset, R_DP));
 524
 525         gen_insn(INSN_CALL_INDIRECT, OP_SIZE_8, 0, 0);
 526         gen_one(R_DP);
 527 #endif
 528         g(gen_upcall_end(ctx, n_args));
 529
 530         return true;
 531 }
 532
 533 static bool attr_w gen_call_millicode(struct codegen_context *ctx)
 534 {
 535         gen_insn(INSN_CALL_MILLICODE, 0, 0, 0);
 536         return true;
 537 }
 538
 539 static bool attr_w gen_cmp_test_jmp(struct codegen_context *ctx, unsigned insn, unsigned op_size, unsigned reg1, unsigned reg2, unsigned cond, uint32_t label);
 540
 541 static bool attr_w gen_timestamp_test(struct codegen_context *ctx, uint32_t escape_label)
 542 {
 543         g(gen_address(ctx, R_UPCALL, offsetof(struct cg_upcall_vector_s, ts), IMM_PURPOSE_LDR_OFFSET, OP_SIZE_NATIVE));
 544         gen_insn(INSN_MOV, OP_SIZE_4, 0, 0);
 545         gen_one(R_SCRATCH_1);
 546         gen_address_offset();
 547
 548         g(gen_cmp_test_jmp(ctx, INSN_CMP, OP_SIZE_4, R_SCRATCH_1, R_TIMESTAMP, COND_NE, escape_label));
 549
 550         return true;
 551 }