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