cg-ptr.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 #if defined(POINTER_COMPRESSION)
  20 #define POINTER_THUNK_BIT               0
  21 #elif defined(POINTER_IGNORE_START)
  22 #define POINTER_THUNK_BIT               POINTER_IGNORE_TOP_BIT
  23 #elif defined(POINTER_TAG)
  24 #define POINTER_THUNK_BIT               POINTER_TAG_BIT
  25 #else
  26 unsupported pointer mode
  27 #endif
  28
  29 static bool attr_w gen_ptr_is_thunk(struct codegen_context *ctx, unsigned reg, frame_t slot, uint32_t label)
  30 {
  31         if (slot != NO_FRAME_T) {
  32                 if (ctx->flag_cache[slot] & FLAG_CACHE_IS_NOT_THUNK || da(ctx->fn,function)->local_variables_flags[slot].must_be_data)
  33                         return true;
  34                 ctx->flag_cache[slot] |= FLAG_CACHE_IS_NOT_THUNK;
  35         }
  36 #if defined(ARCH_X86)
  37         if (POINTER_THUNK_BIT < 8
  38 #if defined(ARCH_X86_32)
  39                 && reg < 4
  40 #endif
  41                 ) {
  42                 g(gen_cmp_test_imm_jmp(ctx, INSN_TEST, OP_SIZE_1, reg, (uint64_t)1 << POINTER_THUNK_BIT, COND_NE, label));
  43         } else
  44 #endif
  45         {
  46                 g(gen_cmp_test_imm_jmp(ctx, INSN_TEST, OP_SIZE_SLOT, reg, (uint64_t)1 << POINTER_THUNK_BIT, COND_NE, label));
  47         }
  48         return true;
  49 }
  50
  51 static bool attr_w gen_test_multiple_thunks(struct codegen_context *ctx, frame_t *variables, size_t n_variables, uint32_t label)
  52 {
  53         size_t n;
  54 #if defined(ARCH_X86) || defined(ARCH_S390)
  55         if (n_variables >= 2) {
  56                 g(gen_frame_load(ctx, OP_SIZE_SLOT, garbage, variables[0], 0, R_SCRATCH_1));
  57                 for (n = 1; n < n_variables; n++) {
  58                         g(gen_frame_load_op(ctx, OP_SIZE_SLOT, garbage, ALU_OR, 0, variables[n], 0, R_SCRATCH_1));
  59                 }
  60                 g(gen_ptr_is_thunk(ctx, R_SCRATCH_1, NO_FRAME_T, label));
  61                 return true;
  62         }
  63 #endif
  64         for (n = 0; n < n_variables; n++) {
  65                 g(gen_frame_load(ctx, OP_SIZE_SLOT, garbage, variables[n], 0, R_SCRATCH_1));
  66                 g(gen_ptr_is_thunk(ctx, R_SCRATCH_1, NO_FRAME_T, label));
  67         }
  68         return true;
  69 }
  70
  71 static bool attr_w gen_barrier(struct codegen_context *ctx)
  72 {
  73         if (ARCH_NEEDS_BARRIER)
  74                 gen_insn(INSN_MB, 0, 0, 0);
  75         return true;
  76 }
  77
  78 static bool attr_w gen_compare_refcount(struct codegen_context *ctx, unsigned ptr, unsigned val, unsigned cond, uint32_t label)
  79 {
  80         unsigned op_size = log_2(sizeof(refcount_int_t));
  81 #if defined(ARCH_X86)
  82         bool logical = COND_IS_LOGICAL(cond);
  83         g(gen_address(ctx, ptr, offsetof(struct data, refcount_), IMM_PURPOSE_LDR_OFFSET, op_size));
  84         g(gen_imm(ctx, val, IMM_PURPOSE_CMP, op_size));
  85         gen_insn(INSN_CMP, op_size, 0, 1 + logical);
  86         gen_address_offset();
  87         gen_imm_offset();
  88
  89         gen_insn(!logical ? INSN_JMP_COND : INSN_JMP_COND_LOGICAL, op_size, cond, 0);
  90         gen_four(label);
  91 #else
  92         g(gen_address(ctx, ptr, offsetof(struct data, refcount_), IMM_PURPOSE_LDR_OFFSET, op_size));
  93         gen_insn(INSN_MOV, op_size, 0, 0);
  94         gen_one(R_SCRATCH_2);
  95         gen_address_offset();
  96
  97         g(gen_cmp_test_imm_jmp(ctx, INSN_CMP, op_size, R_SCRATCH_2, val, cond, label));
  98 #endif
  99         return true;
 100 }
 101
 102 static bool attr_w gen_compare_ptr_tag(struct codegen_context *ctx, unsigned reg, unsigned tag, unsigned cond, uint32_t label, unsigned tmp_reg)
 103 {
 104 #if defined(ARCH_S390)
 105         switch (cond) {
 106                 case COND_A:    cond = COND_G; break;
 107                 case COND_AE:   cond = COND_GE; break;
 108                 case COND_B:    cond = COND_L; break;
 109                 case COND_BE:   cond = COND_LE; break;
 110         }
 111 #endif
 112 #if defined(DATA_TAG_AT_ALLOC)
 113         g(gen_3address_rot_imm(ctx, OP_SIZE_ADDRESS, ROT_SHR, tmp_reg, reg, POINTER_IGNORE_START, false));
 114 #elif defined(REFCOUNT_TAG)
 115         size_t offset = offsetof(struct data, refcount_);
 116 #if defined(C_BIG_ENDIAN)
 117         offset += sizeof(refcount_t) - 1;
 118 #endif
 119 #if defined(ARCH_X86) && REFCOUNT_STEP == 256
 120         g(gen_imm(ctx, tag, IMM_PURPOSE_CMP, OP_SIZE_4));
 121         gen_insn(INSN_CMP, OP_SIZE_1, 0, 1);
 122         gen_one(ARG_ADDRESS_1);
 123         gen_one(reg);
 124         gen_eight(offset);
 125         gen_imm_offset();
 126
 127         gen_insn(INSN_JMP_COND, OP_SIZE_1, cond, 0);
 128         gen_four(label);
 129         return true;
 130 #endif
 131         if (ARCH_HAS_BWX && REFCOUNT_STEP == 256) {
 132                 gen_insn(INSN_MOV, OP_SIZE_1, 0, 0);
 133                 gen_one(tmp_reg);
 134                 gen_one(ARG_ADDRESS_1);
 135                 gen_one(reg);
 136                 gen_eight(offset);
 137         } else {
 138                 gen_insn(INSN_MOV, log_2(sizeof(refcount_int_t)), 0, 0);
 139                 gen_one(tmp_reg);
 140                 gen_one(ARG_ADDRESS_1);
 141                 gen_one(reg);
 142                 gen_eight(offset);
 143
 144                 g(gen_3address_alu_imm(ctx, log_2(sizeof(refcount_int_t)), ALU_AND, tmp_reg, tmp_reg, REFCOUNT_STEP - 1, 0));
 145         }
 146 #else
 147 #if defined(ARCH_S390)
 148         if (sizeof(tag_t) == 1 && !cpu_test_feature(CPU_FEATURE_long_displacement)) {
 149                 g(gen_address(ctx, reg, offsetof(struct data, tag), IMM_PURPOSE_LDR_OFFSET, log_2(sizeof(tag_t))));
 150                 gen_insn(INSN_MOV_MASK, OP_SIZE_NATIVE, MOV_MASK_0_8, 0);
 151                 gen_one(tmp_reg);
 152                 gen_one(tmp_reg);
 153                 gen_address_offset();
 154
 155                 g(gen_extend(ctx, log_2(sizeof(tag_t)), zero_x, tmp_reg, tmp_reg));
 156         } else
 157 #endif
 158         {
 159                 g(gen_address(ctx, reg, offsetof(struct data, tag), IMM_PURPOSE_LDR_OFFSET, log_2(sizeof(tag_t))));
 160                 gen_insn(INSN_MOV, log_2(sizeof(tag_t)), 0, 0);
 161                 gen_one(tmp_reg);
 162                 gen_address_offset();
 163         }
 164 #endif
 165         g(gen_cmp_test_imm_jmp(ctx, INSN_CMP, i_size(OP_SIZE_4), tmp_reg, tag, cond, label));
 166         return true;
 167 }
 168
 169 static bool attr_w gen_compare_da_tag(struct codegen_context *ctx, unsigned reg, unsigned tag, unsigned cond, uint32_t label, unsigned tmp_reg)
 170 {
 171 #if defined(ARCH_S390)
 172         switch (cond) {
 173                 case COND_A:    cond = COND_G; break;
 174                 case COND_AE:   cond = COND_GE; break;
 175                 case COND_B:    cond = COND_L; break;
 176                 case COND_BE:   cond = COND_LE; break;
 177         }
 178 #endif
 179 #if defined(POINTER_COMPRESSION)
 180 #if defined(ARCH_X86) && POINTER_COMPRESSION <= 3 && defined(REFCOUNT_TAG) && REFCOUNT_STEP == 256 && defined(C_LITTLE_ENDIAN)
 181         g(gen_imm(ctx, tag, IMM_PURPOSE_CMP, log_2(sizeof(tag_t))));
 182         gen_insn(INSN_CMP, log_2(sizeof(tag_t)), 0, 0);
 183         gen_one(ARG_ADDRESS_1 + POINTER_COMPRESSION);
 184         gen_one(reg);
 185         gen_eight(offsetof(struct data, refcount_));
 186         gen_imm_offset();
 187
 188         gen_insn(INSN_JMP_COND, OP_SIZE_4, cond, 0);
 189         gen_four(label);
 190
 191         return true;
 192 #endif
 193         if (ARCH_PREFERS_SX(OP_SIZE_4)) {
 194                 g(gen_extend(ctx, OP_SIZE_4, zero_x, tmp_reg, reg));
 195
 196                 g(gen_3address_rot_imm(ctx, OP_SIZE_ADDRESS, ROT_SHL, tmp_reg, tmp_reg, POINTER_COMPRESSION, false));
 197         } else {
 198                 g(gen_3address_rot_imm(ctx, OP_SIZE_ADDRESS, ROT_SHL, tmp_reg, reg, POINTER_COMPRESSION, false));
 199         }
 200         g(gen_compare_ptr_tag(ctx, tmp_reg, tag, cond, label, tmp_reg));
 201         return true;
 202 #endif
 203         g(gen_compare_ptr_tag(ctx, reg, tag, cond, label, tmp_reg));
 204         return true;
 205 }
 206
 207 static bool attr_w gen_compare_tag_and_refcount(struct codegen_context *ctx, unsigned reg, unsigned tag, uint32_t label, unsigned attr_unused tmp_reg)
 208 {
 209 #if defined(REFCOUNT_TAG)
 210         g(gen_compare_refcount(ctx, reg, tag, COND_NE, label));
 211 #else
 212         g(gen_compare_ptr_tag(ctx, reg, tag, COND_NE, label, tmp_reg));
 213         g(gen_compare_refcount(ctx, reg, REFCOUNT_STEP, COND_AE, label));
 214 #endif
 215         return true;
 216 }
 217
 218 static bool attr_w gen_decompress_pointer(struct codegen_context *ctx, bool attr_unused zx, unsigned dest, unsigned src, int64_t offset)
 219 {
 220 #ifdef POINTER_COMPRESSION
 221 #if defined(ARCH_X86) && POINTER_COMPRESSION <= 3
 222         if (offset || dest != src) {
 223                 g(gen_imm(ctx, offset, IMM_PURPOSE_ADD, i_size(OP_SIZE_ADDRESS)));
 224                 gen_insn(INSN_ALU, i_size(OP_SIZE_ADDRESS), ALU_ADD, ALU_WRITES_FLAGS(ALU_ADD, is_imm()));
 225                 gen_one(dest);
 226                 gen_one(ARG_SHIFTED_REGISTER);
 227                 gen_one(ARG_SHIFT_LSL | POINTER_COMPRESSION);
 228                 gen_one(src);
 229                 gen_imm_offset();
 230                 return true;
 231         }
 232 #endif
 233         if (zx) {
 234                 g(gen_extend(ctx, OP_SIZE_4, zero_x, dest, src));
 235                 src = dest;
 236         }
 237         g(gen_3address_rot_imm(ctx, OP_SIZE_ADDRESS, ROT_SHL, dest, src, POINTER_COMPRESSION, false));
 238         src = dest;
 239 #endif
 240         if (offset)
 241                 g(gen_3address_alu_imm(ctx, i_size(OP_SIZE_ADDRESS), ALU_ADD, dest, src, offset, 0));
 242         return true;
 243 }
 244
 245 static bool attr_w gen_compress_pointer(struct codegen_context attr_unused *ctx, unsigned dest, unsigned src)
 246 {
 247 #ifdef POINTER_COMPRESSION
 248         g(gen_3address_rot_imm(ctx, OP_SIZE_ADDRESS, ROT_SHR, dest, src, POINTER_COMPRESSION, false));
 249 #else
 250         g(gen_mov(ctx, i_size(OP_SIZE_ADDRESS), dest, src));
 251 #endif
 252         return true;
 253 }
 254
 255 static bool attr_w gen_frame_get_pointer(struct codegen_context *ctx, frame_t slot, bool deref, unsigned dest)
 256 {
 257         if (!deref) {
 258                 g(gen_upcall_start(ctx, 1));
 259                 g(gen_frame_load(ctx, OP_SIZE_SLOT, garbage, slot, 0, R_ARG0));
 260                 g(gen_upcall_argument(ctx, 0));
 261                 g(gen_upcall(ctx, offsetof(struct cg_upcall_vector_s, cg_upcall_pointer_reference_owned), 1));
 262                 g(gen_frame_load(ctx, OP_SIZE_SLOT, garbage, slot, 0, dest));
 263         } else if (!da(ctx->fn,function)->local_variables_flags[slot].may_be_borrowed) {
 264                 g(gen_frame_load(ctx, OP_SIZE_SLOT, garbage, slot, 0, dest));
 265                 g(gen_set_1(ctx, R_FRAME, slot, 0, false));
 266                 flag_set(ctx, slot, false);
 267         } else {
 268                 uint32_t skip_label;
 269                 skip_label = alloc_label(ctx);
 270                 if (unlikely(!skip_label))
 271                         return false;
 272                 if (flag_is_set(ctx, slot)) {
 273                         g(gen_set_1(ctx, R_FRAME, slot, 0, false));
 274                         goto move_it;
 275                 }
 276                 if (flag_is_clear(ctx, slot))
 277                         goto do_reference;
 278                 g(gen_test_1(ctx, R_FRAME, slot, 0, skip_label, false, TEST_CLEAR));
 279 do_reference:
 280                 g(gen_upcall_start(ctx, 1));
 281                 g(gen_frame_load(ctx, OP_SIZE_SLOT, garbage, slot, 0, R_ARG0));
 282                 g(gen_upcall_argument(ctx, 0));
 283                 g(gen_upcall(ctx, offsetof(struct cg_upcall_vector_s, cg_upcall_pointer_reference_owned), 1));
 284 move_it:
 285                 gen_label(skip_label);
 286                 g(gen_frame_load(ctx, OP_SIZE_SLOT, garbage, slot, 0, dest));
 287                 g(gen_frame_clear(ctx, OP_SIZE_SLOT, slot));
 288                 flag_set(ctx, slot, false);
 289         }
 290         return true;
 291 }
 292
 293 static bool attr_w gen_frame_set_pointer(struct codegen_context *ctx, frame_t slot, unsigned src, bool reference, bool not_thunk)
 294 {
 295         bool escape_on_thunk = !not_thunk && da(ctx->fn,function)->local_variables_flags[slot].must_be_data;
 296         g(gen_set_1(ctx, R_FRAME, slot, 0, true));
 297         flag_set_unknown(ctx, slot);
 298         if (not_thunk)
 299                 ctx->flag_cache[slot] |= FLAG_CACHE_IS_NOT_THUNK;
 300         flag_set(ctx, slot, true);
 301         g(gen_frame_store(ctx, OP_SIZE_SLOT, slot, 0, src));
 302         if (reference) {
 303                 if (escape_on_thunk)
 304                         g(gen_mov(ctx, i_size(OP_SIZE_ADDRESS), R_SAVED_1, src));
 305                 g(gen_upcall_start(ctx, 1));
 306                 g(gen_mov(ctx, i_size(OP_SIZE_ADDRESS), R_ARG0, src));
 307                 g(gen_upcall_argument(ctx, 0));
 308                 g(gen_upcall(ctx, offsetof(struct cg_upcall_vector_s, cg_upcall_pointer_reference_owned), 1));
 309                 if (escape_on_thunk)
 310                         src = R_SAVED_1;
 311         }
 312         if (escape_on_thunk) {
 313                 uint32_t nondata_label = alloc_escape_label_for_ip(ctx, ctx->current_position);
 314                 if (unlikely(!nondata_label))
 315                         return false;
 316                 g(gen_ptr_is_thunk(ctx, src, NO_FRAME_T, nondata_label));
 317         }
 318         return true;
 319 }
 320
 321 static bool attr_w gen_frame_load_slot(struct codegen_context *ctx, frame_t slot, unsigned reg)
 322 {
 323         g(gen_frame_load(ctx, OP_SIZE_SLOT, native, slot, 0, reg));
 324         return true;
 325 }
 326
 327 static bool attr_w gen_frame_get_slot(struct codegen_context *ctx, frame_t slot, unsigned reg, unsigned *dest)
 328 {
 329         if (ctx->registers[slot] >= 0) {
 330                 *dest = ctx->registers[slot];
 331                 return true;
 332         }
 333         *dest = reg;
 334         g(gen_frame_load_slot(ctx, slot, reg));
 335         return true;
 336 }
 337
 338 static bool attr_w gen_frame_decompress_slot(struct codegen_context *ctx, frame_t slot, unsigned reg, unsigned *dest, uint32_t escape_label)
 339 {
 340         if (ctx->registers[slot] >= 0) {
 341                 unsigned creg = ctx->registers[slot];
 342                 g(gen_ptr_is_thunk(ctx, creg, slot, escape_label));
 343 #if !defined(POINTER_COMPRESSION)
 344                 g(gen_barrier(ctx));
 345                 *dest = creg;
 346 #else
 347                 g(gen_decompress_pointer(ctx, ARCH_PREFERS_SX(OP_SIZE_SLOT), reg, creg, 0));
 348                 g(gen_barrier(ctx));
 349                 *dest = reg;
 350 #endif
 351                 return true;
 352         }
 353         g(gen_frame_load(ctx, OP_SIZE_SLOT, native, slot, 0, reg));
 354         g(gen_ptr_is_thunk(ctx, reg, slot, escape_label));
 355         g(gen_decompress_pointer(ctx, ARCH_PREFERS_SX(OP_SIZE_SLOT), reg, reg, 0));
 356         g(gen_barrier(ctx));
 357         *dest = reg;
 358         return true;
 359 }