Add ISEQ_BODY macro

Use ISEQ_BODY macro to get the rb_iseq_constant_body of the ISeq. Using
this macro will make it easier for us to change the allocation strategy
of rb_iseq_constant_body when using Variable Width Allocation.

1 files changed, 86 insertions, 86 deletions

diff --git a/vm_insnhelper.c b/vm_insnhelper.c
index f6d9c2c634..cbc53b5455 100644
--- a/vm_insnhelper.c
+++ b/vm_insnhelper.c
@@ -264,7 +264,7 @@ rb_vm_check_canary(const rb_execution_context_t *ec, VALUE *sp)
     }
 
     const VALUE *orig = rb_iseq_original_iseq(iseq);
-    const VALUE *encoded = iseq->body->iseq_encoded;
+    const VALUE *encoded = ISEQ_BODY(iseq)->iseq_encoded;
     const ptrdiff_t pos = GET_PC() - encoded;
     const enum ruby_vminsn_type insn = (enum ruby_vminsn_type)orig[pos];
     const char *name = insn_name(insn);
@@ -1441,15 +1441,15 @@ vm_throw_start(const rb_execution_context_t *ec, rb_control_frame_t *const reg_c
 	const rb_iseq_t *base_iseq = GET_ISEQ();
 	escape_cfp = reg_cfp;
 
-	while (base_iseq->body->type != ISEQ_TYPE_BLOCK) {
-	    if (escape_cfp->iseq->body->type == ISEQ_TYPE_CLASS) {
+        while (ISEQ_BODY(base_iseq)->type != ISEQ_TYPE_BLOCK) {
+            if (ISEQ_BODY(escape_cfp->iseq)->type == ISEQ_TYPE_CLASS) {
 		escape_cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(escape_cfp);
 		ep = escape_cfp->ep;
 		base_iseq = escape_cfp->iseq;
 	    }
 	    else {
 		ep = VM_ENV_PREV_EP(ep);
-		base_iseq = base_iseq->body->parent_iseq;
+                base_iseq = ISEQ_BODY(base_iseq)->parent_iseq;
 		escape_cfp = rb_vm_search_cf_from_ep(ec, escape_cfp, ep);
 		VM_ASSERT(escape_cfp->iseq == base_iseq);
 	    }
@@ -1466,8 +1466,8 @@ vm_throw_start(const rb_execution_context_t *ec, rb_control_frame_t *const reg_c
 	    while (escape_cfp < eocfp) {
 		if (escape_cfp->ep == ep) {
 		    const rb_iseq_t *const iseq = escape_cfp->iseq;
-		    const VALUE epc = escape_cfp->pc - iseq->body->iseq_encoded;
-		    const struct iseq_catch_table *const ct = iseq->body->catch_table;
+                    const VALUE epc = escape_cfp->pc - ISEQ_BODY(iseq)->iseq_encoded;
+                    const struct iseq_catch_table *const ct = ISEQ_BODY(iseq)->catch_table;
 		    unsigned int i;
 
 		    if (!ct) break;
@@ -1525,7 +1525,7 @@ vm_throw_start(const rb_execution_context_t *ec, rb_control_frame_t *const reg_c
 
 	    if (lep == target_lep &&
 		VM_FRAME_RUBYFRAME_P(escape_cfp) &&
-		escape_cfp->iseq->body->type == ISEQ_TYPE_CLASS) {
+                ISEQ_BODY(escape_cfp->iseq)->type == ISEQ_TYPE_CLASS) {
 		in_class_frame = 1;
 		target_lep = 0;
 	    }
@@ -1555,7 +1555,7 @@ vm_throw_start(const rb_execution_context_t *ec, rb_control_frame_t *const reg_c
 		    }
 		}
 		else if (VM_FRAME_RUBYFRAME_P(escape_cfp)) {
-		    switch (escape_cfp->iseq->body->type) {
+                    switch (ISEQ_BODY(escape_cfp->iseq)->type) {
 		      case ISEQ_TYPE_TOP:
 		      case ISEQ_TYPE_MAIN:
                         if (toplevel) {
@@ -1578,7 +1578,7 @@ vm_throw_start(const rb_execution_context_t *ec, rb_control_frame_t *const reg_c
 		}
 	    }
 
-	    if (escape_cfp->ep == target_lep && escape_cfp->iseq->body->type == ISEQ_TYPE_METHOD) {
+            if (escape_cfp->ep == target_lep && ISEQ_BODY(escape_cfp->iseq)->type == ISEQ_TYPE_METHOD) {
                 if (target_ep == NULL) {
                     goto valid_return;
                 }
@@ -2205,8 +2205,8 @@ vm_base_ptr(const rb_control_frame_t *cfp)
     const rb_control_frame_t *prev_cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp);
 
     if (cfp->iseq && VM_FRAME_RUBYFRAME_P(cfp)) {
-	VALUE *bp = prev_cfp->sp + cfp->iseq->body->local_table_size + VM_ENV_DATA_SIZE;
-	if (cfp->iseq->body->type == ISEQ_TYPE_METHOD) {
+        VALUE *bp = prev_cfp->sp + ISEQ_BODY(cfp->iseq)->local_table_size + VM_ENV_DATA_SIZE;
+        if (ISEQ_BODY(cfp->iseq)->type == ISEQ_TYPE_METHOD) {
 	    /* adjust `self' */
 	    bp += 1;
 	}
@@ -2257,44 +2257,44 @@ vm_call_iseq_setup_normal_0start(rb_execution_context_t *ec, rb_control_frame_t
 
     const struct rb_callcache *cc = calling->cc;
     const rb_iseq_t *iseq = def_iseq_ptr(vm_cc_cme(cc)->def);
-    int param = iseq->body->param.size;
-    int local = iseq->body->local_table_size;
+    int param = ISEQ_BODY(iseq)->param.size;
+    int local = ISEQ_BODY(iseq)->local_table_size;
     return vm_call_iseq_setup_normal(ec, cfp, calling, vm_cc_cme(cc), 0, param, local);
 }
 
 MJIT_STATIC bool
 rb_simple_iseq_p(const rb_iseq_t *iseq)
 {
-    return iseq->body->param.flags.has_opt == FALSE &&
-           iseq->body->param.flags.has_rest == FALSE &&
-	   iseq->body->param.flags.has_post == FALSE &&
-	   iseq->body->param.flags.has_kw == FALSE &&
-	   iseq->body->param.flags.has_kwrest == FALSE &&
-           iseq->body->param.flags.accepts_no_kwarg == FALSE &&
-	   iseq->body->param.flags.has_block == FALSE;
+    return ISEQ_BODY(iseq)->param.flags.has_opt == FALSE &&
+           ISEQ_BODY(iseq)->param.flags.has_rest == FALSE &&
+           ISEQ_BODY(iseq)->param.flags.has_post == FALSE &&
+           ISEQ_BODY(iseq)->param.flags.has_kw == FALSE &&
+           ISEQ_BODY(iseq)->param.flags.has_kwrest == FALSE &&
+           ISEQ_BODY(iseq)->param.flags.accepts_no_kwarg == FALSE &&
+           ISEQ_BODY(iseq)->param.flags.has_block == FALSE;
 }
 
 MJIT_FUNC_EXPORTED bool
 rb_iseq_only_optparam_p(const rb_iseq_t *iseq)
 {
-    return iseq->body->param.flags.has_opt == TRUE &&
-           iseq->body->param.flags.has_rest == FALSE &&
-           iseq->body->param.flags.has_post == FALSE &&
-           iseq->body->param.flags.has_kw == FALSE &&
-           iseq->body->param.flags.has_kwrest == FALSE &&
-           iseq->body->param.flags.accepts_no_kwarg == FALSE &&
-           iseq->body->param.flags.has_block == FALSE;
+    return ISEQ_BODY(iseq)->param.flags.has_opt == TRUE &&
+           ISEQ_BODY(iseq)->param.flags.has_rest == FALSE &&
+           ISEQ_BODY(iseq)->param.flags.has_post == FALSE &&
+           ISEQ_BODY(iseq)->param.flags.has_kw == FALSE &&
+           ISEQ_BODY(iseq)->param.flags.has_kwrest == FALSE &&
+           ISEQ_BODY(iseq)->param.flags.accepts_no_kwarg == FALSE &&
+           ISEQ_BODY(iseq)->param.flags.has_block == FALSE;
 }
 
 MJIT_FUNC_EXPORTED bool
 rb_iseq_only_kwparam_p(const rb_iseq_t *iseq)
 {
-    return iseq->body->param.flags.has_opt == FALSE &&
-           iseq->body->param.flags.has_rest == FALSE &&
-           iseq->body->param.flags.has_post == FALSE &&
-           iseq->body->param.flags.has_kw == TRUE &&
-           iseq->body->param.flags.has_kwrest == FALSE &&
-           iseq->body->param.flags.has_block == FALSE;
+    return ISEQ_BODY(iseq)->param.flags.has_opt == FALSE &&
+           ISEQ_BODY(iseq)->param.flags.has_rest == FALSE &&
+           ISEQ_BODY(iseq)->param.flags.has_post == FALSE &&
+           ISEQ_BODY(iseq)->param.flags.has_kw == TRUE &&
+           ISEQ_BODY(iseq)->param.flags.has_kwrest == FALSE &&
+           ISEQ_BODY(iseq)->param.flags.has_block == FALSE;
 }
 
 // If true, cc->call needs to include `CALLER_SETUP_ARG` (i.e. can't be skipped in fastpath)
@@ -2387,12 +2387,12 @@ vm_call_iseq_setup_normal_opt_start(rb_execution_context_t *ec, rb_control_frame
 {
     const struct rb_callcache *cc = calling->cc;
     const rb_iseq_t *iseq = def_iseq_ptr(vm_cc_cme(cc)->def);
-    const int lead_num = iseq->body->param.lead_num;
+    const int lead_num = ISEQ_BODY(iseq)->param.lead_num;
     const int opt = calling->argc - lead_num;
-    const int opt_num = iseq->body->param.opt_num;
-    const int opt_pc = (int)iseq->body->param.opt_table[opt];
-    const int param = iseq->body->param.size;
-    const int local = iseq->body->local_table_size;
+    const int opt_num = ISEQ_BODY(iseq)->param.opt_num;
+    const int opt_pc = (int)ISEQ_BODY(iseq)->param.opt_table[opt];
+    const int param = ISEQ_BODY(iseq)->param.size;
+    const int local = ISEQ_BODY(iseq)->local_table_size;
     const int delta = opt_num - opt;
 
     RB_DEBUG_COUNTER_INC(ccf_iseq_opt);
@@ -2415,9 +2415,9 @@ vm_call_iseq_setup_tailcall_opt_start(rb_execution_context_t *ec, rb_control_fra
 {
     const struct rb_callcache *cc = calling->cc;
     const rb_iseq_t *iseq = def_iseq_ptr(vm_cc_cme(cc)->def);
-    const int lead_num = iseq->body->param.lead_num;
+    const int lead_num = ISEQ_BODY(iseq)->param.lead_num;
     const int opt = calling->argc - lead_num;
-    const int opt_pc = (int)iseq->body->param.opt_table[opt];
+    const int opt_pc = (int)ISEQ_BODY(iseq)->param.opt_table[opt];
 
     RB_DEBUG_COUNTER_INC(ccf_iseq_opt);
 
@@ -2449,19 +2449,19 @@ vm_call_iseq_setup_kwparm_kwarg(rb_execution_context_t *ec, rb_control_frame_t *
     RB_DEBUG_COUNTER_INC(ccf_iseq_kw1);
 
     const rb_iseq_t *iseq = def_iseq_ptr(vm_cc_cme(cc)->def);
-    const struct rb_iseq_param_keyword *kw_param = iseq->body->param.keyword;
+    const struct rb_iseq_param_keyword *kw_param = ISEQ_BODY(iseq)->param.keyword;
     const struct rb_callinfo_kwarg *kw_arg = vm_ci_kwarg(ci);
     const int ci_kw_len = kw_arg->keyword_len;
     const VALUE * const ci_keywords = kw_arg->keywords;
     VALUE *argv = cfp->sp - calling->argc;
     VALUE *const klocals = argv + kw_param->bits_start - kw_param->num;
-    const int lead_num = iseq->body->param.lead_num;
+    const int lead_num = ISEQ_BODY(iseq)->param.lead_num;
     VALUE * const ci_kws = ALLOCA_N(VALUE, ci_kw_len);
     MEMCPY(ci_kws, argv + lead_num, VALUE, ci_kw_len);
     args_setup_kw_parameters(ec, iseq, ci_kws, ci_kw_len, ci_keywords, klocals);
 
-    int param = iseq->body->param.size;
-    int local = iseq->body->local_table_size;
+    int param = ISEQ_BODY(iseq)->param.size;
+    int local = ISEQ_BODY(iseq)->local_table_size;
     return vm_call_iseq_setup_normal(ec, cfp, calling, vm_cc_cme(cc), 0, param, local);
 }
 
@@ -2476,7 +2476,7 @@ vm_call_iseq_setup_kwparm_nokwarg(rb_execution_context_t *ec, rb_control_frame_t
     RB_DEBUG_COUNTER_INC(ccf_iseq_kw2);
 
     const rb_iseq_t *iseq = def_iseq_ptr(vm_cc_cme(cc)->def);
-    const struct rb_iseq_param_keyword *kw_param = iseq->body->param.keyword;
+    const struct rb_iseq_param_keyword *kw_param = ISEQ_BODY(iseq)->param.keyword;
     VALUE * const argv = cfp->sp - calling->argc;
     VALUE * const klocals = argv + kw_param->bits_start - kw_param->num;
 
@@ -2489,8 +2489,8 @@ vm_call_iseq_setup_kwparm_nokwarg(rb_execution_context_t *ec, rb_control_frame_t
     //   nobody check this value, but it should be cleared because it can
     //   points invalid VALUE (T_NONE objects, raw pointer and so on).
 
-    int param = iseq->body->param.size;
-    int local = iseq->body->local_table_size;
+    int param = ISEQ_BODY(iseq)->param.size;
+    int local = ISEQ_BODY(iseq)->local_table_size;
     return vm_call_iseq_setup_normal(ec, cfp, calling, vm_cc_cme(cc), 0, param, local);
 }
 
@@ -2508,8 +2508,8 @@ vm_callee_setup_arg(rb_execution_context_t *ec, struct rb_calling_info *calling,
             CALLER_SETUP_ARG(cfp, calling, ci);
             CALLER_REMOVE_EMPTY_KW_SPLAT(cfp, calling, ci);
 
-            if (calling->argc != iseq->body->param.lead_num) {
-                argument_arity_error(ec, iseq, calling->argc, iseq->body->param.lead_num, iseq->body->param.lead_num);
+            if (calling->argc != ISEQ_BODY(iseq)->param.lead_num) {
+                argument_arity_error(ec, iseq, calling->argc, ISEQ_BODY(iseq)->param.lead_num, ISEQ_BODY(iseq)->param.lead_num);
             }
 
             VM_ASSERT(ci == calling->ci);
@@ -2522,8 +2522,8 @@ vm_callee_setup_arg(rb_execution_context_t *ec, struct rb_calling_info *calling,
             CALLER_SETUP_ARG(cfp, calling, ci);
             CALLER_REMOVE_EMPTY_KW_SPLAT(cfp, calling, ci);
 
-            const int lead_num = iseq->body->param.lead_num;
-            const int opt_num = iseq->body->param.opt_num;
+            const int lead_num = ISEQ_BODY(iseq)->param.lead_num;
+            const int opt_num = ISEQ_BODY(iseq)->param.opt_num;
             const int argc = calling->argc;
             const int opt = argc - lead_num;
 
@@ -2543,16 +2543,16 @@ vm_callee_setup_arg(rb_execution_context_t *ec, struct rb_calling_info *calling,
             }
 
             /* initialize opt vars for self-references */
-            VM_ASSERT((int)iseq->body->param.size == lead_num + opt_num);
+            VM_ASSERT((int)ISEQ_BODY(iseq)->param.size == lead_num + opt_num);
             for (int i=argc; i<lead_num + opt_num; i++) {
                 argv[i] = Qnil;
             }
-            return (int)iseq->body->param.opt_table[opt];
+            return (int)ISEQ_BODY(iseq)->param.opt_table[opt];
         }
         else if (rb_iseq_only_kwparam_p(iseq) && !IS_ARGS_SPLAT(ci)) {
-            const int lead_num = iseq->body->param.lead_num;
+            const int lead_num = ISEQ_BODY(iseq)->param.lead_num;
             const int argc = calling->argc;
-            const struct rb_iseq_param_keyword *kw_param = iseq->body->param.keyword;
+            const struct rb_iseq_param_keyword *kw_param = ISEQ_BODY(iseq)->param.keyword;
 
             if (vm_ci_flag(ci) & VM_CALL_KWARG) {
                 const struct rb_callinfo_kwarg *kw_arg = vm_ci_kwarg(ci);
@@ -2598,8 +2598,8 @@ vm_call_iseq_setup(rb_execution_context_t *ec, rb_control_frame_t *cfp, struct r
 
     const struct rb_callcache *cc = calling->cc;
     const rb_iseq_t *iseq = def_iseq_ptr(vm_cc_cme(cc)->def);
-    const int param_size = iseq->body->param.size;
-    const int local_size = iseq->body->local_table_size;
+    const int param_size = ISEQ_BODY(iseq)->param.size;
+    const int local_size = ISEQ_BODY(iseq)->local_table_size;
     const int opt_pc = vm_callee_setup_arg(ec, calling, def_iseq_ptr(vm_cc_cme(cc)->def), cfp->sp - calling->argc, param_size, local_size);
     return vm_call_iseq_setup_2(ec, cfp, calling, opt_pc, param_size, local_size);
 }
@@ -2630,9 +2630,9 @@ vm_call_iseq_setup_normal(rb_execution_context_t *ec, rb_control_frame_t *cfp, s
 
     vm_push_frame(ec, iseq, VM_FRAME_MAGIC_METHOD | VM_ENV_FLAG_LOCAL, calling->recv,
                   calling->block_handler, (VALUE)me,
-                  iseq->body->iseq_encoded + opt_pc, sp,
+                  ISEQ_BODY(iseq)->iseq_encoded + opt_pc, sp,
                   local_size - param_size,
-                  iseq->body->stack_max);
+                  ISEQ_BODY(iseq)->stack_max);
     return Qundef;
 }
 
@@ -2670,15 +2670,15 @@ vm_call_iseq_setup_tailcall(rb_execution_context_t *ec, rb_control_frame_t *cfp,
     sp++;
 
     /* copy arguments */
-    for (i=0; i < iseq->body->param.size; i++) {
+    for (i=0; i < ISEQ_BODY(iseq)->param.size; i++) {
 	*sp++ = src_argv[i];
     }
 
     vm_push_frame(ec, iseq, VM_FRAME_MAGIC_METHOD | VM_ENV_FLAG_LOCAL | finish_flag,
-		  calling->recv, calling->block_handler, (VALUE)me,
-		  iseq->body->iseq_encoded + opt_pc, sp,
-		  iseq->body->local_table_size - iseq->body->param.size,
-		  iseq->body->stack_max);
+                  calling->recv, calling->block_handler, (VALUE)me,
+                  ISEQ_BODY(iseq)->iseq_encoded + opt_pc, sp,
+                  ISEQ_BODY(iseq)->local_table_size - ISEQ_BODY(iseq)->param.size,
+                  ISEQ_BODY(iseq)->stack_max);
 
     cfp->sp = sp_orig;
 
@@ -3376,8 +3376,8 @@ current_method_entry(const rb_execution_context_t *ec, rb_control_frame_t *cfp)
 {
     rb_control_frame_t *top_cfp = cfp;
 
-    if (cfp->iseq && cfp->iseq->body->type == ISEQ_TYPE_BLOCK) {
-	const rb_iseq_t *local_iseq = cfp->iseq->body->local_iseq;
+    if (cfp->iseq && ISEQ_BODY(cfp->iseq)->type == ISEQ_TYPE_BLOCK) {
+        const rb_iseq_t *local_iseq = ISEQ_BODY(cfp->iseq)->local_iseq;
 
 	do {
 	    cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp);
@@ -3987,9 +3987,9 @@ vm_callee_setup_block_arg_arg0_splat(rb_control_frame_t *cfp, const rb_iseq_t *i
     int i;
     long len = RARRAY_LEN(ary);
 
-    CHECK_VM_STACK_OVERFLOW(cfp, iseq->body->param.lead_num);
+    CHECK_VM_STACK_OVERFLOW(cfp, ISEQ_BODY(iseq)->param.lead_num);
 
-    for (i=0; i<len && i<iseq->body->param.lead_num; i++) {
+    for (i=0; i<len && i<ISEQ_BODY(iseq)->param.lead_num; i++) {
 	argv[i] = RARRAY_AREF(ary, i);
     }
 
@@ -4021,26 +4021,26 @@ vm_callee_setup_block_arg(rb_execution_context_t *ec, struct rb_calling_info *ca
 
 	if (arg_setup_type == arg_setup_block &&
 	    calling->argc == 1 &&
-	    iseq->body->param.flags.has_lead &&
-	    !iseq->body->param.flags.ambiguous_param0 &&
+            ISEQ_BODY(iseq)->param.flags.has_lead &&
+            !ISEQ_BODY(iseq)->param.flags.ambiguous_param0 &&
 	    !NIL_P(arg0 = vm_callee_setup_block_arg_arg0_check(argv))) {
 	    calling->argc = vm_callee_setup_block_arg_arg0_splat(cfp, iseq, argv, arg0);
 	}
 
-	if (calling->argc != iseq->body->param.lead_num) {
+        if (calling->argc != ISEQ_BODY(iseq)->param.lead_num) {
 	    if (arg_setup_type == arg_setup_block) {
-		if (calling->argc < iseq->body->param.lead_num) {
+                if (calling->argc < ISEQ_BODY(iseq)->param.lead_num) {
 		    int i;
-		    CHECK_VM_STACK_OVERFLOW(cfp, iseq->body->param.lead_num);
-		    for (i=calling->argc; i<iseq->body->param.lead_num; i++) argv[i] = Qnil;
-		    calling->argc = iseq->body->param.lead_num; /* fill rest parameters */
+                    CHECK_VM_STACK_OVERFLOW(cfp, ISEQ_BODY(iseq)->param.lead_num);
+                    for (i=calling->argc; i<ISEQ_BODY(iseq)->param.lead_num; i++) argv[i] = Qnil;
+                    calling->argc = ISEQ_BODY(iseq)->param.lead_num; /* fill rest parameters */
 		}
-		else if (calling->argc > iseq->body->param.lead_num) {
-		    calling->argc = iseq->body->param.lead_num; /* simply truncate arguments */
+                else if (calling->argc > ISEQ_BODY(iseq)->param.lead_num) {
+                    calling->argc = ISEQ_BODY(iseq)->param.lead_num; /* simply truncate arguments */
 		}
 	    }
 	    else {
-		argument_arity_error(ec, iseq, calling->argc, iseq->body->param.lead_num, iseq->body->param.lead_num);
+                argument_arity_error(ec, iseq, calling->argc, ISEQ_BODY(iseq)->param.lead_num, ISEQ_BODY(iseq)->param.lead_num);
 	    }
 	}
 
@@ -4075,7 +4075,7 @@ vm_invoke_iseq_block(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp,
 {
     const struct rb_captured_block *captured = VM_BH_TO_ISEQ_BLOCK(block_handler);
     const rb_iseq_t *iseq = rb_iseq_check(captured->code.iseq);
-    const int arg_size = iseq->body->param.size;
+    const int arg_size = ISEQ_BODY(iseq)->param.size;
     VALUE * const rsp = GET_SP() - calling->argc;
     int opt_pc = vm_callee_setup_block_arg(ec, calling, ci, iseq, rsp, is_lambda ? arg_setup_method : arg_setup_block);
 
@@ -4085,9 +4085,9 @@ vm_invoke_iseq_block(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp,
 		  VM_FRAME_MAGIC_BLOCK | (is_lambda ? VM_FRAME_FLAG_LAMBDA : 0),
 		  captured->self,
 		  VM_GUARDED_PREV_EP(captured->ep), 0,
-		  iseq->body->iseq_encoded + opt_pc,
+                  ISEQ_BODY(iseq)->iseq_encoded + opt_pc,
 		  rsp + arg_size,
-		  iseq->body->local_table_size - arg_size, iseq->body->stack_max);
+                  ISEQ_BODY(iseq)->local_table_size - arg_size, ISEQ_BODY(iseq)->stack_max);
 
     return Qundef;
 }
@@ -4775,7 +4775,7 @@ vm_sendish(
        frame may have stack values in the local variables and the
        cancelling the caller frame will purge them. But directly
        calling mjit_exec is faster... */
-    if (GET_ISEQ()->body->catch_except_p) {
+    if (ISEQ_BODY(GET_ISEQ())->catch_except_p) {
         VM_ENV_FLAGS_SET(GET_EP(), VM_FRAME_FLAG_FINISH);
         return vm_exec(ec, true);
     }
@@ -5637,7 +5637,7 @@ vm_trace(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp)
     }
     else {
 	const rb_iseq_t *iseq = reg_cfp->iseq;
-	size_t pos = pc - iseq->body->iseq_encoded;
+        size_t pos = pc - ISEQ_BODY(iseq)->iseq_encoded;
         rb_event_flag_t pc_events = rb_iseq_event_flags(iseq, pos);
         rb_hook_list_t *local_hooks = iseq->aux.exec.local_hooks;
         rb_event_flag_t iseq_local_events = local_hooks != NULL ? local_hooks->events : 0;
@@ -5910,7 +5910,7 @@ lookup_builtin_invoker(int argc)
 static inline VALUE
 invoke_bf(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp, const struct rb_builtin_function* bf, const VALUE *argv)
 {
-    const bool canary_p = reg_cfp->iseq->body->builtin_inline_p; // Verify an assumption of `Primitive.attr! 'inline'`
+    const bool canary_p = ISEQ_BODY(reg_cfp->iseq)->builtin_inline_p; // Verify an assumption of `Primitive.attr! 'inline'`
     SETUP_CANARY(canary_p);
     VALUE ret = (*lookup_builtin_invoker(bf->argc))(ec, reg_cfp->self, argv, (rb_insn_func_t)bf->func_ptr);
     CHECK_CANARY(canary_p, BIN(invokebuiltin));
@@ -5929,7 +5929,7 @@ vm_invoke_builtin_delegate(rb_execution_context_t *ec, rb_control_frame_t *cfp,
     if (0) { // debug print
         fputs("vm_invoke_builtin_delegate: passing -> ", stderr);
         for (int i=0; i<bf->argc; i++) {
-            ruby_debug_printf(":%s ", rb_id2name(cfp->iseq->body->local_table[i+start_index]));
+            ruby_debug_printf(":%s ", rb_id2name(ISEQ_BODY(cfp->iseq)->local_table[i+start_index]));
         }
         ruby_debug_printf("\n" "%s %s(%d):%p\n", RUBY_FUNCTION_NAME_STRING, bf->name, bf->argc, bf->func_ptr);
     }
@@ -5938,7 +5938,7 @@ vm_invoke_builtin_delegate(rb_execution_context_t *ec, rb_control_frame_t *cfp,
         return invoke_bf(ec, cfp, bf, NULL);
     }
     else {
-        const VALUE *argv = cfp->ep - cfp->iseq->body->local_table_size - VM_ENV_DATA_SIZE + 1 + start_index;
+        const VALUE *argv = cfp->ep - ISEQ_BODY(cfp->iseq)->local_table_size - VM_ENV_DATA_SIZE + 1 + start_index;
         return invoke_bf(ec, cfp, bf, argv);
     }
 }