Merge pull request ruby#167 from Shopify/noah_fix_link_errs

Noah Gibbs · web-flow · commit 8736bf706164 · 2022-02-16T17:06:59.000Z
Remove C-side gen_single_block
diff --git a/yjit_codegen.c b/yjit_codegen.c
@@ -633,162 +633,6 @@ jit_jump_to_next_insn(jitstate_t *jit, const ctx_t *current_context)
     );
 }
 
-// Compile a sequence of bytecode instructions for a given basic block version.
-// Part of gen_block_version().
-static block_t *
-gen_single_block(blockid_t blockid, const ctx_t *start_ctx, rb_execution_context_t *ec)
-{
-    RUBY_ASSERT(cb != NULL);
-    verify_blockid(blockid);
-
-    // Allocate the new block
-    block_t *block = calloc(1, sizeof(block_t));
-    if (!block) {
-        return NULL;
-    }
-
-    // Copy the starting context to avoid mutating it
-    ctx_t ctx_copy = *start_ctx;
-    ctx_t *ctx = &ctx_copy;
-
-    // Limit the number of specialized versions for this block
-    *ctx = limit_block_versions(blockid, ctx);
-
-    // Save the starting context on the block.
-    block->blockid = blockid;
-    block->ctx = *ctx;
-
-    RUBY_ASSERT(!(blockid.idx == 0 && start_ctx->stack_size > 0));
-
-    const rb_iseq_t *iseq = block->blockid.iseq;
-    const unsigned int iseq_size = iseq->body->iseq_size;
-    uint32_t insn_idx = block->blockid.idx;
-    const uint32_t starting_insn_idx = insn_idx;
-
-    // Initialize a JIT state object
-    jitstate_t jit = {
-        .cb = cb,
-        .ocb = ocb,
-        .block = block,
-        .iseq = iseq,
-        .ec = ec
-    };
-
-    // Mark the start position of the block
-    block->start_addr = cb_get_write_ptr(cb);
-
-    // For each instruction to compile
-    while (insn_idx < iseq_size) {
-        // Get the current pc and opcode
-        VALUE *pc = yjit_iseq_pc_at_idx(iseq, insn_idx);
-        int opcode = yjit_opcode_at_pc(iseq, pc);
-        RUBY_ASSERT(opcode >= 0 && opcode < VM_INSTRUCTION_SIZE);
-
-        // opt_getinlinecache wants to be in a block all on its own. Cut the block short
-        // if we run into it. See gen_opt_getinlinecache() for details.
-        if (opcode == BIN(opt_getinlinecache) && insn_idx > starting_insn_idx) {
-            jit_jump_to_next_insn(&jit, ctx);
-            break;
-        }
-
-        // Set the current instruction
-        jit.insn_idx = insn_idx;
-        jit.opcode = opcode;
-        jit.pc = pc;
-        jit.side_exit_for_pc = NULL;
-
-        // If previous instruction requested to record the boundary
-        if (jit.record_boundary_patch_point) {
-            // Generate an exit to this instruction and record it
-            uint32_t exit_pos = yjit_gen_exit(jit.pc, ctx, ocb);
-            record_global_inval_patch(cb, exit_pos);
-            jit.record_boundary_patch_point = false;
-        }
-
-        // Verify our existing assumption (DEBUG)
-        if (jit_at_current_insn(&jit)) {
-            verify_ctx(&jit, ctx);
-        }
-
-        // Lookup the codegen function for this instruction
-        codegen_fn gen_fn = gen_fns[opcode];
-        codegen_status_t status = YJIT_CANT_COMPILE;
-        if (gen_fn) {
-            if (0) {
-                fprintf(stderr, "compiling %d: %s\n", insn_idx, insn_name(opcode));
-                print_str(cb, insn_name(opcode));
-            }
-
-            // :count-placement:
-            // Count bytecode instructions that execute in generated code.
-            // Note that the increment happens even when the output takes side exit.
-            GEN_COUNTER_INC(cb, exec_instruction);
-
-            // Add a comment for the name of the YARV instruction
-            ADD_COMMENT(cb, insn_name(opcode));
-
-            // Call the code generation function
-            status = gen_fn(&jit, ctx, cb);
-        }
-
-        // If we can't compile this instruction
-        // exit to the interpreter and stop compiling
-        if (status == YJIT_CANT_COMPILE) {
-            // TODO: if the codegen function makes changes to ctx and then return YJIT_CANT_COMPILE,
-            // the exit this generates would be wrong. We could save a copy of the entry context
-            // and assert that ctx is the same here.
-            uint32_t exit_off = yjit_gen_exit(jit.pc, ctx, cb);
-
-            // If this is the first instruction in the block, then we can use
-            // the exit for block->entry_exit.
-            if (insn_idx == block->blockid.idx) {
-                block->entry_exit = cb_get_ptr(cb, exit_off);
-            }
-            break;
-        }
-
-        // For now, reset the chain depth after each instruction as only the
-        // first instruction in the block can concern itself with the depth.
-        ctx->chain_depth = 0;
-
-        // Move to the next instruction to compile
-        insn_idx += insn_len(opcode);
-
-        // If the instruction terminates this block
-        if (status == YJIT_END_BLOCK) {
-            break;
-        }
-    }
-
-    // Mark the end position of the block
-    block->end_addr = cb_get_write_ptr(cb);
-
-    // Store the index of the last instruction in the block
-    block->end_idx = insn_idx;
-
-    // We currently can't handle cases where the request is for a block that
-    // doesn't go to the next instruction.
-    RUBY_ASSERT(!jit.record_boundary_patch_point);
-
-    // If code for the block doesn't fit, free the block and fail.
-    if (cb->dropped_bytes || ocb->dropped_bytes) {
-        yjit_free_block(block);
-        return NULL;
-    }
-
-    if (YJIT_DUMP_MODE >= 2) {
-        // Dump list of compiled instrutions
-        fprintf(stderr, "Compiled the following for iseq=%p:\n", (void *)iseq);
-        for (uint32_t idx = block->blockid.idx; idx < insn_idx; ) {
-            int opcode = yjit_opcode_at_pc(iseq, yjit_iseq_pc_at_idx(iseq, idx));
-            fprintf(stderr, "  %04d %s\n", idx, insn_name(opcode));
-            idx += insn_len(opcode);
-        }
-    }
-
-    return block;
-}
-
 static codegen_status_t gen_opt_send_without_block(jitstate_t *jit, ctx_t *ctx, codeblock_t *cb);
 
 static codegen_status_t
diff --git a/yjit_core.c b/yjit_core.c
@@ -746,7 +746,7 @@ gen_block_version(blockid_t blockid, const ctx_t *start_ctx, rb_execution_contex
     block_t *block;
 
     // Generate code for the first block
-    block = gen_single_block(blockid, start_ctx, ec);
+    //block = gen_single_block(blockid, start_ctx, ec);
     if (block) {
         // Track the block
         add_block_version(block);
@@ -782,7 +782,7 @@ gen_block_version(blockid_t blockid, const ctx_t *start_ctx, rb_execution_contex
 
         batch_success = compiled_count < MAX_PER_BATCH;
         if (batch_success) {
-            block = gen_single_block(requested_id, requested_ctx, ec);
+            //block = gen_single_block(requested_id, requested_ctx, ec);
             batch_success = block;
         }
 
