c1-arm64.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 OP_SIZE_NATIVE                  OP_SIZE_8
  20 #define OP_SIZE_ADDRESS                 OP_SIZE_8
  21
  22 #define JMP_LIMIT                       JMP_LONG
  23
  24 #define UNALIGNED_TRAP                  0
  25
  26 #define ALU_WRITES_FLAGS(alu, im)       0
  27 #define ALU1_WRITES_FLAGS(alu)          0
  28 #define ROT_WRITES_FLAGS(alu, size, im) 0
  29 #define COND_IS_LOGICAL(cond)           0
  30
  31 #define ARCH_PARTIAL_ALU(size)          0
  32 #define ARCH_IS_3ADDRESS(alu, f)        1
  33 #define ARCH_IS_3ADDRESS_IMM(alu, f)    1
  34 #define ARCH_IS_3ADDRESS_ROT(alu, size) 1
  35 #define ARCH_IS_3ADDRESS_ROT_IMM(alu)   1
  36 #define ARCH_IS_2ADDRESS(alu)           1
  37 #define ARCH_IS_3ADDRESS_FP             1
  38 #define ARCH_HAS_JMP_2REGS(cond)        0
  39 #define ARCH_HAS_FLAGS                  1
  40 #define ARCH_PREFERS_SX(size)           0
  41 #define ARCH_HAS_BWX                    1
  42 #define ARCH_HAS_MUL                    1
  43 #define ARCH_HAS_DIV                    1
  44 #define ARCH_HAS_ANDN                   1
  45 #define ARCH_HAS_SHIFTED_ADD(bits)      1
  46 #define ARCH_HAS_BTX(btx, size, cnst)   0
  47 #define ARCH_SHIFT_SIZE                 OP_SIZE_4
  48 #define ARCH_BOOL_SIZE                  OP_SIZE_4
  49 #define ARCH_HAS_FP_GP_MOV              1
  50 #define ARCH_NEEDS_BARRIER              0
  51
  52 #define i_size(size)                    maximum(size, OP_SIZE_4)
  53 #define i_size_rot(size)                maximum(size, OP_SIZE_4)
  54 #define i_size_cmp(size)                maximum(size, OP_SIZE_4)
  55
  56 #define R_0             0x00
  57 #define R_1             0x01
  58 #define R_2             0x02
  59 #define R_3             0x03
  60 #define R_4             0x04
  61 #define R_5             0x05
  62 #define R_6             0x06
  63 #define R_7             0x07
  64 #define R_8             0x08
  65 #define R_9             0x09
  66 #define R_10            0x0a
  67 #define R_11            0x0b
  68 #define R_12            0x0c
  69 #define R_13            0x0d
  70 #define R_14            0x0e
  71 #define R_15            0x0f
  72 #define R_16            0x10
  73 #define R_17            0x11
  74 #define R_18            0x12
  75 #define R_19            0x13
  76 #define R_20            0x14
  77 #define R_21            0x15
  78 #define R_22            0x16
  79 #define R_23            0x17
  80 #define R_24            0x18
  81 #define R_25            0x19
  82 #define R_26            0x1a
  83 #define R_27            0x1b
  84 #define R_28            0x1c
  85 #define R_FP            0x1d
  86 #define R_LR            0x1e
  87 #define R_SP            0x1f
  88
  89 #define FR_0            0x20
  90 #define FR_1            0x21
  91 #define FR_2            0x22
  92 #define FR_3            0x23
  93 #define FR_4            0x24
  94 #define FR_5            0x25
  95 #define FR_6            0x26
  96 #define FR_7            0x27
  97 #define FR_8            0x28
  98 #define FR_9            0x29
  99 #define FR_10           0x2a
 100 #define FR_11           0x2b
 101 #define FR_12           0x2c
 102 #define FR_13           0x2d
 103 #define FR_14           0x2e
 104 #define FR_15           0x2f
 105 #define FR_16           0x30
 106 #define FR_17           0x31
 107 #define FR_18           0x32
 108 #define FR_19           0x33
 109 #define FR_20           0x34
 110 #define FR_21           0x35
 111 #define FR_22           0x36
 112 #define FR_23           0x37
 113 #define FR_24           0x38
 114 #define FR_25           0x39
 115 #define FR_26           0x3a
 116 #define FR_27           0x3b
 117 #define FR_28           0x3c
 118 #define FR_29           0x3d
 119 #define FR_30           0x3e
 120 #define FR_31           0x3f
 121
 122 #define FRAME_SIZE      0x60
 123
 124 #define R_FRAME         R_28
 125 #define R_UPCALL        R_27
 126 #define R_TIMESTAMP     R_26
 127 #define R_SAVED_1       R_25
 128 #define R_SAVED_2       R_24
 129 #define R_SAVED_3       R_23
 130 #define R_SAVED_4       R_22
 131 #define R_SAVED_5       R_21
 132 #define R_SAVED_6       R_20
 133 #define R_SAVED_7       R_19
 134
 135 #define R_SCRATCH_1     R_0
 136 #define R_SCRATCH_2     R_1
 137 #define R_SCRATCH_3     R_2
 138 #define R_SCRATCH_4     R_3
 139 #define R_SCRATCH_NA_1  R_8
 140 #define R_SCRATCH_NA_2  R_9
 141 #ifdef HAVE_BITWISE_FRAME
 142 #define R_SCRATCH_NA_3  R_10
 143 #endif
 144 #define R_OFFSET_IMM    R_16
 145 #define R_CONST_IMM     R_17
 146
 147 #define R_ARG0          R_0
 148 #define R_ARG1          R_1
 149 #define R_ARG2          R_2
 150 #define R_ARG3          R_3
 151 #define R_RET0          R_0
 152 #define R_RET1          R_1
 153
 154 #define FR_SCRATCH_1    FR_0
 155 #define FR_SCRATCH_2    FR_1
 156
 157 #define SUPPORTED_FP            0x6
 158 #define SUPPORTED_FP_HALF_CVT   0x1
 159
 160 static bool reg_is_fp(unsigned reg)
 161 {
 162         return reg >= 0x20 && reg < 0x40;
 163 }
 164
 165 static const uint8_t regs_saved[] = { R_SAVED_7, R_SAVED_6, R_SAVED_5, R_SAVED_4, R_SAVED_3 };
 166 static const uint8_t regs_volatile[] = { R_4, R_5, R_6, R_7,
 167 #ifndef HAVE_BITWISE_FRAME
 168         R_10,
 169 #endif
 170         R_11, R_12, R_13, R_14, R_15, R_LR };
 171 static const uint8_t fp_saved[] = { 0 };
 172 #define n_fp_saved 0U
 173 static const uint8_t fp_volatile[] = { FR_2, FR_3, FR_4, FR_5, FR_6, FR_7, FR_16, FR_17, FR_18, FR_19, FR_20, FR_21, FR_22, FR_23, FR_24, FR_25, FR_26, FR_27, FR_28, FR_29, FR_30, FR_31 };
 174 #define reg_is_saved(r) ((r) >= R_19 && (r) <= R_FP)
 175
 176 struct logical_imm {
 177         uint64_t value;
 178         uint16_t code;
 179 };
 180
 181 static const struct logical_imm value_to_code_4_table[] = {
 182 #include "arm64-w.inc"
 183 };
 184
 185 static const struct logical_imm value_to_code_8_table[] = {
 186 #include "arm64-x.inc"
 187 };
 188
 189 static int16_t value_to_code(uint8_t size, uint64_t value)
 190 {
 191         size_t result;
 192         if (size == OP_SIZE_4) {
 193                 binary_search(size_t, n_array_elements(value_to_code_4_table), result, value_to_code_4_table[result].value == value, value_to_code_4_table[result].value < value, return -1);
 194                 return value_to_code_4_table[result].code;
 195         } else {
 196                 binary_search(size_t, n_array_elements(value_to_code_8_table), result, value_to_code_8_table[result].value == value, value_to_code_8_table[result].value < value, return -1);
 197                 return value_to_code_8_table[result].code;
 198         }
 199 }
 200
 201 static bool attr_w gen_load_constant(struct codegen_context *ctx, unsigned reg, uint64_t c)
 202 {
 203         int16_t code;
 204
 205         if (c < 0x10000)
 206                 goto skip_lookup;
 207
 208         code = value_to_code(OP_SIZE_4, c);
 209         if (code >= 0) {
 210                 gen_insn(INSN_ALU, OP_SIZE_4, ALU_OR, 0);
 211                 gen_one(reg);
 212                 gen_one(0x1f);
 213                 gen_one(ARG_IMM);
 214                 gen_eight(c);
 215                 return true;
 216         }
 217
 218         code = value_to_code(OP_SIZE_8, c);
 219         if (code >= 0) {
 220                 gen_insn(INSN_ALU, OP_SIZE_8, ALU_OR, 0);
 221                 gen_one(reg);
 222                 gen_one(0x1f);
 223                 gen_one(ARG_IMM);
 224                 gen_eight(c);
 225                 return true;
 226         }
 227
 228 skip_lookup:
 229         if ((int64_t)c < 0) {
 230                 gen_insn(INSN_MOV, OP_SIZE_8, 0, 0);
 231                 gen_one(reg);
 232                 gen_one(ARG_IMM);
 233                 gen_eight((c & 0xffff) | 0xffffffffffff0000ULL);
 234                 if ((c & 0xffff0000ULL) != 0xffff0000ULL) {
 235                         gen_insn(INSN_MOV_MASK, OP_SIZE_8, MOV_MASK_16_32, 0);
 236                         gen_one(reg);
 237                         gen_one(reg);
 238                         gen_one(ARG_IMM);
 239                         gen_eight((c >> 16) & 0xffff);
 240                 }
 241                 if ((c & 0xffff00000000ULL) != 0xffff00000000ULL) {
 242                         gen_insn(INSN_MOV_MASK, OP_SIZE_8, MOV_MASK_32_48, 0);
 243                         gen_one(reg);
 244                         gen_one(reg);
 245                         gen_one(ARG_IMM);
 246                         gen_eight((c >> 32) & 0xffff);
 247                 }
 248                 if ((c & 0xffff000000000000ULL) != 0xffff000000000000ULL) {
 249                         gen_insn(INSN_MOV_MASK, OP_SIZE_8, MOV_MASK_48_64, 0);
 250                         gen_one(reg);
 251                         gen_one(reg);
 252                         gen_one(ARG_IMM);
 253                         gen_eight((c >> 48) & 0xffff);
 254                 }
 255         } else {
 256                 gen_insn(INSN_MOV, OP_SIZE_8, 0, 0);
 257                 gen_one(reg);
 258                 gen_one(ARG_IMM);
 259                 gen_eight(c & 0xffff);
 260                 if (c & 0xffff0000ULL) {
 261                         gen_insn(INSN_MOV_MASK, OP_SIZE_8, MOV_MASK_16_32, 0);
 262                         gen_one(reg);
 263                         gen_one(reg);
 264                         gen_one(ARG_IMM);
 265                         gen_eight((c >> 16) & 0xffff);
 266                 }
 267                 if (c & 0xffff00000000ULL) {
 268                         gen_insn(INSN_MOV_MASK, OP_SIZE_8, MOV_MASK_32_48, 0);
 269                         gen_one(reg);
 270                         gen_one(reg);
 271                         gen_one(ARG_IMM);
 272                         gen_eight((c >> 32) & 0xffff);
 273                 }
 274                 if (c & 0xffff000000000000ULL) {
 275                         gen_insn(INSN_MOV_MASK, OP_SIZE_8, MOV_MASK_48_64, 0);
 276                         gen_one(reg);
 277                         gen_one(reg);
 278                         gen_one(ARG_IMM);
 279                         gen_eight((c >> 48) & 0xffff);
 280                 }
 281         }
 282         return true;
 283 }
 284
 285 static bool attr_w gen_address(struct codegen_context *ctx, unsigned base, int64_t imm, unsigned purpose, unsigned size)
 286 {
 287         ctx->base_reg = base;
 288         ctx->offset_imm = imm;
 289         ctx->offset_reg = false;
 290         switch (purpose) {
 291                 case IMM_PURPOSE_LDR_OFFSET:
 292                 case IMM_PURPOSE_LDR_SX_OFFSET:
 293                 case IMM_PURPOSE_STR_OFFSET:
 294                 case IMM_PURPOSE_VLDR_VSTR_OFFSET:
 295                 case IMM_PURPOSE_MVI_CLI_OFFSET:
 296                         if (likely(imm >= -256) && likely(imm <= 255))
 297                                 return true;
 298                         if (likely(imm >= 0)) {
 299                                 if (unlikely((imm & ((1 << size) - 1)) != 0))
 300                                         break;
 301                                 if (likely((imm >> size) <= 4095))
 302                                         return true;
 303                         }
 304                         break;
 305                 case IMM_PURPOSE_LDP_STP_OFFSET:
 306                         if (unlikely((imm & ((1 << size) - 1)) != 0))
 307                                 break;
 308                         if (imm / (1 << size) >= -64 && imm / (1 << size) <= 63)
 309                                 return true;
 310                         break;
 311                 default:
 312                         internal(file_line, "gen_address: invalid purpose %d", purpose);
 313         }
 314         g(gen_load_constant(ctx, R_OFFSET_IMM, imm));
 315         if (purpose == IMM_PURPOSE_LDP_STP_OFFSET) {
 316                 gen_insn(INSN_ALU, OP_SIZE_ADDRESS, ALU_ADD, 0);
 317                 gen_one(R_OFFSET_IMM);
 318                 gen_one(R_OFFSET_IMM);
 319                 gen_one(base);
 320                 ctx->base_reg = R_OFFSET_IMM;
 321                 ctx->offset_imm = 0;
 322                 return true;
 323         }
 324         ctx->offset_reg = true;
 325         return true;
 326
 327 }
 328
 329 static bool is_direct_const(int64_t imm, unsigned purpose, unsigned size)
 330 {
 331         switch (purpose) {
 332                 case IMM_PURPOSE_STORE_VALUE:
 333                         if (!imm)
 334                                 return true;
 335                         break;
 336                 case IMM_PURPOSE_ADD:
 337                 case IMM_PURPOSE_SUB:
 338                 case IMM_PURPOSE_CMP:
 339                 case IMM_PURPOSE_CMP_LOGICAL:
 340                         if (imm >= 0 && imm < 4096)
 341                                 return true;
 342                         break;
 343                 case IMM_PURPOSE_AND:
 344                 case IMM_PURPOSE_OR:
 345                 case IMM_PURPOSE_XOR:
 346                 case IMM_PURPOSE_ANDN:
 347                 case IMM_PURPOSE_TEST:
 348                         if (value_to_code(size, imm) >= 0)
 349                                 return true;
 350                         break;
 351                 case IMM_PURPOSE_MUL:
 352                         break;
 353                 default:
 354                         internal(file_line, "is_direct_const: invalid purpose %u (imm %"PRIxMAX", size %u)", purpose, (uintmax_t)imm, size);
 355         }
 356         return false;
 357 }
 358
 359 static bool attr_w gen_imm(struct codegen_context *ctx, int64_t imm, unsigned purpose, unsigned size)
 360 {
 361         if (is_direct_const(imm, purpose, size)) {
 362                 ctx->const_imm = imm;
 363                 ctx->const_reg = false;
 364         } else {
 365                 g(gen_load_constant(ctx, R_CONST_IMM, imm));
 366                 ctx->const_reg = true;
 367         }
 368         return true;
 369 }
 370
 371 static bool attr_w gen_entry(struct codegen_context *ctx)
 372 {
 373         gen_insn(INSN_STP, OP_SIZE_8, 0, 0);
 374         gen_one(ARG_ADDRESS_1_PRE_I);
 375         gen_one(R_SP);
 376         gen_eight(-FRAME_SIZE);
 377         gen_one(R_FP);
 378         gen_one(R_LR);
 379
 380         gen_insn(INSN_MOV, OP_SIZE_8, 0, 0);
 381         gen_one(R_FP);
 382         gen_one(R_SP);
 383
 384         gen_insn(INSN_STP, OP_SIZE_8, 0, 0);
 385         gen_one(ARG_ADDRESS_1);
 386         gen_one(R_SP);
 387         gen_eight(0x10);
 388         gen_one(R_UPCALL);
 389         gen_one(R_FRAME);
 390
 391         gen_insn(INSN_STP, OP_SIZE_8, 0, 0);
 392         gen_one(ARG_ADDRESS_1);
 393         gen_one(R_SP);
 394         gen_eight(0x20);
 395         gen_one(R_SAVED_1);
 396         gen_one(R_TIMESTAMP);
 397
 398         gen_insn(INSN_STP, OP_SIZE_8, 0, 0);
 399         gen_one(ARG_ADDRESS_1);
 400         gen_one(R_SP);
 401         gen_eight(0x30);
 402         gen_one(R_SAVED_3);
 403         gen_one(R_SAVED_2);
 404
 405         gen_insn(INSN_STP, OP_SIZE_8, 0, 0);
 406         gen_one(ARG_ADDRESS_1);
 407         gen_one(R_SP);
 408         gen_eight(0x40);
 409         gen_one(R_SAVED_5);
 410         gen_one(R_SAVED_4);
 411
 412         gen_insn(INSN_STP, OP_SIZE_8, 0, 0);
 413         gen_one(ARG_ADDRESS_1);
 414         gen_one(R_SP);
 415         gen_eight(0x50);
 416         gen_one(R_SAVED_7);
 417         gen_one(R_SAVED_6);
 418
 419         gen_insn(INSN_MOV, OP_SIZE_8, 0, 0);
 420         gen_one(R_FRAME);
 421         gen_one(R_ARG0);
 422
 423         gen_insn(INSN_MOV, OP_SIZE_8, 0, 0);
 424         gen_one(R_UPCALL);
 425         gen_one(R_ARG1);
 426
 427         gen_insn(INSN_MOV, OP_SIZE_8, 0, 0);
 428         gen_one(R_TIMESTAMP);
 429         gen_one(R_ARG2);
 430
 431         gen_insn(INSN_JMP_INDIRECT, 0, 0, 0);
 432         gen_one(R_ARG3);
 433
 434         return true;
 435 }
 436
 437 static bool attr_w gen_escape_arg(struct codegen_context *ctx, ip_t ip, uint32_t escape_label)
 438 {
 439         g(gen_load_constant(ctx, R_RET1, ip));
 440
 441         gen_insn(INSN_JMP, 0, 0, 0);
 442         gen_four(escape_label);
 443
 444         return true;
 445 }
 446
 447 static bool attr_w gen_escape(struct codegen_context *ctx)
 448 {
 449         gen_insn(INSN_MOV, OP_SIZE_8, 0, 0);
 450         gen_one(R_RET0);
 451         gen_one(R_FRAME);
 452
 453         gen_insn(INSN_LDP, OP_SIZE_8, 0, 0);
 454         gen_one(R_SAVED_7);
 455         gen_one(R_SAVED_6);
 456         gen_one(ARG_ADDRESS_1);
 457         gen_one(R_SP);
 458         gen_eight(0x50);
 459
 460         gen_insn(INSN_LDP, OP_SIZE_8, 0, 0);
 461         gen_one(R_SAVED_5);
 462         gen_one(R_SAVED_4);
 463         gen_one(ARG_ADDRESS_1);
 464         gen_one(R_SP);
 465         gen_eight(0x40);
 466
 467         gen_insn(INSN_LDP, OP_SIZE_8, 0, 0);
 468         gen_one(R_SAVED_3);
 469         gen_one(R_SAVED_2);
 470         gen_one(ARG_ADDRESS_1);
 471         gen_one(R_SP);
 472         gen_eight(0x30);
 473
 474         gen_insn(INSN_LDP, OP_SIZE_8, 0, 0);
 475         gen_one(R_SAVED_1);
 476         gen_one(R_TIMESTAMP);
 477         gen_one(ARG_ADDRESS_1);
 478         gen_one(R_SP);
 479         gen_eight(0x20);
 480
 481         gen_insn(INSN_LDP, OP_SIZE_8, 0, 0);
 482         gen_one(R_UPCALL);
 483         gen_one(R_FRAME);
 484         gen_one(ARG_ADDRESS_1);
 485         gen_one(R_SP);
 486         gen_eight(0x10);
 487
 488         gen_insn(INSN_LDP, OP_SIZE_8, 0, 0);
 489         gen_one(R_FP);
 490         gen_one(R_LR);
 491         gen_one(ARG_ADDRESS_1_POST_I);
 492         gen_one(R_SP);
 493         gen_eight(FRAME_SIZE);
 494
 495         gen_insn(INSN_RET, 0, 0, 0);
 496
 497         return true;
 498 }
 499
 500 static bool attr_w gen_upcall_argument(struct codegen_context attr_unused *ctx, unsigned attr_unused arg)
 501 {
 502         return true;
 503 }
 504
 505 static bool attr_w gen_get_upcall_pointer(struct codegen_context *ctx, unsigned offset, unsigned reg)
 506 {
 507         g(gen_address(ctx, R_UPCALL, offset, IMM_PURPOSE_LDR_OFFSET, OP_SIZE_8));
 508         gen_insn(INSN_MOV, OP_SIZE_8, 0, 0);
 509         gen_one(reg);
 510         gen_address_offset();
 511
 512         return true;
 513 }
 514
 515 static bool attr_w gen_upcall(struct codegen_context *ctx, unsigned offset, unsigned n_args)
 516 {
 517         g(gen_get_upcall_pointer(ctx, offset, R_SCRATCH_NA_1));
 518
 519         gen_insn(INSN_CALL_INDIRECT, OP_SIZE_8, 0, 0);
 520         gen_one(R_SCRATCH_NA_1);
 521
 522         g(gen_upcall_end(ctx, n_args));
 523
 524         return true;
 525 }
 526
 527 static bool attr_w gen_timestamp_test(struct codegen_context *ctx, uint32_t escape_label)
 528 {
 529         g(gen_address(ctx, R_UPCALL, offsetof(struct cg_upcall_vector_s, ts), IMM_PURPOSE_LDR_OFFSET, OP_SIZE_4));
 530         gen_insn(INSN_MOV, OP_SIZE_4, 0, 0);
 531         gen_one(R_SCRATCH_1);
 532         gen_address_offset();
 533
 534         gen_insn(INSN_CMP, OP_SIZE_4, 0, 1);
 535         gen_one(R_SCRATCH_1);
 536         gen_one(R_TIMESTAMP);
 537
 538         gen_insn(INSN_JMP_COND, OP_SIZE_4, COND_NE, 0);
 539         gen_four(escape_label);
 540
 541         return true;
 542 }