c1-s390.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 #ifdef ARCH_S390_64
  20 #define Z                               1
  21 #else
  22 #define Z                               cpu_test_feature(CPU_FEATURE_z)
  23 #endif
  24
  25 #ifdef ARCH_S390_64
  26 #define OP_SIZE_ADDRESS                 OP_SIZE_8
  27 #else
  28 #define OP_SIZE_ADDRESS                 OP_SIZE_4
  29 #endif
  30
  31 #define OP_SIZE_NATIVE                  (Z ? OP_SIZE_8 : OP_SIZE_4)
  32
  33 #define JMP_LIMIT                       JMP_SHORT
  34
  35 #define UNALIGNED_TRAP                  0
  36
  37 #define ALU_WRITES_FLAGS(alu, im)       ((alu) != ALU_MUL)
  38 #define ALU1_WRITES_FLAGS(alu)          1
  39 #define ROT_WRITES_FLAGS(alu, size, im) ((alu) == ROT_SAR || (alu) == ROT_SAL)
  40 #define COND_IS_LOGICAL(cond)           ((cond) == COND_B || (cond) == COND_AE || (cond) == COND_BE || (cond) == COND_A)
  41
  42 #define ARCH_PARTIAL_ALU(size)          ((size) < OP_SIZE_NATIVE)
  43 #define ARCH_IS_3ADDRESS(alu, f)        cpu_test_feature(CPU_FEATURE_misc_45)
  44 #define ARCH_IS_3ADDRESS_IMM(alu, f)    0
  45 #define ARCH_IS_3ADDRESS_ROT(alu, size) cpu_test_feature(CPU_FEATURE_misc_45)
  46 #define ARCH_IS_3ADDRESS_ROT_IMM(alu)   0
  47 #define ARCH_IS_2ADDRESS(alu)           ((alu) != ALU1_INC && (alu) != ALU1_DEC)
  48 #define ARCH_HAS_FLAGS                  1
  49 #define ARCH_PREFERS_SX(size)           1
  50 #define ARCH_HAS_BWX                    1
  51 #define ARCH_HAS_MUL                    1
  52 #define ARCH_HAS_DIV                    1
  53 #define ARCH_HAS_ANDN                   cpu_test_feature(CPU_FEATURE_misc_insn_ext_3)
  54 #define ARCH_HAS_SHIFTED_ADD(bits)      0
  55 #define ARCH_HAS_BTX(btx, size, cnst)   0
  56 #define ARCH_SHIFT_SIZE                 OP_SIZE_8
  57 #define ARCH_NEEDS_BARRIER              0
  58
  59 #define i_size(size)                    maximum(size, OP_SIZE_4)
  60 #define i_size_rot(size)                maximum(size, OP_SIZE_4)
  61
  62 #define R_0             0x00
  63 #define R_1             0x01
  64 #define R_2             0x02
  65 #define R_3             0x03
  66 #define R_4             0x04
  67 #define R_5             0x05
  68 #define R_6             0x06
  69 #define R_7             0x07
  70 #define R_8             0x08
  71 #define R_9             0x09
  72 #define R_10            0x0a
  73 #define R_11            0x0b
  74 #define R_12            0x0c
  75 #define R_13            0x0d
  76 #define R_14            0x0e
  77 #define R_15            0x0f
  78
  79 #define FR_0            0x10
  80 #define FR_1            0x11
  81 #define FR_2            0x12
  82 #define FR_3            0x13
  83 #define FR_4            0x14
  84 #define FR_5            0x15
  85 #define FR_6            0x16
  86 #define FR_7            0x17
  87 #define FR_8            0x18
  88 #define FR_9            0x19
  89 #define FR_10           0x1a
  90 #define FR_11           0x1b
  91 #define FR_12           0x1c
  92 #define FR_13           0x1d
  93 #define FR_14           0x1e
  94 #define FR_15           0x1f
  95
  96 #define R_FRAME         R_12
  97 #define R_UPCALL        R_13
  98
  99 #define R_SP            R_15
 100
 101 #define R_SAVED_1       R_9
 102 #define R_SAVED_2       R_10
 103
 104 #define R_SCRATCH_NA_1  R_1
 105 #ifdef HAVE_BITWISE_FRAME
 106 #define R_SCRATCH_NA_2  R_6
 107 #define R_SCRATCH_NA_3  R_7
 108 #endif
 109 #define R_SCRATCH_1     R_3
 110 #define R_SCRATCH_2     R_2
 111 #define R_SCRATCH_3     R_5
 112 #define R_SCRATCH_4     R_4
 113 #define R_CONST_IMM     (cpu_test_feature(CPU_FEATURE_extended_imm) ? R_0 : R_11)
 114 #define R_OFFSET_IMM    R_14
 115
 116 #define R_ARG0          R_2
 117 #define R_ARG1          R_3
 118 #define R_ARG2          R_4
 119 #define R_ARG3          R_5
 120 #define R_ARG4          R_6
 121 #define R_RET0          R_2
 122
 123 #define FR_SCRATCH_1    FR_0    /* + FR_2 */
 124 #define FR_SCRATCH_2    FR_4    /* + FR_6 */
 125
 126 #define SUPPORTED_FP    0x16
 127
 128 #ifdef ARCH_S390_64
 129 #define FRAME_SIZE      160
 130 #define FRAME_REGS      48
 131 #define FRAME_RETPTR    (FRAME_SIZE + 16)
 132 #define FRAME_TIMESTAMP (FRAME_SIZE + 40)
 133 #else
 134 #define FRAME_SIZE      96
 135 #define FRAME_REGS      24
 136 #define FRAME_FP_REGS   80
 137 #define FRAME_RETPTR    (FRAME_SIZE + 8)
 138 #define FRAME_TIMESTAMP (FRAME_SIZE + 20)
 139 #endif
 140
 141 static bool reg_is_fp(unsigned reg)
 142 {
 143         return reg >= 0x10 && reg < 0x20;
 144 }
 145
 146 static const uint8_t regs_saved[] = {
 147 #ifndef HAVE_BITWISE_FRAME
 148         R_6, R_7,
 149 #endif
 150         R_8, R_11 };
 151 #define n_regs_saved (cpu_test_feature(CPU_FEATURE_extended_imm) ? n_array_elements(regs_saved) : n_array_elements(regs_saved) - 1)
 152 static const uint8_t regs_volatile[] = { 0 };
 153 #define n_regs_volatile 0U
 154 static const uint8_t fp_saved[] = { 0 };
 155 #define n_fp_saved 0U
 156 static const uint8_t fp_volatile[] = { FR_1, FR_3, FR_5, FR_7, FR_2, FR_6 };
 157 #define n_fp_volatile   (!uses_x ? 6U : 4U)
 158 #define reg_is_saved(r) (!reg_is_fp(r))
 159
 160 static bool attr_w gen_load_constant(struct codegen_context *ctx, unsigned reg, uint64_t c)
 161 {
 162         if (OP_SIZE_NATIVE == OP_SIZE_4)
 163                 c = (int32_t)c;
 164         if ((int64_t)c >= -0x8000 && (int64_t)c < 0x8000) {
 165                 gen_insn(INSN_MOV, OP_SIZE_NATIVE, 0, 0);
 166                 gen_one(reg);
 167                 gen_one(ARG_IMM);
 168                 gen_eight(c);
 169                 return true;
 170         }
 171         if (cpu_test_feature(CPU_FEATURE_extended_imm)) {
 172                 bool sign;
 173                 gen_insn(INSN_MOV, OP_SIZE_NATIVE, 0, 0);
 174                 gen_one(reg);
 175                 gen_one(ARG_IMM);
 176                 gen_eight((int32_t)(int64_t)c);
 177                 sign = ((c >> 31) & 1) != 0;
 178                 c >>= 32;
 179                 if (c != (sign ? 0xffffffffU : 0)) {
 180                         gen_insn(INSN_MOV_MASK, OP_SIZE_8, MOV_MASK_32_64, 0);
 181                         gen_one(reg);
 182                         gen_one(reg);
 183                         gen_one(ARG_IMM);
 184                         gen_eight(c);
 185                 }
 186                 return true;
 187         } else {
 188                 gen_insn(INSN_MOV, OP_SIZE_NATIVE, 0, 0);
 189                 gen_one(reg);
 190                 gen_one(ARG_IMM);
 191                 gen_eight(c);
 192                 return true;
 193         }
 194 }
 195
 196 static bool attr_w s390_inline_address(int64_t imm)
 197 {
 198         if (likely(cpu_test_feature(CPU_FEATURE_long_displacement))) {
 199                 if (likely(imm >= -0x80000) && likely(imm < 0x80000))
 200                         return true;
 201         }
 202         if (imm >= 0 && imm < 0x1000)
 203                 return true;
 204         return false;
 205 }
 206
 207 static bool attr_w gen_address(struct codegen_context *ctx, unsigned base, int64_t imm, unsigned purpose, unsigned attr_unused size)
 208 {
 209         ctx->offset_imm = imm;
 210         ctx->offset_reg = false;
 211         ctx->base_reg = base;
 212         switch (purpose) {
 213                 case IMM_PURPOSE_LDR_OFFSET:
 214                 case IMM_PURPOSE_LDR_SX_OFFSET:
 215                 case IMM_PURPOSE_STR_OFFSET:
 216                 case IMM_PURPOSE_VLDR_VSTR_OFFSET:
 217                 case IMM_PURPOSE_MVI_CLI_OFFSET:
 218                         break;
 219                 case IMM_PURPOSE_LDP_STP_OFFSET:
 220                         if (imm >= 0 && imm < 0x1000)
 221                                 return true;
 222                         goto load_cnst;
 223                 default:
 224                         internal(file_line, "gen_address: invalid purpose %d", purpose);
 225         }
 226         if (s390_inline_address(imm))
 227                 return true;
 228
 229 load_cnst:
 230         g(gen_load_constant(ctx, R_OFFSET_IMM, imm));
 231
 232         if (purpose == IMM_PURPOSE_MVI_CLI_OFFSET || purpose == IMM_PURPOSE_LDP_STP_OFFSET) {
 233                 gen_insn(INSN_LEA3, OP_SIZE_ADDRESS, 0, 0);
 234                 gen_one(R_OFFSET_IMM);
 235                 gen_one(R_OFFSET_IMM);
 236                 gen_one(base);
 237                 gen_one(ARG_IMM);
 238                 gen_eight(0);
 239                 ctx->base_reg = R_OFFSET_IMM;
 240                 ctx->offset_imm = 0;
 241                 return true;
 242         }
 243
 244         ctx->offset_reg = true;
 245
 246         return true;
 247 }
 248
 249 static bool is_direct_const(int64_t imm, unsigned purpose, unsigned size)
 250 {
 251         switch (purpose) {
 252                 case IMM_PURPOSE_ADD:
 253                         if (imm >= -0x8000 && imm < 0x8000)
 254                                 return true;
 255                         break;
 256                 case IMM_PURPOSE_SUB:
 257                         if (imm > -0x8000 && imm <= 0x8000)
 258                                 return true;
 259                         break;
 260                 case IMM_PURPOSE_AND:
 261                         imm = ~imm;
 262                         /*-fallthrough*/
 263                 case IMM_PURPOSE_OR:
 264                         if (Z) {
 265                                 if (!(imm & ~0xffffULL))
 266                                         return true;
 267                                 if (!(imm & ~0xffff0000ULL))
 268                                         return true;
 269                                 if (!(imm & ~0xffff00000000ULL))
 270                                         return true;
 271                                 if (!(imm & ~0xffff000000000000ULL))
 272                                         return true;
 273                         }
 274                         /*-fallthrough*/
 275                 case IMM_PURPOSE_XOR:
 276                         if (cpu_test_feature(CPU_FEATURE_extended_imm)) {
 277                                 if (!(imm & ~0xffffffffULL))
 278                                         return true;
 279                                 if (!(imm & ~0xffffffff00000000ULL))
 280                                         return true;
 281                         }
 282                         break;
 283                 case IMM_PURPOSE_TEST:
 284                         if (!(imm & ~0xffffULL))
 285                                 return true;
 286                         if (!(imm & ~0xffff0000ULL))
 287                                 return true;
 288                         if (!(imm & ~0xffff00000000ULL))
 289                                 return true;
 290                         if (!(imm & ~0xffff000000000000ULL))
 291                                 return true;
 292                         break;
 293                 case IMM_PURPOSE_STORE_VALUE:
 294                         if (size == OP_SIZE_1)
 295                                 return true;
 296                         break;
 297                 default:
 298                         break;
 299         }
 300         return false;
 301 }
 302
 303 static bool attr_w gen_imm(struct codegen_context *ctx, int64_t imm, unsigned purpose, unsigned size)
 304 {
 305         if (is_direct_const(imm, purpose, size)/* && (purpose == IMM_PURPOSE_TEST || purpose == IMM_PURPOSE_CMP)*/) {
 306                 ctx->const_imm = imm;
 307                 ctx->const_reg = false;
 308         } else {
 309                 g(gen_load_constant(ctx, R_CONST_IMM, imm));
 310                 ctx->const_reg = true;
 311         }
 312         return true;
 313 }
 314
 315 static bool attr_w gen_entry(struct codegen_context *ctx)
 316 {
 317         gen_insn(INSN_S390_PUSH, OP_SIZE_ADDRESS, 0, 0);
 318         gen_one(ARG_ADDRESS_1);
 319         gen_one(R_SP);
 320         gen_eight(FRAME_REGS);
 321 #if defined(ARCH_S390_32)
 322         gen_insn(INSN_MOV, OP_SIZE_8, 0, 0);
 323         gen_one(ARG_ADDRESS_1);
 324         gen_one(R_SP);
 325         gen_eight(FRAME_FP_REGS);
 326         gen_one(FR_4);
 327
 328         gen_insn(INSN_MOV, OP_SIZE_8, 0, 0);
 329         gen_one(ARG_ADDRESS_1);
 330         gen_one(R_SP);
 331         gen_eight(FRAME_FP_REGS + 8);
 332         gen_one(FR_6);
 333 #endif
 334         gen_insn(INSN_ALU, OP_SIZE_NATIVE, ALU_ADD, ALU_WRITES_FLAGS(ALU_ADD, true));
 335         gen_one(R_SP);
 336         gen_one(R_SP);
 337         gen_one(ARG_IMM);
 338         gen_eight(-FRAME_SIZE);
 339
 340         gen_insn(INSN_MOV, OP_SIZE_ADDRESS, 0, 0);
 341         gen_one(ARG_ADDRESS_1);
 342         gen_one(R_SP);
 343         gen_eight(FRAME_RETPTR);
 344         gen_one(R_ARG0);
 345
 346         gen_insn(INSN_MOV, OP_SIZE_NATIVE, 0, 0);
 347         gen_one(R_FRAME);
 348         gen_one(R_ARG1);
 349
 350         gen_insn(INSN_MOV, OP_SIZE_NATIVE, 0, 0);
 351         gen_one(R_UPCALL);
 352         gen_one(R_ARG2);
 353
 354         gen_insn(INSN_MOV, OP_SIZE_4, 0, 0);
 355         gen_one(ARG_ADDRESS_1);
 356         gen_one(R_SP);
 357         gen_eight(FRAME_TIMESTAMP);
 358         gen_one(R_ARG3);
 359
 360         gen_insn(INSN_JMP_INDIRECT, 0, 0, 0);
 361         gen_one(R_ARG4);
 362
 363         return true;
 364 }
 365
 366 static bool attr_w gen_escape_arg(struct codegen_context *ctx, ip_t ip, uint32_t escape_label)
 367 {
 368         g(gen_load_constant(ctx, R_UPCALL, ip));
 369
 370         gen_insn(INSN_JMP, 0, 0, 0);
 371         gen_four(escape_label);
 372
 373         return true;
 374 }
 375
 376 static bool attr_w gen_escape(struct codegen_context *ctx)
 377 {
 378 #if defined(ARCH_S390_32)
 379         gen_insn(INSN_MOV, OP_SIZE_8, 0, 0);
 380         gen_one(FR_4);
 381         gen_one(ARG_ADDRESS_1);
 382         gen_one(R_SP);
 383         gen_eight(FRAME_SIZE + FRAME_FP_REGS);
 384
 385         gen_insn(INSN_MOV, OP_SIZE_8, 0, 0);
 386         gen_one(FR_6);
 387         gen_one(ARG_ADDRESS_1);
 388         gen_one(R_SP);
 389         gen_eight(FRAME_SIZE + FRAME_FP_REGS + 8);
 390 #endif
 391         gen_insn(INSN_MOV, OP_SIZE_ADDRESS, 0, 0);
 392         gen_one(R_ARG0);
 393         gen_one(ARG_ADDRESS_1);
 394         gen_one(R_SP);
 395         gen_eight(FRAME_RETPTR);
 396
 397         gen_insn(INSN_STP, OP_SIZE_ADDRESS, 0, 0);
 398         gen_one(ARG_ADDRESS_1);
 399         gen_one(R_ARG0);
 400         gen_eight(0);
 401         gen_one(R_UPCALL);
 402         gen_one(R_FRAME);
 403
 404         gen_insn(INSN_S390_POP, OP_SIZE_ADDRESS, 0, 0);
 405         gen_one(ARG_ADDRESS_1);
 406         gen_one(R_SP);
 407         gen_eight(FRAME_SIZE + FRAME_REGS);
 408
 409         gen_insn(INSN_RET, 0, 0, 0);
 410         return true;
 411 }
 412
 413 static bool attr_w gen_upcall_argument(struct codegen_context attr_unused *ctx, unsigned attr_unused arg)
 414 {
 415         return true;
 416 }
 417
 418 static bool attr_w gen_upcall(struct codegen_context *ctx, unsigned offset, unsigned n_args)
 419 {
 420         g(gen_address(ctx, R_UPCALL, offset, IMM_PURPOSE_LDR_OFFSET, OP_SIZE_ADDRESS));
 421         gen_insn(INSN_MOV, OP_SIZE_ADDRESS, 0, 0);
 422         gen_one(R_OFFSET_IMM);
 423         gen_address_offset();
 424
 425         gen_insn(INSN_CALL_INDIRECT, OP_SIZE_ADDRESS, 0, 0);
 426         gen_one(R_OFFSET_IMM);
 427
 428         g(gen_upcall_end(ctx, n_args));
 429
 430         return true;
 431 }
 432
 433 static bool attr_w gen_timestamp_test(struct codegen_context *ctx, uint32_t escape_label)
 434 {
 435         gen_insn(INSN_MOV, OP_SIZE_4, 0, 0);
 436         gen_one(R_SCRATCH_1);
 437         gen_one(ARG_ADDRESS_1);
 438         gen_one(R_SP);
 439         gen_eight(FRAME_TIMESTAMP);
 440
 441         g(gen_address(ctx, R_UPCALL, offsetof(struct cg_upcall_vector_s, ts), IMM_PURPOSE_LDR_OFFSET, OP_SIZE_4));
 442         gen_insn(INSN_CMP, OP_SIZE_4, 0, 1);
 443         gen_one(R_SCRATCH_1);
 444         gen_address_offset();
 445
 446         gen_insn(INSN_JMP_COND, OP_SIZE_4, COND_NE, 0);
 447         gen_four(escape_label);
 448
 449         return true;
 450 }