debase-ruby_core_source 3.2.1 → 3.2.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (129) hide show
  1. checksums.yaml +4 -4
  2. data/CHANGELOG.md +10 -0
  3. data/lib/debase/ruby_core_source/{ruby-3.3.0-preview1 → ruby-3.3.0-preview3}/addr2line.h +3 -1
  4. data/lib/debase/ruby_core_source/ruby-3.3.0-preview3/darray.h +246 -0
  5. data/lib/debase/ruby_core_source/{ruby-3.3.0-preview1 → ruby-3.3.0-preview3}/debug_counter.h +7 -10
  6. data/lib/debase/ruby_core_source/{ruby-3.3.0-preview1 → ruby-3.3.0-preview3}/eval_intern.h +3 -1
  7. data/lib/debase/ruby_core_source/{ruby-3.3.0-preview1 → ruby-3.3.0-preview3}/id.h +44 -0
  8. data/lib/debase/ruby_core_source/{ruby-3.3.0-preview1 → ruby-3.3.0-preview3}/insns_info.inc +128 -154
  9. data/lib/debase/ruby_core_source/{ruby-3.3.0-preview1 → ruby-3.3.0-preview3}/internal/array.h +9 -20
  10. data/lib/debase/ruby_core_source/ruby-3.3.0-preview3/internal/bits.h +568 -0
  11. data/lib/debase/ruby_core_source/{ruby-3.3.0-preview1 → ruby-3.3.0-preview3}/internal/class.h +11 -2
  12. data/lib/debase/ruby_core_source/{ruby-3.3.0-preview1 → ruby-3.3.0-preview3}/internal/cmdlineopt.h +5 -1
  13. data/lib/debase/ruby_core_source/{ruby-3.3.0-preview1 → ruby-3.3.0-preview3}/internal/compile.h +0 -1
  14. data/lib/debase/ruby_core_source/{ruby-3.3.0-preview1 → ruby-3.3.0-preview3}/internal/error.h +24 -2
  15. data/lib/debase/ruby_core_source/{ruby-3.3.0-preview1 → ruby-3.3.0-preview3}/internal/gc.h +29 -0
  16. data/lib/debase/ruby_core_source/{ruby-3.3.0-preview1 → ruby-3.3.0-preview3}/internal/hash.h +19 -44
  17. data/lib/debase/ruby_core_source/{ruby-3.3.0-preview1 → ruby-3.3.0-preview3}/internal/imemo.h +0 -1
  18. data/lib/debase/ruby_core_source/ruby-3.3.0-preview3/internal/io.h +137 -0
  19. data/lib/debase/ruby_core_source/ruby-3.3.0-preview3/internal/parse.h +108 -0
  20. data/lib/debase/ruby_core_source/{ruby-3.3.0-preview1 → ruby-3.3.0-preview3}/internal/process.h +0 -14
  21. data/lib/debase/ruby_core_source/{ruby-3.3.0-preview1 → ruby-3.3.0-preview3}/internal/range.h +2 -2
  22. data/lib/debase/ruby_core_source/{ruby-3.3.0-preview1 → ruby-3.3.0-preview3}/internal/re.h +1 -1
  23. data/lib/debase/ruby_core_source/ruby-3.3.0-preview3/internal/ruby_parser.h +69 -0
  24. data/lib/debase/ruby_core_source/{ruby-3.3.0-preview1 → ruby-3.3.0-preview3}/internal/signal.h +4 -0
  25. data/lib/debase/ruby_core_source/{ruby-3.3.0-preview1 → ruby-3.3.0-preview3}/internal/string.h +15 -0
  26. data/lib/debase/ruby_core_source/{ruby-3.3.0-preview1 → ruby-3.3.0-preview3}/internal/struct.h +9 -34
  27. data/lib/debase/ruby_core_source/{ruby-3.3.0-preview1 → ruby-3.3.0-preview3}/internal/thread.h +14 -0
  28. data/lib/debase/ruby_core_source/{ruby-3.3.0-preview1 → ruby-3.3.0-preview3}/internal/variable.h +17 -35
  29. data/lib/debase/ruby_core_source/{ruby-3.3.0-preview1 → ruby-3.3.0-preview3}/internal/vm.h +9 -2
  30. data/lib/debase/ruby_core_source/{ruby-3.3.0-preview1 → ruby-3.3.0-preview3}/iseq.h +4 -4
  31. data/lib/debase/ruby_core_source/{ruby-3.3.0-preview1 → ruby-3.3.0-preview3}/method.h +8 -7
  32. data/lib/debase/ruby_core_source/ruby-3.3.0-preview3/node.h +128 -0
  33. data/lib/debase/ruby_core_source/{ruby-3.3.0-preview1 → ruby-3.3.0-preview3}/node_name.inc +4 -2
  34. data/lib/debase/ruby_core_source/{ruby-3.3.0-preview1 → ruby-3.3.0-preview3}/parse.h +19 -6
  35. data/lib/debase/ruby_core_source/{ruby-3.3.0-preview1/internal/bits.h → ruby-3.3.0-preview3/parser_bits.h} +4 -4
  36. data/lib/debase/ruby_core_source/ruby-3.3.0-preview3/parser_node.h +32 -0
  37. data/lib/debase/ruby_core_source/ruby-3.3.0-preview3/parser_st.h +162 -0
  38. data/lib/debase/ruby_core_source/ruby-3.3.0-preview3/parser_value.h +106 -0
  39. data/lib/debase/ruby_core_source/ruby-3.3.0-preview3/prism_compile.h +18 -0
  40. data/lib/debase/ruby_core_source/{ruby-3.3.0-preview1 → ruby-3.3.0-preview3}/ractor_core.h +10 -4
  41. data/lib/debase/ruby_core_source/{ruby-3.3.0-preview1 → ruby-3.3.0-preview3}/regint.h +8 -0
  42. data/lib/debase/ruby_core_source/{ruby-3.3.0-preview1 → ruby-3.3.0-preview3}/regparse.h +2 -1
  43. data/lib/debase/ruby_core_source/ruby-3.3.0-preview3/revision.h +5 -0
  44. data/lib/debase/ruby_core_source/ruby-3.3.0-preview3/rubyparser.h +1403 -0
  45. data/lib/debase/ruby_core_source/{ruby-3.3.0-preview1 → ruby-3.3.0-preview3}/shape.h +32 -22
  46. data/lib/debase/ruby_core_source/{ruby-3.3.0-preview1 → ruby-3.3.0-preview3}/symbol.h +2 -3
  47. data/lib/debase/ruby_core_source/{ruby-3.3.0-preview1 → ruby-3.3.0-preview3}/thread_none.h +1 -0
  48. data/lib/debase/ruby_core_source/{ruby-3.3.0-preview1 → ruby-3.3.0-preview3}/thread_pthread.h +66 -28
  49. data/lib/debase/ruby_core_source/{ruby-3.3.0-preview1 → ruby-3.3.0-preview3}/thread_win32.h +1 -6
  50. data/lib/debase/ruby_core_source/{ruby-3.3.0-preview1 → ruby-3.3.0-preview3}/variable.h +9 -2
  51. data/lib/debase/ruby_core_source/{ruby-3.3.0-preview1 → ruby-3.3.0-preview3}/version.h +7 -3
  52. data/lib/debase/ruby_core_source/{ruby-3.3.0-preview1 → ruby-3.3.0-preview3}/vm.inc +383 -497
  53. data/lib/debase/ruby_core_source/{ruby-3.3.0-preview1 → ruby-3.3.0-preview3}/vm_callinfo.h +54 -16
  54. data/lib/debase/ruby_core_source/{ruby-3.3.0-preview1 → ruby-3.3.0-preview3}/vm_core.h +92 -57
  55. data/lib/debase/ruby_core_source/{ruby-3.3.0-preview1 → ruby-3.3.0-preview3}/vm_exec.h +11 -10
  56. data/lib/debase/ruby_core_source/{ruby-3.3.0-preview1 → ruby-3.3.0-preview3}/vm_insnhelper.h +20 -23
  57. data/lib/debase/ruby_core_source/{ruby-3.3.0-preview1 → ruby-3.3.0-preview3}/vm_opts.h +0 -5
  58. data/lib/debase/ruby_core_source/{ruby-3.3.0-preview1 → ruby-3.3.0-preview3}/yjit.h +12 -12
  59. data/lib/debase/ruby_core_source/version.rb +1 -1
  60. metadata +120 -115
  61. data/lib/debase/ruby_core_source/ruby-3.3.0-preview1/darray.h +0 -179
  62. data/lib/debase/ruby_core_source/ruby-3.3.0-preview1/internal/io.h +0 -38
  63. data/lib/debase/ruby_core_source/ruby-3.3.0-preview1/internal/parse.h +0 -25
  64. data/lib/debase/ruby_core_source/ruby-3.3.0-preview1/node.h +0 -514
  65. data/lib/debase/ruby_core_source/ruby-3.3.0-preview1/opt_sc.inc +0 -109
  66. data/lib/debase/ruby_core_source/ruby-3.3.0-preview1/revision.h +0 -5
  67. data/lib/debase/ruby_core_source/ruby-3.3.0-preview1/transient_heap.h +0 -65
  68. /data/lib/debase/ruby_core_source/{ruby-3.3.0-preview1 → ruby-3.3.0-preview3}/builtin.h +0 -0
  69. /data/lib/debase/ruby_core_source/{ruby-3.3.0-preview1 → ruby-3.3.0-preview3}/ccan/build_assert/build_assert.h +0 -0
  70. /data/lib/debase/ruby_core_source/{ruby-3.3.0-preview1 → ruby-3.3.0-preview3}/ccan/check_type/check_type.h +0 -0
  71. /data/lib/debase/ruby_core_source/{ruby-3.3.0-preview1 → ruby-3.3.0-preview3}/ccan/container_of/container_of.h +0 -0
  72. /data/lib/debase/ruby_core_source/{ruby-3.3.0-preview1 → ruby-3.3.0-preview3}/ccan/list/list.h +0 -0
  73. /data/lib/debase/ruby_core_source/{ruby-3.3.0-preview1 → ruby-3.3.0-preview3}/ccan/str/str.h +0 -0
  74. /data/lib/debase/ruby_core_source/{ruby-3.3.0-preview1 → ruby-3.3.0-preview3}/constant.h +0 -0
  75. /data/lib/debase/ruby_core_source/{ruby-3.3.0-preview1 → ruby-3.3.0-preview3}/dln.h +0 -0
  76. /data/lib/debase/ruby_core_source/{ruby-3.3.0-preview1 → ruby-3.3.0-preview3}/encindex.h +0 -0
  77. /data/lib/debase/ruby_core_source/{ruby-3.3.0-preview1 → ruby-3.3.0-preview3}/hrtime.h +0 -0
  78. /data/lib/debase/ruby_core_source/{ruby-3.3.0-preview1 → ruby-3.3.0-preview3}/id_table.h +0 -0
  79. /data/lib/debase/ruby_core_source/{ruby-3.3.0-preview1 → ruby-3.3.0-preview3}/insns.inc +0 -0
  80. /data/lib/debase/ruby_core_source/{ruby-3.3.0-preview1 → ruby-3.3.0-preview3}/internal/basic_operators.h +0 -0
  81. /data/lib/debase/ruby_core_source/{ruby-3.3.0-preview1 → ruby-3.3.0-preview3}/internal/bignum.h +0 -0
  82. /data/lib/debase/ruby_core_source/{ruby-3.3.0-preview1 → ruby-3.3.0-preview3}/internal/compar.h +0 -0
  83. /data/lib/debase/ruby_core_source/{ruby-3.3.0-preview1 → ruby-3.3.0-preview3}/internal/compilers.h +0 -0
  84. /data/lib/debase/ruby_core_source/{ruby-3.3.0-preview1 → ruby-3.3.0-preview3}/internal/complex.h +0 -0
  85. /data/lib/debase/ruby_core_source/{ruby-3.3.0-preview1 → ruby-3.3.0-preview3}/internal/cont.h +0 -0
  86. /data/lib/debase/ruby_core_source/{ruby-3.3.0-preview1 → ruby-3.3.0-preview3}/internal/dir.h +0 -0
  87. /data/lib/debase/ruby_core_source/{ruby-3.3.0-preview1 → ruby-3.3.0-preview3}/internal/enc.h +0 -0
  88. /data/lib/debase/ruby_core_source/{ruby-3.3.0-preview1 → ruby-3.3.0-preview3}/internal/encoding.h +0 -0
  89. /data/lib/debase/ruby_core_source/{ruby-3.3.0-preview1 → ruby-3.3.0-preview3}/internal/enum.h +0 -0
  90. /data/lib/debase/ruby_core_source/{ruby-3.3.0-preview1 → ruby-3.3.0-preview3}/internal/enumerator.h +0 -0
  91. /data/lib/debase/ruby_core_source/{ruby-3.3.0-preview1 → ruby-3.3.0-preview3}/internal/eval.h +0 -0
  92. /data/lib/debase/ruby_core_source/{ruby-3.3.0-preview1 → ruby-3.3.0-preview3}/internal/file.h +0 -0
  93. /data/lib/debase/ruby_core_source/{ruby-3.3.0-preview1 → ruby-3.3.0-preview3}/internal/fixnum.h +0 -0
  94. /data/lib/debase/ruby_core_source/{ruby-3.3.0-preview1 → ruby-3.3.0-preview3}/internal/inits.h +0 -0
  95. /data/lib/debase/ruby_core_source/{ruby-3.3.0-preview1 → ruby-3.3.0-preview3}/internal/load.h +0 -0
  96. /data/lib/debase/ruby_core_source/{ruby-3.3.0-preview1 → ruby-3.3.0-preview3}/internal/loadpath.h +0 -0
  97. /data/lib/debase/ruby_core_source/{ruby-3.3.0-preview1 → ruby-3.3.0-preview3}/internal/math.h +0 -0
  98. /data/lib/debase/ruby_core_source/{ruby-3.3.0-preview1 → ruby-3.3.0-preview3}/internal/missing.h +0 -0
  99. /data/lib/debase/ruby_core_source/{ruby-3.3.0-preview1 → ruby-3.3.0-preview3}/internal/numeric.h +0 -0
  100. /data/lib/debase/ruby_core_source/{ruby-3.3.0-preview1 → ruby-3.3.0-preview3}/internal/object.h +0 -0
  101. /data/lib/debase/ruby_core_source/{ruby-3.3.0-preview1 → ruby-3.3.0-preview3}/internal/proc.h +0 -0
  102. /data/lib/debase/ruby_core_source/{ruby-3.3.0-preview1 → ruby-3.3.0-preview3}/internal/ractor.h +0 -0
  103. /data/lib/debase/ruby_core_source/{ruby-3.3.0-preview1 → ruby-3.3.0-preview3}/internal/random.h +0 -0
  104. /data/lib/debase/ruby_core_source/{ruby-3.3.0-preview1 → ruby-3.3.0-preview3}/internal/rational.h +0 -0
  105. /data/lib/debase/ruby_core_source/{ruby-3.3.0-preview1 → ruby-3.3.0-preview3}/internal/sanitizers.h +0 -0
  106. /data/lib/debase/ruby_core_source/{ruby-3.3.0-preview1 → ruby-3.3.0-preview3}/internal/serial.h +0 -0
  107. /data/lib/debase/ruby_core_source/{ruby-3.3.0-preview1 → ruby-3.3.0-preview3}/internal/static_assert.h +0 -0
  108. /data/lib/debase/ruby_core_source/{ruby-3.3.0-preview1 → ruby-3.3.0-preview3}/internal/symbol.h +0 -0
  109. /data/lib/debase/ruby_core_source/{ruby-3.3.0-preview1 → ruby-3.3.0-preview3}/internal/time.h +0 -0
  110. /data/lib/debase/ruby_core_source/{ruby-3.3.0-preview1 → ruby-3.3.0-preview3}/internal/transcode.h +0 -0
  111. /data/lib/debase/ruby_core_source/{ruby-3.3.0-preview1 → ruby-3.3.0-preview3}/internal/util.h +0 -0
  112. /data/lib/debase/ruby_core_source/{ruby-3.3.0-preview1 → ruby-3.3.0-preview3}/internal/warnings.h +0 -0
  113. /data/lib/debase/ruby_core_source/{ruby-3.3.0-preview1 → ruby-3.3.0-preview3}/internal.h +0 -0
  114. /data/lib/debase/ruby_core_source/{ruby-3.3.0-preview1 → ruby-3.3.0-preview3}/known_errors.inc +0 -0
  115. /data/lib/debase/ruby_core_source/{ruby-3.3.0-preview1 → ruby-3.3.0-preview3}/optinsn.inc +0 -0
  116. /data/lib/debase/ruby_core_source/{ruby-3.3.0-preview1 → ruby-3.3.0-preview3}/optunifs.inc +0 -0
  117. /data/lib/debase/ruby_core_source/{ruby-3.3.0-preview1 → ruby-3.3.0-preview3}/probes_helper.h +0 -0
  118. /data/lib/debase/ruby_core_source/{ruby-3.3.0-preview1 → ruby-3.3.0-preview3}/regenc.h +0 -0
  119. /data/lib/debase/ruby_core_source/{ruby-3.3.0-preview1 → ruby-3.3.0-preview3}/rjit.h +0 -0
  120. /data/lib/debase/ruby_core_source/{ruby-3.3.0-preview1 → ruby-3.3.0-preview3}/rjit_c.h +0 -0
  121. /data/lib/debase/ruby_core_source/{ruby-3.3.0-preview1 → ruby-3.3.0-preview3}/ruby_assert.h +0 -0
  122. /data/lib/debase/ruby_core_source/{ruby-3.3.0-preview1 → ruby-3.3.0-preview3}/ruby_atomic.h +0 -0
  123. /data/lib/debase/ruby_core_source/{ruby-3.3.0-preview1 → ruby-3.3.0-preview3}/siphash.h +0 -0
  124. /data/lib/debase/ruby_core_source/{ruby-3.3.0-preview1 → ruby-3.3.0-preview3}/timev.h +0 -0
  125. /data/lib/debase/ruby_core_source/{ruby-3.3.0-preview1 → ruby-3.3.0-preview3}/transcode_data.h +0 -0
  126. /data/lib/debase/ruby_core_source/{ruby-3.3.0-preview1 → ruby-3.3.0-preview3}/vm_call_iseq_optimized.inc +0 -0
  127. /data/lib/debase/ruby_core_source/{ruby-3.3.0-preview1 → ruby-3.3.0-preview3}/vm_debug.h +0 -0
  128. /data/lib/debase/ruby_core_source/{ruby-3.3.0-preview1 → ruby-3.3.0-preview3}/vm_sync.h +0 -0
  129. /data/lib/debase/ruby_core_source/{ruby-3.3.0-preview1 → ruby-3.3.0-preview3}/vmtc.inc +0 -0
data/lib/debase/ruby_core_source/{ruby-3.3.0-preview1 → ruby-3.3.0-preview3}/vm.inc RENAMED
@@ -47,16 +47,15 @@ INSN_ENTRY(nop)
47
47
 
48
48
  /* ### Declare and assign variables. ### */
49
49
  # define INSN_ATTR(x) attr_ ## x ## _nop()
50
- const bool leaf = INSN_ATTR(leaf);
50
+ const bool MAYBE_UNUSED(leaf) = INSN_ATTR(leaf);
51
51
 
52
52
  /* ### Instruction preambles. ### */
53
- if (! leaf) ADD_PC(INSN_ATTR(width));
53
+ ADD_PC(INSN_ATTR(width));
54
54
  COLLECT_USAGE_INSN(INSN_ATTR(bin));
55
55
 
56
56
  /* ### Instruction trailers. ### */
57
57
  CHECK_VM_STACK_OVERFLOW_FOR_INSN(VM_REG_CFP, INSN_ATTR(retn));
58
58
  INC_SP(INSN_ATTR(sp_inc));
59
- if (leaf) ADD_PC(INSN_ATTR(width));
60
59
  # undef INSN_ATTR
61
60
 
62
61
  /* ### Leave the instruction. ### */
@@ -74,11 +73,11 @@ INSN_ENTRY(getlocal)
74
73
  lindex_t idx = (lindex_t)GET_OPERAND(1);
75
74
  rb_num_t level = (rb_num_t)GET_OPERAND(2);
76
75
  # define INSN_ATTR(x) attr_ ## x ## _getlocal(idx, level)
77
- const bool leaf = INSN_ATTR(leaf);
76
+ const bool MAYBE_UNUSED(leaf) = INSN_ATTR(leaf);
78
77
  VALUE val;
79
78
 
80
79
  /* ### Instruction preambles. ### */
81
- if (! leaf) ADD_PC(INSN_ATTR(width));
80
+ ADD_PC(INSN_ATTR(width));
82
81
  SETUP_CANARY(leaf);
83
82
  COLLECT_USAGE_INSN(INSN_ATTR(bin));
84
83
  COLLECT_USAGE_OPERAND(INSN_ATTR(bin), 0, idx);
@@ -92,7 +91,7 @@ INSN_ENTRY(getlocal)
92
91
  RB_DEBUG_COUNTER_INC(lvar_get);
93
92
  (void)RB_DEBUG_COUNTER_INC_IF(lvar_get_dynamic, level > 0);
94
93
  }
95
- # line 96 "vm.inc"
94
+ # line 95 "vm.inc"
96
95
  # undef NAME_OF_CURRENT_INSN
97
96
 
98
97
  /* ### Instruction trailers. ### */
@@ -102,7 +101,6 @@ INSN_ENTRY(getlocal)
102
101
  TOPN(0) = val;
103
102
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_NONE));
104
103
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_MOVED));
105
- if (leaf) ADD_PC(INSN_ATTR(width));
106
104
  # undef INSN_ATTR
107
105
 
108
106
  /* ### Leave the instruction. ### */
@@ -120,11 +118,11 @@ INSN_ENTRY(setlocal)
120
118
  lindex_t idx = (lindex_t)GET_OPERAND(1);
121
119
  rb_num_t level = (rb_num_t)GET_OPERAND(2);
122
120
  # define INSN_ATTR(x) attr_ ## x ## _setlocal(idx, level)
123
- const bool leaf = INSN_ATTR(leaf);
121
+ const bool MAYBE_UNUSED(leaf) = INSN_ATTR(leaf);
124
122
  VALUE val = TOPN(0);
125
123
 
126
124
  /* ### Instruction preambles. ### */
127
- if (! leaf) ADD_PC(INSN_ATTR(width));
125
+ ADD_PC(INSN_ATTR(width));
128
126
  SETUP_CANARY(leaf);
129
127
  COLLECT_USAGE_INSN(INSN_ATTR(bin));
130
128
  COLLECT_USAGE_OPERAND(INSN_ATTR(bin), 0, idx);
@@ -138,14 +136,13 @@ INSN_ENTRY(setlocal)
138
136
  RB_DEBUG_COUNTER_INC(lvar_set);
139
137
  (void)RB_DEBUG_COUNTER_INC_IF(lvar_set_dynamic, level > 0);
140
138
  }
141
- # line 142 "vm.inc"
139
+ # line 140 "vm.inc"
142
140
  # undef NAME_OF_CURRENT_INSN
143
141
 
144
142
  /* ### Instruction trailers. ### */
145
143
  CHECK_VM_STACK_OVERFLOW_FOR_INSN(VM_REG_CFP, INSN_ATTR(retn));
146
144
  CHECK_CANARY(leaf, INSN_ATTR(bin));
147
145
  INC_SP(INSN_ATTR(sp_inc));
148
- if (leaf) ADD_PC(INSN_ATTR(width));
149
146
  # undef INSN_ATTR
150
147
 
151
148
  /* ### Leave the instruction. ### */
@@ -163,11 +160,11 @@ INSN_ENTRY(getblockparam)
163
160
  lindex_t idx = (lindex_t)GET_OPERAND(1);
164
161
  rb_num_t level = (rb_num_t)GET_OPERAND(2);
165
162
  # define INSN_ATTR(x) attr_ ## x ## _getblockparam(idx, level)
166
- const bool leaf = INSN_ATTR(leaf);
163
+ const bool MAYBE_UNUSED(leaf) = INSN_ATTR(leaf);
167
164
  VALUE val;
168
165
 
169
166
  /* ### Instruction preambles. ### */
170
- if (! leaf) ADD_PC(INSN_ATTR(width));
167
+ ADD_PC(INSN_ATTR(width));
171
168
  SETUP_CANARY(leaf);
172
169
  COLLECT_USAGE_INSN(INSN_ATTR(bin));
173
170
  COLLECT_USAGE_OPERAND(INSN_ATTR(bin), 0, idx);
@@ -191,7 +188,7 @@ INSN_ENTRY(getblockparam)
191
188
  (void)RB_DEBUG_COUNTER_INC_IF(lvar_get_dynamic, level > 0);
192
189
  }
193
190
  }
194
- # line 195 "vm.inc"
191
+ # line 192 "vm.inc"
195
192
  # undef NAME_OF_CURRENT_INSN
196
193
 
197
194
  /* ### Instruction trailers. ### */
@@ -201,7 +198,6 @@ INSN_ENTRY(getblockparam)
201
198
  TOPN(0) = val;
202
199
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_NONE));
203
200
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_MOVED));
204
- if (leaf) ADD_PC(INSN_ATTR(width));
205
201
  # undef INSN_ATTR
206
202
 
207
203
  /* ### Leave the instruction. ### */
@@ -219,11 +215,11 @@ INSN_ENTRY(setblockparam)
219
215
  lindex_t idx = (lindex_t)GET_OPERAND(1);
220
216
  rb_num_t level = (rb_num_t)GET_OPERAND(2);
221
217
  # define INSN_ATTR(x) attr_ ## x ## _setblockparam(idx, level)
222
- const bool leaf = INSN_ATTR(leaf);
218
+ const bool MAYBE_UNUSED(leaf) = INSN_ATTR(leaf);
223
219
  VALUE val = TOPN(0);
224
220
 
225
221
  /* ### Instruction preambles. ### */
226
- if (! leaf) ADD_PC(INSN_ATTR(width));
222
+ ADD_PC(INSN_ATTR(width));
227
223
  SETUP_CANARY(leaf);
228
224
  COLLECT_USAGE_INSN(INSN_ATTR(bin));
229
225
  COLLECT_USAGE_OPERAND(INSN_ATTR(bin), 0, idx);
@@ -242,14 +238,13 @@ INSN_ENTRY(setblockparam)
242
238
 
243
239
  VM_ENV_FLAGS_SET(ep, VM_FRAME_FLAG_MODIFIED_BLOCK_PARAM);
244
240
  }
245
- # line 246 "vm.inc"
241
+ # line 242 "vm.inc"
246
242
  # undef NAME_OF_CURRENT_INSN
247
243
 
248
244
  /* ### Instruction trailers. ### */
249
245
  CHECK_VM_STACK_OVERFLOW_FOR_INSN(VM_REG_CFP, INSN_ATTR(retn));
250
246
  CHECK_CANARY(leaf, INSN_ATTR(bin));
251
247
  INC_SP(INSN_ATTR(sp_inc));
252
- if (leaf) ADD_PC(INSN_ATTR(width));
253
248
  # undef INSN_ATTR
254
249
 
255
250
  /* ### Leave the instruction. ### */
@@ -267,11 +262,11 @@ INSN_ENTRY(getblockparamproxy)
267
262
  lindex_t idx = (lindex_t)GET_OPERAND(1);
268
263
  rb_num_t level = (rb_num_t)GET_OPERAND(2);
269
264
  # define INSN_ATTR(x) attr_ ## x ## _getblockparamproxy(idx, level)
270
- const bool leaf = INSN_ATTR(leaf);
265
+ const bool MAYBE_UNUSED(leaf) = INSN_ATTR(leaf);
271
266
  VALUE val;
272
267
 
273
268
  /* ### Instruction preambles. ### */
274
- if (! leaf) ADD_PC(INSN_ATTR(width));
269
+ ADD_PC(INSN_ATTR(width));
275
270
  SETUP_CANARY(leaf);
276
271
  COLLECT_USAGE_INSN(INSN_ATTR(bin));
277
272
  COLLECT_USAGE_OPERAND(INSN_ATTR(bin), 0, idx);
@@ -316,7 +311,7 @@ INSN_ENTRY(getblockparamproxy)
316
311
  (void)RB_DEBUG_COUNTER_INC_IF(lvar_get_dynamic, level > 0);
317
312
  }
318
313
  }
319
- # line 320 "vm.inc"
314
+ # line 315 "vm.inc"
320
315
  # undef NAME_OF_CURRENT_INSN
321
316
 
322
317
  /* ### Instruction trailers. ### */
@@ -326,7 +321,6 @@ INSN_ENTRY(getblockparamproxy)
326
321
  TOPN(0) = val;
327
322
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_NONE));
328
323
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_MOVED));
329
- if (leaf) ADD_PC(INSN_ATTR(width));
330
324
  # undef INSN_ATTR
331
325
 
332
326
  /* ### Leave the instruction. ### */
@@ -344,11 +338,11 @@ INSN_ENTRY(getspecial)
344
338
  rb_num_t key = (rb_num_t)GET_OPERAND(1);
345
339
  rb_num_t type = (rb_num_t)GET_OPERAND(2);
346
340
  # define INSN_ATTR(x) attr_ ## x ## _getspecial(key, type)
347
- const bool leaf = INSN_ATTR(leaf);
341
+ const bool MAYBE_UNUSED(leaf) = INSN_ATTR(leaf);
348
342
  VALUE val;
349
343
 
350
344
  /* ### Instruction preambles. ### */
351
- if (! leaf) ADD_PC(INSN_ATTR(width));
345
+ ADD_PC(INSN_ATTR(width));
352
346
  SETUP_CANARY(leaf);
353
347
  COLLECT_USAGE_INSN(INSN_ATTR(bin));
354
348
  COLLECT_USAGE_OPERAND(INSN_ATTR(bin), 0, key);
@@ -360,7 +354,7 @@ INSN_ENTRY(getspecial)
360
354
  {
361
355
  val = vm_getspecial(ec, GET_LEP(), key, type);
362
356
  }
363
- # line 364 "vm.inc"
357
+ # line 358 "vm.inc"
364
358
  # undef NAME_OF_CURRENT_INSN
365
359
 
366
360
  /* ### Instruction trailers. ### */
@@ -370,7 +364,6 @@ INSN_ENTRY(getspecial)
370
364
  TOPN(0) = val;
371
365
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_NONE));
372
366
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_MOVED));
373
- if (leaf) ADD_PC(INSN_ATTR(width));
374
367
  # undef INSN_ATTR
375
368
 
376
369
  /* ### Leave the instruction. ### */
@@ -387,11 +380,11 @@ INSN_ENTRY(setspecial)
387
380
  /* ### Declare and assign variables. ### */
388
381
  rb_num_t key = (rb_num_t)GET_OPERAND(1);
389
382
  # define INSN_ATTR(x) attr_ ## x ## _setspecial(key)
390
- const bool leaf = INSN_ATTR(leaf);
383
+ const bool MAYBE_UNUSED(leaf) = INSN_ATTR(leaf);
391
384
  VALUE obj = TOPN(0);
392
385
 
393
386
  /* ### Instruction preambles. ### */
394
- if (! leaf) ADD_PC(INSN_ATTR(width));
387
+ ADD_PC(INSN_ATTR(width));
395
388
  SETUP_CANARY(leaf);
396
389
  COLLECT_USAGE_INSN(INSN_ATTR(bin));
397
390
  COLLECT_USAGE_OPERAND(INSN_ATTR(bin), 0, key);
@@ -402,14 +395,13 @@ INSN_ENTRY(setspecial)
402
395
  {
403
396
  lep_svar_set(ec, GET_LEP(), key, obj);
404
397
  }
405
- # line 406 "vm.inc"
398
+ # line 399 "vm.inc"
406
399
  # undef NAME_OF_CURRENT_INSN
407
400
 
408
401
  /* ### Instruction trailers. ### */
409
402
  CHECK_VM_STACK_OVERFLOW_FOR_INSN(VM_REG_CFP, INSN_ATTR(retn));
410
403
  CHECK_CANARY(leaf, INSN_ATTR(bin));
411
404
  INC_SP(INSN_ATTR(sp_inc));
412
- if (leaf) ADD_PC(INSN_ATTR(width));
413
405
  # undef INSN_ATTR
414
406
 
415
407
  /* ### Leave the instruction. ### */
@@ -427,11 +419,11 @@ INSN_ENTRY(getinstancevariable)
427
419
  ID id = (ID)GET_OPERAND(1);
428
420
  IVC ic = (IVC)GET_OPERAND(2);
429
421
  # define INSN_ATTR(x) attr_ ## x ## _getinstancevariable(id, ic)
430
- const bool leaf = INSN_ATTR(leaf);
422
+ const bool MAYBE_UNUSED(leaf) = INSN_ATTR(leaf);
431
423
  VALUE val;
432
424
 
433
425
  /* ### Instruction preambles. ### */
434
- if (! leaf) ADD_PC(INSN_ATTR(width));
426
+ ADD_PC(INSN_ATTR(width));
435
427
  SETUP_CANARY(leaf);
436
428
  COLLECT_USAGE_INSN(INSN_ATTR(bin));
437
429
  COLLECT_USAGE_OPERAND(INSN_ATTR(bin), 0, id);
@@ -443,7 +435,7 @@ INSN_ENTRY(getinstancevariable)
443
435
  {
444
436
  val = vm_getinstancevariable(GET_ISEQ(), GET_SELF(), id, ic);
445
437
  }
446
- # line 447 "vm.inc"
438
+ # line 439 "vm.inc"
447
439
  # undef NAME_OF_CURRENT_INSN
448
440
 
449
441
  /* ### Instruction trailers. ### */
@@ -453,7 +445,6 @@ INSN_ENTRY(getinstancevariable)
453
445
  TOPN(0) = val;
454
446
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_NONE));
455
447
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_MOVED));
456
- if (leaf) ADD_PC(INSN_ATTR(width));
457
448
  # undef INSN_ATTR
458
449
 
459
450
  /* ### Leave the instruction. ### */
@@ -471,11 +462,11 @@ INSN_ENTRY(setinstancevariable)
471
462
  ID id = (ID)GET_OPERAND(1);
472
463
  IVC ic = (IVC)GET_OPERAND(2);
473
464
  # define INSN_ATTR(x) attr_ ## x ## _setinstancevariable(id, ic)
474
- const bool leaf = INSN_ATTR(leaf);
465
+ const bool MAYBE_UNUSED(leaf) = INSN_ATTR(leaf);
475
466
  VALUE val = TOPN(0);
476
467
 
477
468
  /* ### Instruction preambles. ### */
478
- if (! leaf) ADD_PC(INSN_ATTR(width));
469
+ ADD_PC(INSN_ATTR(width));
479
470
  SETUP_CANARY(leaf);
480
471
  COLLECT_USAGE_INSN(INSN_ATTR(bin));
481
472
  COLLECT_USAGE_OPERAND(INSN_ATTR(bin), 0, id);
@@ -487,14 +478,13 @@ INSN_ENTRY(setinstancevariable)
487
478
  {
488
479
  vm_setinstancevariable(GET_ISEQ(), GET_SELF(), id, val, ic);
489
480
  }
490
- # line 491 "vm.inc"
481
+ # line 482 "vm.inc"
491
482
  # undef NAME_OF_CURRENT_INSN
492
483
 
493
484
  /* ### Instruction trailers. ### */
494
485
  CHECK_VM_STACK_OVERFLOW_FOR_INSN(VM_REG_CFP, INSN_ATTR(retn));
495
486
  CHECK_CANARY(leaf, INSN_ATTR(bin));
496
487
  INC_SP(INSN_ATTR(sp_inc));
497
- if (leaf) ADD_PC(INSN_ATTR(width));
498
488
  # undef INSN_ATTR
499
489
 
500
490
  /* ### Leave the instruction. ### */
@@ -512,11 +502,11 @@ INSN_ENTRY(getclassvariable)
512
502
  ID id = (ID)GET_OPERAND(1);
513
503
  ICVARC ic = (ICVARC)GET_OPERAND(2);
514
504
  # define INSN_ATTR(x) attr_ ## x ## _getclassvariable(id, ic)
515
- const bool leaf = INSN_ATTR(leaf);
505
+ const bool MAYBE_UNUSED(leaf) = INSN_ATTR(leaf);
516
506
  VALUE val;
517
507
 
518
508
  /* ### Instruction preambles. ### */
519
- if (! leaf) ADD_PC(INSN_ATTR(width));
509
+ ADD_PC(INSN_ATTR(width));
520
510
  SETUP_CANARY(leaf);
521
511
  COLLECT_USAGE_INSN(INSN_ATTR(bin));
522
512
  COLLECT_USAGE_OPERAND(INSN_ATTR(bin), 0, id);
@@ -529,7 +519,7 @@ INSN_ENTRY(getclassvariable)
529
519
  rb_control_frame_t *cfp = GET_CFP();
530
520
  val = vm_getclassvariable(GET_ISEQ(), cfp, id, ic);
531
521
  }
532
- # line 533 "vm.inc"
522
+ # line 523 "vm.inc"
533
523
  # undef NAME_OF_CURRENT_INSN
534
524
 
535
525
  /* ### Instruction trailers. ### */
@@ -539,7 +529,6 @@ INSN_ENTRY(getclassvariable)
539
529
  TOPN(0) = val;
540
530
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_NONE));
541
531
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_MOVED));
542
- if (leaf) ADD_PC(INSN_ATTR(width));
543
532
  # undef INSN_ATTR
544
533
 
545
534
  /* ### Leave the instruction. ### */
@@ -557,11 +546,11 @@ INSN_ENTRY(setclassvariable)
557
546
  ID id = (ID)GET_OPERAND(1);
558
547
  ICVARC ic = (ICVARC)GET_OPERAND(2);
559
548
  # define INSN_ATTR(x) attr_ ## x ## _setclassvariable(id, ic)
560
- const bool leaf = INSN_ATTR(leaf);
549
+ const bool MAYBE_UNUSED(leaf) = INSN_ATTR(leaf);
561
550
  VALUE val = TOPN(0);
562
551
 
563
552
  /* ### Instruction preambles. ### */
564
- if (! leaf) ADD_PC(INSN_ATTR(width));
553
+ ADD_PC(INSN_ATTR(width));
565
554
  SETUP_CANARY(leaf);
566
555
  COLLECT_USAGE_INSN(INSN_ATTR(bin));
567
556
  COLLECT_USAGE_OPERAND(INSN_ATTR(bin), 0, id);
@@ -574,14 +563,13 @@ INSN_ENTRY(setclassvariable)
574
563
  vm_ensure_not_refinement_module(GET_SELF());
575
564
  vm_setclassvariable(GET_ISEQ(), GET_CFP(), id, val, ic);
576
565
  }
577
- # line 578 "vm.inc"
566
+ # line 567 "vm.inc"
578
567
  # undef NAME_OF_CURRENT_INSN
579
568
 
580
569
  /* ### Instruction trailers. ### */
581
570
  CHECK_VM_STACK_OVERFLOW_FOR_INSN(VM_REG_CFP, INSN_ATTR(retn));
582
571
  CHECK_CANARY(leaf, INSN_ATTR(bin));
583
572
  INC_SP(INSN_ATTR(sp_inc));
584
- if (leaf) ADD_PC(INSN_ATTR(width));
585
573
  # undef INSN_ATTR
586
574
 
587
575
  /* ### Leave the instruction. ### */
@@ -598,11 +586,11 @@ INSN_ENTRY(opt_getconstant_path)
598
586
  /* ### Declare and assign variables. ### */
599
587
  IC ic = (IC)GET_OPERAND(1);
600
588
  # define INSN_ATTR(x) attr_ ## x ## _opt_getconstant_path(ic)
601
- const bool leaf = INSN_ATTR(leaf);
589
+ const bool MAYBE_UNUSED(leaf) = INSN_ATTR(leaf);
602
590
  VALUE val;
603
591
 
604
592
  /* ### Instruction preambles. ### */
605
- if (! leaf) ADD_PC(INSN_ATTR(width));
593
+ ADD_PC(INSN_ATTR(width));
606
594
  SETUP_CANARY(leaf);
607
595
  COLLECT_USAGE_INSN(INSN_ATTR(bin));
608
596
  COLLECT_USAGE_OPERAND(INSN_ATTR(bin), 0, ic);
@@ -611,22 +599,9 @@ INSN_ENTRY(opt_getconstant_path)
611
599
  # define NAME_OF_CURRENT_INSN opt_getconstant_path
612
600
  # line 262 "insns.def"
613
601
  {
614
- const ID *segments = ic->segments;
615
- struct iseq_inline_constant_cache_entry *ice = ic->entry;
616
- if (ice && vm_ic_hit_p(ice, GET_EP())) {
617
- val = ice->value;
618
-
619
- VM_ASSERT(val == vm_get_ev_const_chain(ec, segments));
620
- } else {
621
- ruby_vm_constant_cache_misses++;
622
- val = vm_get_ev_const_chain(ec, segments);
623
- vm_ic_track_const_chain(GET_CFP(), ic, segments);
624
- // Because leaf=false, we need to undo the PC increment to get the address to this instruction
625
- // INSN_ATTR(width) == 2
626
- vm_ic_update(GET_ISEQ(), ic, val, GET_EP(), GET_PC() - 2);
627
- }
602
+ val = rb_vm_opt_getconstant_path(ec, GET_CFP(), ic);
628
603
  }
629
- # line 630 "vm.inc"
604
+ # line 605 "vm.inc"
630
605
  # undef NAME_OF_CURRENT_INSN
631
606
 
632
607
  /* ### Instruction trailers. ### */
@@ -636,7 +611,6 @@ INSN_ENTRY(opt_getconstant_path)
636
611
  TOPN(0) = val;
637
612
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_NONE));
638
613
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_MOVED));
639
- if (leaf) ADD_PC(INSN_ATTR(width));
640
614
  # undef INSN_ATTR
641
615
 
642
616
  /* ### Leave the instruction. ### */
@@ -653,24 +627,24 @@ INSN_ENTRY(getconstant)
653
627
  /* ### Declare and assign variables. ### */
654
628
  ID id = (ID)GET_OPERAND(1);
655
629
  # define INSN_ATTR(x) attr_ ## x ## _getconstant(id)
656
- const bool leaf = INSN_ATTR(leaf);
630
+ const bool MAYBE_UNUSED(leaf) = INSN_ATTR(leaf);
657
631
  VALUE klass = TOPN(1);
658
632
  VALUE allow_nil = TOPN(0);
659
633
  VALUE val;
660
634
 
661
635
  /* ### Instruction preambles. ### */
662
- if (! leaf) ADD_PC(INSN_ATTR(width));
636
+ ADD_PC(INSN_ATTR(width));
663
637
  SETUP_CANARY(leaf);
664
638
  COLLECT_USAGE_INSN(INSN_ATTR(bin));
665
639
  COLLECT_USAGE_OPERAND(INSN_ATTR(bin), 0, id);
666
640
 
667
641
  /* ### Here we do the instruction body. ### */
668
642
  # define NAME_OF_CURRENT_INSN getconstant
669
- # line 290 "insns.def"
643
+ # line 277 "insns.def"
670
644
  {
671
645
  val = vm_get_ev_const(ec, klass, id, allow_nil == Qtrue, 0);
672
646
  }
673
- # line 674 "vm.inc"
647
+ # line 648 "vm.inc"
674
648
  # undef NAME_OF_CURRENT_INSN
675
649
 
676
650
  /* ### Instruction trailers. ### */
@@ -680,7 +654,6 @@ INSN_ENTRY(getconstant)
680
654
  TOPN(0) = val;
681
655
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_NONE));
682
656
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_MOVED));
683
- if (leaf) ADD_PC(INSN_ATTR(width));
684
657
  # undef INSN_ATTR
685
658
 
686
659
  /* ### Leave the instruction. ### */
@@ -697,32 +670,31 @@ INSN_ENTRY(setconstant)
697
670
  /* ### Declare and assign variables. ### */
698
671
  ID id = (ID)GET_OPERAND(1);
699
672
  # define INSN_ATTR(x) attr_ ## x ## _setconstant(id)
700
- const bool leaf = INSN_ATTR(leaf);
673
+ const bool MAYBE_UNUSED(leaf) = INSN_ATTR(leaf);
701
674
  VALUE val = TOPN(1);
702
675
  VALUE cbase = TOPN(0);
703
676
 
704
677
  /* ### Instruction preambles. ### */
705
- if (! leaf) ADD_PC(INSN_ATTR(width));
678
+ ADD_PC(INSN_ATTR(width));
706
679
  SETUP_CANARY(leaf);
707
680
  COLLECT_USAGE_INSN(INSN_ATTR(bin));
708
681
  COLLECT_USAGE_OPERAND(INSN_ATTR(bin), 0, id);
709
682
 
710
683
  /* ### Here we do the instruction body. ### */
711
684
  # define NAME_OF_CURRENT_INSN setconstant
712
- # line 306 "insns.def"
685
+ # line 293 "insns.def"
713
686
  {
714
687
  vm_check_if_namespace(cbase);
715
688
  vm_ensure_not_refinement_module(GET_SELF());
716
689
  rb_const_set(cbase, id, val);
717
690
  }
718
- # line 719 "vm.inc"
691
+ # line 692 "vm.inc"
719
692
  # undef NAME_OF_CURRENT_INSN
720
693
 
721
694
  /* ### Instruction trailers. ### */
722
695
  CHECK_VM_STACK_OVERFLOW_FOR_INSN(VM_REG_CFP, INSN_ATTR(retn));
723
696
  CHECK_CANARY(leaf, INSN_ATTR(bin));
724
697
  INC_SP(INSN_ATTR(sp_inc));
725
- if (leaf) ADD_PC(INSN_ATTR(width));
726
698
  # undef INSN_ATTR
727
699
 
728
700
  /* ### Leave the instruction. ### */
@@ -739,22 +711,22 @@ INSN_ENTRY(getglobal)
739
711
  /* ### Declare and assign variables. ### */
740
712
  ID gid = (ID)GET_OPERAND(1);
741
713
  # define INSN_ATTR(x) attr_ ## x ## _getglobal(gid)
742
- const bool leaf = INSN_ATTR(leaf);
714
+ const bool MAYBE_UNUSED(leaf) = INSN_ATTR(leaf);
743
715
  VALUE val;
744
716
 
745
717
  /* ### Instruction preambles. ### */
746
- if (! leaf) ADD_PC(INSN_ATTR(width));
718
+ ADD_PC(INSN_ATTR(width));
747
719
  SETUP_CANARY(leaf);
748
720
  COLLECT_USAGE_INSN(INSN_ATTR(bin));
749
721
  COLLECT_USAGE_OPERAND(INSN_ATTR(bin), 0, gid);
750
722
 
751
723
  /* ### Here we do the instruction body. ### */
752
724
  # define NAME_OF_CURRENT_INSN getglobal
753
- # line 319 "insns.def"
725
+ # line 306 "insns.def"
754
726
  {
755
727
  val = rb_gvar_get(gid);
756
728
  }
757
- # line 758 "vm.inc"
729
+ # line 730 "vm.inc"
758
730
  # undef NAME_OF_CURRENT_INSN
759
731
 
760
732
  /* ### Instruction trailers. ### */
@@ -764,7 +736,6 @@ INSN_ENTRY(getglobal)
764
736
  TOPN(0) = val;
765
737
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_NONE));
766
738
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_MOVED));
767
- if (leaf) ADD_PC(INSN_ATTR(width));
768
739
  # undef INSN_ATTR
769
740
 
770
741
  /* ### Leave the instruction. ### */
@@ -781,29 +752,28 @@ INSN_ENTRY(setglobal)
781
752
  /* ### Declare and assign variables. ### */
782
753
  ID gid = (ID)GET_OPERAND(1);
783
754
  # define INSN_ATTR(x) attr_ ## x ## _setglobal(gid)
784
- const bool leaf = INSN_ATTR(leaf);
755
+ const bool MAYBE_UNUSED(leaf) = INSN_ATTR(leaf);
785
756
  VALUE val = TOPN(0);
786
757
 
787
758
  /* ### Instruction preambles. ### */
788
- if (! leaf) ADD_PC(INSN_ATTR(width));
759
+ ADD_PC(INSN_ATTR(width));
789
760
  SETUP_CANARY(leaf);
790
761
  COLLECT_USAGE_INSN(INSN_ATTR(bin));
791
762
  COLLECT_USAGE_OPERAND(INSN_ATTR(bin), 0, gid);
792
763
 
793
764
  /* ### Here we do the instruction body. ### */
794
765
  # define NAME_OF_CURRENT_INSN setglobal
795
- # line 330 "insns.def"
766
+ # line 317 "insns.def"
796
767
  {
797
768
  rb_gvar_set(gid, val);
798
769
  }
799
- # line 800 "vm.inc"
770
+ # line 771 "vm.inc"
800
771
  # undef NAME_OF_CURRENT_INSN
801
772
 
802
773
  /* ### Instruction trailers. ### */
803
774
  CHECK_VM_STACK_OVERFLOW_FOR_INSN(VM_REG_CFP, INSN_ATTR(retn));
804
775
  CHECK_CANARY(leaf, INSN_ATTR(bin));
805
776
  INC_SP(INSN_ATTR(sp_inc));
806
- if (leaf) ADD_PC(INSN_ATTR(width));
807
777
  # undef INSN_ATTR
808
778
 
809
779
  /* ### Leave the instruction. ### */
@@ -819,21 +789,21 @@ INSN_ENTRY(putnil)
819
789
 
820
790
  /* ### Declare and assign variables. ### */
821
791
  # define INSN_ATTR(x) attr_ ## x ## _putnil()
822
- const bool leaf = INSN_ATTR(leaf);
792
+ const bool MAYBE_UNUSED(leaf) = INSN_ATTR(leaf);
823
793
  VALUE val;
824
794
 
825
795
  /* ### Instruction preambles. ### */
826
- if (! leaf) ADD_PC(INSN_ATTR(width));
796
+ ADD_PC(INSN_ATTR(width));
827
797
  SETUP_CANARY(leaf);
828
798
  COLLECT_USAGE_INSN(INSN_ATTR(bin));
829
799
 
830
800
  /* ### Here we do the instruction body. ### */
831
801
  # define NAME_OF_CURRENT_INSN putnil
832
- # line 344 "insns.def"
802
+ # line 331 "insns.def"
833
803
  {
834
804
  val = Qnil;
835
805
  }
836
- # line 837 "vm.inc"
806
+ # line 807 "vm.inc"
837
807
  # undef NAME_OF_CURRENT_INSN
838
808
 
839
809
  /* ### Instruction trailers. ### */
@@ -843,7 +813,6 @@ INSN_ENTRY(putnil)
843
813
  TOPN(0) = val;
844
814
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_NONE));
845
815
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_MOVED));
846
- if (leaf) ADD_PC(INSN_ATTR(width));
847
816
  # undef INSN_ATTR
848
817
 
849
818
  /* ### Leave the instruction. ### */
@@ -859,21 +828,21 @@ INSN_ENTRY(putself)
859
828
 
860
829
  /* ### Declare and assign variables. ### */
861
830
  # define INSN_ATTR(x) attr_ ## x ## _putself()
862
- const bool leaf = INSN_ATTR(leaf);
831
+ const bool MAYBE_UNUSED(leaf) = INSN_ATTR(leaf);
863
832
  VALUE val;
864
833
 
865
834
  /* ### Instruction preambles. ### */
866
- if (! leaf) ADD_PC(INSN_ATTR(width));
835
+ ADD_PC(INSN_ATTR(width));
867
836
  SETUP_CANARY(leaf);
868
837
  COLLECT_USAGE_INSN(INSN_ATTR(bin));
869
838
 
870
839
  /* ### Here we do the instruction body. ### */
871
840
  # define NAME_OF_CURRENT_INSN putself
872
- # line 354 "insns.def"
841
+ # line 341 "insns.def"
873
842
  {
874
843
  val = GET_SELF();
875
844
  }
876
- # line 877 "vm.inc"
845
+ # line 846 "vm.inc"
877
846
  # undef NAME_OF_CURRENT_INSN
878
847
 
879
848
  /* ### Instruction trailers. ### */
@@ -883,7 +852,6 @@ INSN_ENTRY(putself)
883
852
  TOPN(0) = val;
884
853
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_NONE));
885
854
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_MOVED));
886
- if (leaf) ADD_PC(INSN_ATTR(width));
887
855
  # undef INSN_ATTR
888
856
 
889
857
  /* ### Leave the instruction. ### */
@@ -900,10 +868,10 @@ INSN_ENTRY(putobject)
900
868
  /* ### Declare and assign variables. ### */
901
869
  VALUE val = (VALUE)GET_OPERAND(1);
902
870
  # define INSN_ATTR(x) attr_ ## x ## _putobject(val)
903
- const bool leaf = INSN_ATTR(leaf);
871
+ const bool MAYBE_UNUSED(leaf) = INSN_ATTR(leaf);
904
872
 
905
873
  /* ### Instruction preambles. ### */
906
- if (! leaf) ADD_PC(INSN_ATTR(width));
874
+ ADD_PC(INSN_ATTR(width));
907
875
  COLLECT_USAGE_INSN(INSN_ATTR(bin));
908
876
  COLLECT_USAGE_OPERAND(INSN_ATTR(bin), 0, val);
909
877
 
@@ -913,7 +881,6 @@ INSN_ENTRY(putobject)
913
881
  TOPN(0) = val;
914
882
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_NONE));
915
883
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_MOVED));
916
- if (leaf) ADD_PC(INSN_ATTR(width));
917
884
  # undef INSN_ATTR
918
885
 
919
886
  /* ### Leave the instruction. ### */
@@ -930,25 +897,25 @@ INSN_ENTRY(putspecialobject)
930
897
  /* ### Declare and assign variables. ### */
931
898
  rb_num_t value_type = (rb_num_t)GET_OPERAND(1);
932
899
  # define INSN_ATTR(x) attr_ ## x ## _putspecialobject(value_type)
933
- const bool leaf = INSN_ATTR(leaf);
900
+ const bool MAYBE_UNUSED(leaf) = INSN_ATTR(leaf);
934
901
  VALUE val;
935
902
 
936
903
  /* ### Instruction preambles. ### */
937
- if (! leaf) ADD_PC(INSN_ATTR(width));
904
+ ADD_PC(INSN_ATTR(width));
938
905
  SETUP_CANARY(leaf);
939
906
  COLLECT_USAGE_INSN(INSN_ATTR(bin));
940
907
  COLLECT_USAGE_OPERAND(INSN_ATTR(bin), 0, value_type);
941
908
 
942
909
  /* ### Here we do the instruction body. ### */
943
910
  # define NAME_OF_CURRENT_INSN putspecialobject
944
- # line 377 "insns.def"
911
+ # line 364 "insns.def"
945
912
  {
946
913
  enum vm_special_object_type type;
947
914
 
948
915
  type = (enum vm_special_object_type)value_type;
949
916
  val = vm_get_special_object(GET_EP(), type);
950
917
  }
951
- # line 952 "vm.inc"
918
+ # line 919 "vm.inc"
952
919
  # undef NAME_OF_CURRENT_INSN
953
920
 
954
921
  /* ### Instruction trailers. ### */
@@ -958,7 +925,6 @@ INSN_ENTRY(putspecialobject)
958
925
  TOPN(0) = val;
959
926
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_NONE));
960
927
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_MOVED));
961
- if (leaf) ADD_PC(INSN_ATTR(width));
962
928
  # undef INSN_ATTR
963
929
 
964
930
  /* ### Leave the instruction. ### */
@@ -975,22 +941,22 @@ INSN_ENTRY(putstring)
975
941
  /* ### Declare and assign variables. ### */
976
942
  VALUE str = (VALUE)GET_OPERAND(1);
977
943
  # define INSN_ATTR(x) attr_ ## x ## _putstring(str)
978
- const bool leaf = INSN_ATTR(leaf);
944
+ const bool MAYBE_UNUSED(leaf) = INSN_ATTR(leaf);
979
945
  VALUE val;
980
946
 
981
947
  /* ### Instruction preambles. ### */
982
- if (! leaf) ADD_PC(INSN_ATTR(width));
948
+ ADD_PC(INSN_ATTR(width));
983
949
  SETUP_CANARY(leaf);
984
950
  COLLECT_USAGE_INSN(INSN_ATTR(bin));
985
951
  COLLECT_USAGE_OPERAND(INSN_ATTR(bin), 0, str);
986
952
 
987
953
  /* ### Here we do the instruction body. ### */
988
954
  # define NAME_OF_CURRENT_INSN putstring
989
- # line 390 "insns.def"
955
+ # line 377 "insns.def"
990
956
  {
991
957
  val = rb_ec_str_resurrect(ec, str);
992
958
  }
993
- # line 994 "vm.inc"
959
+ # line 960 "vm.inc"
994
960
  # undef NAME_OF_CURRENT_INSN
995
961
 
996
962
  /* ### Instruction trailers. ### */
@@ -1000,7 +966,6 @@ INSN_ENTRY(putstring)
1000
966
  TOPN(0) = val;
1001
967
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_NONE));
1002
968
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_MOVED));
1003
- if (leaf) ADD_PC(INSN_ATTR(width));
1004
969
  # undef INSN_ATTR
1005
970
 
1006
971
  /* ### Leave the instruction. ### */
@@ -1017,22 +982,22 @@ INSN_ENTRY(concatstrings)
1017
982
  /* ### Declare and assign variables. ### */
1018
983
  rb_num_t num = (rb_num_t)GET_OPERAND(1);
1019
984
  # define INSN_ATTR(x) attr_ ## x ## _concatstrings(num)
1020
- const bool leaf = INSN_ATTR(leaf);
985
+ const bool MAYBE_UNUSED(leaf) = INSN_ATTR(leaf);
1021
986
  VALUE val;
1022
987
 
1023
988
  /* ### Instruction preambles. ### */
1024
- if (! leaf) ADD_PC(INSN_ATTR(width));
989
+ ADD_PC(INSN_ATTR(width));
1025
990
  SETUP_CANARY(leaf);
1026
991
  COLLECT_USAGE_INSN(INSN_ATTR(bin));
1027
992
  COLLECT_USAGE_OPERAND(INSN_ATTR(bin), 0, num);
1028
993
 
1029
994
  /* ### Here we do the instruction body. ### */
1030
995
  # define NAME_OF_CURRENT_INSN concatstrings
1031
- # line 404 "insns.def"
996
+ # line 391 "insns.def"
1032
997
  {
1033
998
  val = rb_str_concat_literals(num, STACK_ADDR_FROM_TOP(num));
1034
999
  }
1035
- # line 1036 "vm.inc"
1000
+ # line 1001 "vm.inc"
1036
1001
  # undef NAME_OF_CURRENT_INSN
1037
1002
 
1038
1003
  /* ### Instruction trailers. ### */
@@ -1042,7 +1007,6 @@ INSN_ENTRY(concatstrings)
1042
1007
  TOPN(0) = val;
1043
1008
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_NONE));
1044
1009
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_MOVED));
1045
- if (leaf) ADD_PC(INSN_ATTR(width));
1046
1010
  # undef INSN_ATTR
1047
1011
 
1048
1012
  /* ### Leave the instruction. ### */
@@ -1058,22 +1022,22 @@ INSN_ENTRY(anytostring)
1058
1022
 
1059
1023
  /* ### Declare and assign variables. ### */
1060
1024
  # define INSN_ATTR(x) attr_ ## x ## _anytostring()
1061
- const bool leaf = INSN_ATTR(leaf);
1025
+ const bool MAYBE_UNUSED(leaf) = INSN_ATTR(leaf);
1062
1026
  VALUE val = TOPN(1);
1063
1027
  VALUE str = TOPN(0);
1064
1028
 
1065
1029
  /* ### Instruction preambles. ### */
1066
- if (! leaf) ADD_PC(INSN_ATTR(width));
1030
+ ADD_PC(INSN_ATTR(width));
1067
1031
  SETUP_CANARY(leaf);
1068
1032
  COLLECT_USAGE_INSN(INSN_ATTR(bin));
1069
1033
 
1070
1034
  /* ### Here we do the instruction body. ### */
1071
1035
  # define NAME_OF_CURRENT_INSN anytostring
1072
- # line 415 "insns.def"
1036
+ # line 402 "insns.def"
1073
1037
  {
1074
1038
  val = rb_obj_as_string_result(str, val);
1075
1039
  }
1076
- # line 1077 "vm.inc"
1040
+ # line 1041 "vm.inc"
1077
1041
  # undef NAME_OF_CURRENT_INSN
1078
1042
 
1079
1043
  /* ### Instruction trailers. ### */
@@ -1083,7 +1047,6 @@ INSN_ENTRY(anytostring)
1083
1047
  TOPN(0) = val;
1084
1048
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_NONE));
1085
1049
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_MOVED));
1086
- if (leaf) ADD_PC(INSN_ATTR(width));
1087
1050
  # undef INSN_ATTR
1088
1051
 
1089
1052
  /* ### Leave the instruction. ### */
@@ -1101,11 +1064,11 @@ INSN_ENTRY(toregexp)
1101
1064
  rb_num_t opt = (rb_num_t)GET_OPERAND(1);
1102
1065
  rb_num_t cnt = (rb_num_t)GET_OPERAND(2);
1103
1066
  # define INSN_ATTR(x) attr_ ## x ## _toregexp(opt, cnt)
1104
- const bool leaf = INSN_ATTR(leaf);
1067
+ const bool MAYBE_UNUSED(leaf) = INSN_ATTR(leaf);
1105
1068
  VALUE val;
1106
1069
 
1107
1070
  /* ### Instruction preambles. ### */
1108
- if (! leaf) ADD_PC(INSN_ATTR(width));
1071
+ ADD_PC(INSN_ATTR(width));
1109
1072
  SETUP_CANARY(leaf);
1110
1073
  COLLECT_USAGE_INSN(INSN_ATTR(bin));
1111
1074
  COLLECT_USAGE_OPERAND(INSN_ATTR(bin), 0, opt);
@@ -1113,13 +1076,13 @@ INSN_ENTRY(toregexp)
1113
1076
 
1114
1077
  /* ### Here we do the instruction body. ### */
1115
1078
  # define NAME_OF_CURRENT_INSN toregexp
1116
- # line 431 "insns.def"
1079
+ # line 418 "insns.def"
1117
1080
  {
1118
1081
  const VALUE ary = rb_ary_tmp_new_from_values(0, cnt, STACK_ADDR_FROM_TOP(cnt));
1119
1082
  val = rb_reg_new_ary(ary, (int)opt);
1120
1083
  rb_ary_clear(ary);
1121
1084
  }
1122
- # line 1123 "vm.inc"
1085
+ # line 1086 "vm.inc"
1123
1086
  # undef NAME_OF_CURRENT_INSN
1124
1087
 
1125
1088
  /* ### Instruction trailers. ### */
@@ -1129,7 +1092,6 @@ INSN_ENTRY(toregexp)
1129
1092
  TOPN(0) = val;
1130
1093
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_NONE));
1131
1094
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_MOVED));
1132
- if (leaf) ADD_PC(INSN_ATTR(width));
1133
1095
  # undef INSN_ATTR
1134
1096
 
1135
1097
  /* ### Leave the instruction. ### */
@@ -1145,22 +1107,22 @@ INSN_ENTRY(intern)
1145
1107
 
1146
1108
  /* ### Declare and assign variables. ### */
1147
1109
  # define INSN_ATTR(x) attr_ ## x ## _intern()
1148
- const bool leaf = INSN_ATTR(leaf);
1110
+ const bool MAYBE_UNUSED(leaf) = INSN_ATTR(leaf);
1149
1111
  VALUE str = TOPN(0);
1150
1112
  VALUE sym;
1151
1113
 
1152
1114
  /* ### Instruction preambles. ### */
1153
- if (! leaf) ADD_PC(INSN_ATTR(width));
1115
+ ADD_PC(INSN_ATTR(width));
1154
1116
  SETUP_CANARY(leaf);
1155
1117
  COLLECT_USAGE_INSN(INSN_ATTR(bin));
1156
1118
 
1157
1119
  /* ### Here we do the instruction body. ### */
1158
1120
  # define NAME_OF_CURRENT_INSN intern
1159
- # line 443 "insns.def"
1121
+ # line 430 "insns.def"
1160
1122
  {
1161
1123
  sym = rb_str_intern(str);
1162
1124
  }
1163
- # line 1164 "vm.inc"
1125
+ # line 1126 "vm.inc"
1164
1126
  # undef NAME_OF_CURRENT_INSN
1165
1127
 
1166
1128
  /* ### Instruction trailers. ### */
@@ -1170,7 +1132,6 @@ INSN_ENTRY(intern)
1170
1132
  TOPN(0) = sym;
1171
1133
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_NONE));
1172
1134
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_MOVED));
1173
- if (leaf) ADD_PC(INSN_ATTR(width));
1174
1135
  # undef INSN_ATTR
1175
1136
 
1176
1137
  /* ### Leave the instruction. ### */
@@ -1187,22 +1148,22 @@ INSN_ENTRY(newarray)
1187
1148
  /* ### Declare and assign variables. ### */
1188
1149
  rb_num_t num = (rb_num_t)GET_OPERAND(1);
1189
1150
  # define INSN_ATTR(x) attr_ ## x ## _newarray(num)
1190
- const bool leaf = INSN_ATTR(leaf);
1151
+ const bool MAYBE_UNUSED(leaf) = INSN_ATTR(leaf);
1191
1152
  VALUE val;
1192
1153
 
1193
1154
  /* ### Instruction preambles. ### */
1194
- if (! leaf) ADD_PC(INSN_ATTR(width));
1155
+ ADD_PC(INSN_ATTR(width));
1195
1156
  SETUP_CANARY(leaf);
1196
1157
  COLLECT_USAGE_INSN(INSN_ATTR(bin));
1197
1158
  COLLECT_USAGE_OPERAND(INSN_ATTR(bin), 0, num);
1198
1159
 
1199
1160
  /* ### Here we do the instruction body. ### */
1200
1161
  # define NAME_OF_CURRENT_INSN newarray
1201
- # line 454 "insns.def"
1162
+ # line 441 "insns.def"
1202
1163
  {
1203
1164
  val = rb_ec_ary_new_from_values(ec, num, STACK_ADDR_FROM_TOP(num));
1204
1165
  }
1205
- # line 1206 "vm.inc"
1166
+ # line 1167 "vm.inc"
1206
1167
  # undef NAME_OF_CURRENT_INSN
1207
1168
 
1208
1169
  /* ### Instruction trailers. ### */
@@ -1212,7 +1173,6 @@ INSN_ENTRY(newarray)
1212
1173
  TOPN(0) = val;
1213
1174
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_NONE));
1214
1175
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_MOVED));
1215
- if (leaf) ADD_PC(INSN_ATTR(width));
1216
1176
  # undef INSN_ATTR
1217
1177
 
1218
1178
  /* ### Leave the instruction. ### */
@@ -1229,18 +1189,18 @@ INSN_ENTRY(newarraykwsplat)
1229
1189
  /* ### Declare and assign variables. ### */
1230
1190
  rb_num_t num = (rb_num_t)GET_OPERAND(1);
1231
1191
  # define INSN_ATTR(x) attr_ ## x ## _newarraykwsplat(num)
1232
- const bool leaf = INSN_ATTR(leaf);
1192
+ const bool MAYBE_UNUSED(leaf) = INSN_ATTR(leaf);
1233
1193
  VALUE val;
1234
1194
 
1235
1195
  /* ### Instruction preambles. ### */
1236
- if (! leaf) ADD_PC(INSN_ATTR(width));
1196
+ ADD_PC(INSN_ATTR(width));
1237
1197
  SETUP_CANARY(leaf);
1238
1198
  COLLECT_USAGE_INSN(INSN_ATTR(bin));
1239
1199
  COLLECT_USAGE_OPERAND(INSN_ATTR(bin), 0, num);
1240
1200
 
1241
1201
  /* ### Here we do the instruction body. ### */
1242
1202
  # define NAME_OF_CURRENT_INSN newarraykwsplat
1243
- # line 469 "insns.def"
1203
+ # line 456 "insns.def"
1244
1204
  {
1245
1205
  if (RHASH_EMPTY_P(*STACK_ADDR_FROM_TOP(1))) {
1246
1206
  val = rb_ary_new4(num-1, STACK_ADDR_FROM_TOP(num));
@@ -1249,7 +1209,7 @@ INSN_ENTRY(newarraykwsplat)
1249
1209
  val = rb_ary_new4(num, STACK_ADDR_FROM_TOP(num));
1250
1210
  }
1251
1211
  }
1252
- # line 1253 "vm.inc"
1212
+ # line 1213 "vm.inc"
1253
1213
  # undef NAME_OF_CURRENT_INSN
1254
1214
 
1255
1215
  /* ### Instruction trailers. ### */
@@ -1259,7 +1219,6 @@ INSN_ENTRY(newarraykwsplat)
1259
1219
  TOPN(0) = val;
1260
1220
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_NONE));
1261
1221
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_MOVED));
1262
- if (leaf) ADD_PC(INSN_ATTR(width));
1263
1222
  # undef INSN_ATTR
1264
1223
 
1265
1224
  /* ### Leave the instruction. ### */
@@ -1276,23 +1235,23 @@ INSN_ENTRY(duparray)
1276
1235
  /* ### Declare and assign variables. ### */
1277
1236
  VALUE ary = (VALUE)GET_OPERAND(1);
1278
1237
  # define INSN_ATTR(x) attr_ ## x ## _duparray(ary)
1279
- const bool leaf = INSN_ATTR(leaf);
1238
+ const bool MAYBE_UNUSED(leaf) = INSN_ATTR(leaf);
1280
1239
  VALUE val;
1281
1240
 
1282
1241
  /* ### Instruction preambles. ### */
1283
- if (! leaf) ADD_PC(INSN_ATTR(width));
1242
+ ADD_PC(INSN_ATTR(width));
1284
1243
  SETUP_CANARY(leaf);
1285
1244
  COLLECT_USAGE_INSN(INSN_ATTR(bin));
1286
1245
  COLLECT_USAGE_OPERAND(INSN_ATTR(bin), 0, ary);
1287
1246
 
1288
1247
  /* ### Here we do the instruction body. ### */
1289
1248
  # define NAME_OF_CURRENT_INSN duparray
1290
- # line 484 "insns.def"
1249
+ # line 471 "insns.def"
1291
1250
  {
1292
1251
  RUBY_DTRACE_CREATE_HOOK(ARRAY, RARRAY_LEN(ary));
1293
1252
  val = rb_ary_resurrect(ary);
1294
1253
  }
1295
- # line 1296 "vm.inc"
1254
+ # line 1255 "vm.inc"
1296
1255
  # undef NAME_OF_CURRENT_INSN
1297
1256
 
1298
1257
  /* ### Instruction trailers. ### */
@@ -1302,7 +1261,6 @@ INSN_ENTRY(duparray)
1302
1261
  TOPN(0) = val;
1303
1262
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_NONE));
1304
1263
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_MOVED));
1305
- if (leaf) ADD_PC(INSN_ATTR(width));
1306
1264
  # undef INSN_ATTR
1307
1265
 
1308
1266
  /* ### Leave the instruction. ### */
@@ -1319,23 +1277,23 @@ INSN_ENTRY(duphash)
1319
1277
  /* ### Declare and assign variables. ### */
1320
1278
  VALUE hash = (VALUE)GET_OPERAND(1);
1321
1279
  # define INSN_ATTR(x) attr_ ## x ## _duphash(hash)
1322
- const bool leaf = INSN_ATTR(leaf);
1280
+ const bool MAYBE_UNUSED(leaf) = INSN_ATTR(leaf);
1323
1281
  VALUE val;
1324
1282
 
1325
1283
  /* ### Instruction preambles. ### */
1326
- if (! leaf) ADD_PC(INSN_ATTR(width));
1284
+ ADD_PC(INSN_ATTR(width));
1327
1285
  SETUP_CANARY(leaf);
1328
1286
  COLLECT_USAGE_INSN(INSN_ATTR(bin));
1329
1287
  COLLECT_USAGE_OPERAND(INSN_ATTR(bin), 0, hash);
1330
1288
 
1331
1289
  /* ### Here we do the instruction body. ### */
1332
1290
  # define NAME_OF_CURRENT_INSN duphash
1333
- # line 495 "insns.def"
1291
+ # line 482 "insns.def"
1334
1292
  {
1335
1293
  RUBY_DTRACE_CREATE_HOOK(HASH, RHASH_SIZE(hash) << 1);
1336
1294
  val = rb_hash_resurrect(hash);
1337
1295
  }
1338
- # line 1339 "vm.inc"
1296
+ # line 1297 "vm.inc"
1339
1297
  # undef NAME_OF_CURRENT_INSN
1340
1298
 
1341
1299
  /* ### Instruction trailers. ### */
@@ -1345,7 +1303,6 @@ INSN_ENTRY(duphash)
1345
1303
  TOPN(0) = val;
1346
1304
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_NONE));
1347
1305
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_MOVED));
1348
- if (leaf) ADD_PC(INSN_ATTR(width));
1349
1306
  # undef INSN_ATTR
1350
1307
 
1351
1308
  /* ### Leave the instruction. ### */
@@ -1363,28 +1320,27 @@ INSN_ENTRY(expandarray)
1363
1320
  rb_num_t num = (rb_num_t)GET_OPERAND(1);
1364
1321
  rb_num_t flag = (rb_num_t)GET_OPERAND(2);
1365
1322
  # define INSN_ATTR(x) attr_ ## x ## _expandarray(num, flag)
1366
- const bool leaf = INSN_ATTR(leaf);
1323
+ const bool MAYBE_UNUSED(leaf) = INSN_ATTR(leaf);
1367
1324
  VALUE ary = TOPN(0);
1368
1325
 
1369
1326
  /* ### Instruction preambles. ### */
1370
- if (! leaf) ADD_PC(INSN_ATTR(width));
1327
+ ADD_PC(INSN_ATTR(width));
1371
1328
  COLLECT_USAGE_INSN(INSN_ATTR(bin));
1372
1329
  COLLECT_USAGE_OPERAND(INSN_ATTR(bin), 0, num);
1373
1330
  COLLECT_USAGE_OPERAND(INSN_ATTR(bin), 1, flag);
1374
1331
 
1375
1332
  /* ### Here we do the instruction body. ### */
1376
1333
  # define NAME_OF_CURRENT_INSN expandarray
1377
- # line 516 "insns.def"
1334
+ # line 503 "insns.def"
1378
1335
  {
1379
1336
  vm_expandarray(GET_SP(), ary, num, (int)flag);
1380
1337
  }
1381
- # line 1382 "vm.inc"
1338
+ # line 1339 "vm.inc"
1382
1339
  # undef NAME_OF_CURRENT_INSN
1383
1340
 
1384
1341
  /* ### Instruction trailers. ### */
1385
1342
  CHECK_VM_STACK_OVERFLOW_FOR_INSN(VM_REG_CFP, INSN_ATTR(retn));
1386
1343
  INC_SP(INSN_ATTR(sp_inc));
1387
- if (leaf) ADD_PC(INSN_ATTR(width));
1388
1344
  # undef INSN_ATTR
1389
1345
 
1390
1346
  /* ### Leave the instruction. ### */
@@ -1400,23 +1356,23 @@ INSN_ENTRY(concatarray)
1400
1356
 
1401
1357
  /* ### Declare and assign variables. ### */
1402
1358
  # define INSN_ATTR(x) attr_ ## x ## _concatarray()
1403
- const bool leaf = INSN_ATTR(leaf);
1359
+ const bool MAYBE_UNUSED(leaf) = INSN_ATTR(leaf);
1404
1360
  VALUE ary1 = TOPN(1);
1405
1361
  VALUE ary2 = TOPN(0);
1406
1362
  VALUE ary;
1407
1363
 
1408
1364
  /* ### Instruction preambles. ### */
1409
- if (! leaf) ADD_PC(INSN_ATTR(width));
1365
+ ADD_PC(INSN_ATTR(width));
1410
1366
  SETUP_CANARY(leaf);
1411
1367
  COLLECT_USAGE_INSN(INSN_ATTR(bin));
1412
1368
 
1413
1369
  /* ### Here we do the instruction body. ### */
1414
1370
  # define NAME_OF_CURRENT_INSN concatarray
1415
- # line 527 "insns.def"
1371
+ # line 514 "insns.def"
1416
1372
  {
1417
1373
  ary = vm_concat_array(ary1, ary2);
1418
1374
  }
1419
- # line 1420 "vm.inc"
1375
+ # line 1376 "vm.inc"
1420
1376
  # undef NAME_OF_CURRENT_INSN
1421
1377
 
1422
1378
  /* ### Instruction trailers. ### */
@@ -1426,7 +1382,6 @@ INSN_ENTRY(concatarray)
1426
1382
  TOPN(0) = ary;
1427
1383
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_NONE));
1428
1384
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_MOVED));
1429
- if (leaf) ADD_PC(INSN_ATTR(width));
1430
1385
  # undef INSN_ATTR
1431
1386
 
1432
1387
  /* ### Leave the instruction. ### */
@@ -1443,23 +1398,23 @@ INSN_ENTRY(splatarray)
1443
1398
  /* ### Declare and assign variables. ### */
1444
1399
  VALUE flag = (VALUE)GET_OPERAND(1);
1445
1400
  # define INSN_ATTR(x) attr_ ## x ## _splatarray(flag)
1446
- const bool leaf = INSN_ATTR(leaf);
1401
+ const bool MAYBE_UNUSED(leaf) = INSN_ATTR(leaf);
1447
1402
  VALUE ary = TOPN(0);
1448
1403
  VALUE obj;
1449
1404
 
1450
1405
  /* ### Instruction preambles. ### */
1451
- if (! leaf) ADD_PC(INSN_ATTR(width));
1406
+ ADD_PC(INSN_ATTR(width));
1452
1407
  SETUP_CANARY(leaf);
1453
1408
  COLLECT_USAGE_INSN(INSN_ATTR(bin));
1454
1409
  COLLECT_USAGE_OPERAND(INSN_ATTR(bin), 0, flag);
1455
1410
 
1456
1411
  /* ### Here we do the instruction body. ### */
1457
1412
  # define NAME_OF_CURRENT_INSN splatarray
1458
- # line 538 "insns.def"
1413
+ # line 525 "insns.def"
1459
1414
  {
1460
1415
  obj = vm_splat_array(flag, ary);
1461
1416
  }
1462
- # line 1463 "vm.inc"
1417
+ # line 1418 "vm.inc"
1463
1418
  # undef NAME_OF_CURRENT_INSN
1464
1419
 
1465
1420
  /* ### Instruction trailers. ### */
@@ -1469,7 +1424,6 @@ INSN_ENTRY(splatarray)
1469
1424
  TOPN(0) = obj;
1470
1425
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_NONE));
1471
1426
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_MOVED));
1472
- if (leaf) ADD_PC(INSN_ATTR(width));
1473
1427
  # undef INSN_ATTR
1474
1428
 
1475
1429
  /* ### Leave the instruction. ### */
@@ -1486,18 +1440,18 @@ INSN_ENTRY(newhash)
1486
1440
  /* ### Declare and assign variables. ### */
1487
1441
  rb_num_t num = (rb_num_t)GET_OPERAND(1);
1488
1442
  # define INSN_ATTR(x) attr_ ## x ## _newhash(num)
1489
- const bool leaf = INSN_ATTR(leaf);
1443
+ const bool MAYBE_UNUSED(leaf) = INSN_ATTR(leaf);
1490
1444
  VALUE val;
1491
1445
 
1492
1446
  /* ### Instruction preambles. ### */
1493
- if (! leaf) ADD_PC(INSN_ATTR(width));
1447
+ ADD_PC(INSN_ATTR(width));
1494
1448
  SETUP_CANARY(leaf);
1495
1449
  COLLECT_USAGE_INSN(INSN_ATTR(bin));
1496
1450
  COLLECT_USAGE_OPERAND(INSN_ATTR(bin), 0, num);
1497
1451
 
1498
1452
  /* ### Here we do the instruction body. ### */
1499
1453
  # define NAME_OF_CURRENT_INSN newhash
1500
- # line 550 "insns.def"
1454
+ # line 537 "insns.def"
1501
1455
  {
1502
1456
  RUBY_DTRACE_CREATE_HOOK(HASH, num);
1503
1457
 
@@ -1509,7 +1463,7 @@ INSN_ENTRY(newhash)
1509
1463
  val = rb_hash_new();
1510
1464
  }
1511
1465
  }
1512
- # line 1513 "vm.inc"
1466
+ # line 1467 "vm.inc"
1513
1467
  # undef NAME_OF_CURRENT_INSN
1514
1468
 
1515
1469
  /* ### Instruction trailers. ### */
@@ -1519,7 +1473,6 @@ INSN_ENTRY(newhash)
1519
1473
  TOPN(0) = val;
1520
1474
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_NONE));
1521
1475
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_MOVED));
1522
- if (leaf) ADD_PC(INSN_ATTR(width));
1523
1476
  # undef INSN_ATTR
1524
1477
 
1525
1478
  /* ### Leave the instruction. ### */
@@ -1536,24 +1489,24 @@ INSN_ENTRY(newrange)
1536
1489
  /* ### Declare and assign variables. ### */
1537
1490
  rb_num_t flag = (rb_num_t)GET_OPERAND(1);
1538
1491
  # define INSN_ATTR(x) attr_ ## x ## _newrange(flag)
1539
- const bool leaf = INSN_ATTR(leaf);
1492
+ const bool MAYBE_UNUSED(leaf) = INSN_ATTR(leaf);
1540
1493
  VALUE low = TOPN(1);
1541
1494
  VALUE high = TOPN(0);
1542
1495
  VALUE val;
1543
1496
 
1544
1497
  /* ### Instruction preambles. ### */
1545
- if (! leaf) ADD_PC(INSN_ATTR(width));
1498
+ ADD_PC(INSN_ATTR(width));
1546
1499
  SETUP_CANARY(leaf);
1547
1500
  COLLECT_USAGE_INSN(INSN_ATTR(bin));
1548
1501
  COLLECT_USAGE_OPERAND(INSN_ATTR(bin), 0, flag);
1549
1502
 
1550
1503
  /* ### Here we do the instruction body. ### */
1551
1504
  # define NAME_OF_CURRENT_INSN newrange
1552
- # line 570 "insns.def"
1505
+ # line 557 "insns.def"
1553
1506
  {
1554
1507
  val = rb_range_new(low, high, (int)flag);
1555
1508
  }
1556
- # line 1557 "vm.inc"
1509
+ # line 1510 "vm.inc"
1557
1510
  # undef NAME_OF_CURRENT_INSN
1558
1511
 
1559
1512
  /* ### Instruction trailers. ### */
@@ -1563,7 +1516,6 @@ INSN_ENTRY(newrange)
1563
1516
  TOPN(0) = val;
1564
1517
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_NONE));
1565
1518
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_MOVED));
1566
- if (leaf) ADD_PC(INSN_ATTR(width));
1567
1519
  # undef INSN_ATTR
1568
1520
 
1569
1521
  /* ### Leave the instruction. ### */
@@ -1579,29 +1531,28 @@ INSN_ENTRY(pop)
1579
1531
 
1580
1532
  /* ### Declare and assign variables. ### */
1581
1533
  # define INSN_ATTR(x) attr_ ## x ## _pop()
1582
- const bool leaf = INSN_ATTR(leaf);
1534
+ const bool MAYBE_UNUSED(leaf) = INSN_ATTR(leaf);
1583
1535
  VALUE val = TOPN(0);
1584
1536
 
1585
1537
  /* ### Instruction preambles. ### */
1586
- if (! leaf) ADD_PC(INSN_ATTR(width));
1538
+ ADD_PC(INSN_ATTR(width));
1587
1539
  SETUP_CANARY(leaf);
1588
1540
  COLLECT_USAGE_INSN(INSN_ATTR(bin));
1589
1541
 
1590
1542
  /* ### Here we do the instruction body. ### */
1591
1543
  # define NAME_OF_CURRENT_INSN pop
1592
- # line 584 "insns.def"
1544
+ # line 571 "insns.def"
1593
1545
  {
1594
1546
  (void)val;
1595
1547
  /* none */
1596
1548
  }
1597
- # line 1598 "vm.inc"
1549
+ # line 1550 "vm.inc"
1598
1550
  # undef NAME_OF_CURRENT_INSN
1599
1551
 
1600
1552
  /* ### Instruction trailers. ### */
1601
1553
  CHECK_VM_STACK_OVERFLOW_FOR_INSN(VM_REG_CFP, INSN_ATTR(retn));
1602
1554
  CHECK_CANARY(leaf, INSN_ATTR(bin));
1603
1555
  INC_SP(INSN_ATTR(sp_inc));
1604
- if (leaf) ADD_PC(INSN_ATTR(width));
1605
1556
  # undef INSN_ATTR
1606
1557
 
1607
1558
  /* ### Leave the instruction. ### */
@@ -1617,23 +1568,23 @@ INSN_ENTRY(dup)
1617
1568
 
1618
1569
  /* ### Declare and assign variables. ### */
1619
1570
  # define INSN_ATTR(x) attr_ ## x ## _dup()
1620
- const bool leaf = INSN_ATTR(leaf);
1571
+ const bool MAYBE_UNUSED(leaf) = INSN_ATTR(leaf);
1621
1572
  VALUE val = TOPN(0);
1622
1573
  VALUE val1;
1623
1574
  VALUE val2;
1624
1575
 
1625
1576
  /* ### Instruction preambles. ### */
1626
- if (! leaf) ADD_PC(INSN_ATTR(width));
1577
+ ADD_PC(INSN_ATTR(width));
1627
1578
  SETUP_CANARY(leaf);
1628
1579
  COLLECT_USAGE_INSN(INSN_ATTR(bin));
1629
1580
 
1630
1581
  /* ### Here we do the instruction body. ### */
1631
1582
  # define NAME_OF_CURRENT_INSN dup
1632
- # line 595 "insns.def"
1583
+ # line 582 "insns.def"
1633
1584
  {
1634
1585
  val1 = val2 = val;
1635
1586
  }
1636
- # line 1637 "vm.inc"
1587
+ # line 1588 "vm.inc"
1637
1588
  # undef NAME_OF_CURRENT_INSN
1638
1589
 
1639
1590
  /* ### Instruction trailers. ### */
@@ -1646,7 +1597,6 @@ INSN_ENTRY(dup)
1646
1597
  TOPN(1) = val1;
1647
1598
  VM_ASSERT(!RB_TYPE_P(TOPN(1), T_NONE));
1648
1599
  VM_ASSERT(!RB_TYPE_P(TOPN(1), T_MOVED));
1649
- if (leaf) ADD_PC(INSN_ATTR(width));
1650
1600
  # undef INSN_ATTR
1651
1601
 
1652
1602
  /* ### Leave the instruction. ### */
@@ -1663,29 +1613,28 @@ INSN_ENTRY(dupn)
1663
1613
  /* ### Declare and assign variables. ### */
1664
1614
  rb_num_t n = (rb_num_t)GET_OPERAND(1);
1665
1615
  # define INSN_ATTR(x) attr_ ## x ## _dupn(n)
1666
- const bool leaf = INSN_ATTR(leaf);
1616
+ const bool MAYBE_UNUSED(leaf) = INSN_ATTR(leaf);
1667
1617
 
1668
1618
  /* ### Instruction preambles. ### */
1669
- if (! leaf) ADD_PC(INSN_ATTR(width));
1619
+ ADD_PC(INSN_ATTR(width));
1670
1620
  COLLECT_USAGE_INSN(INSN_ATTR(bin));
1671
1621
  COLLECT_USAGE_OPERAND(INSN_ATTR(bin), 0, n);
1672
1622
 
1673
1623
  /* ### Here we do the instruction body. ### */
1674
1624
  # define NAME_OF_CURRENT_INSN dupn
1675
- # line 606 "insns.def"
1625
+ # line 593 "insns.def"
1676
1626
  {
1677
1627
  void *dst = GET_SP();
1678
1628
  void *src = STACK_ADDR_FROM_TOP(n);
1679
1629
 
1680
1630
  MEMCPY(dst, src, VALUE, n);
1681
1631
  }
1682
- # line 1683 "vm.inc"
1632
+ # line 1633 "vm.inc"
1683
1633
  # undef NAME_OF_CURRENT_INSN
1684
1634
 
1685
1635
  /* ### Instruction trailers. ### */
1686
1636
  CHECK_VM_STACK_OVERFLOW_FOR_INSN(VM_REG_CFP, INSN_ATTR(retn));
1687
1637
  INC_SP(INSN_ATTR(sp_inc));
1688
- if (leaf) ADD_PC(INSN_ATTR(width));
1689
1638
  # undef INSN_ATTR
1690
1639
 
1691
1640
  /* ### Leave the instruction. ### */
@@ -1701,12 +1650,12 @@ INSN_ENTRY(swap)
1701
1650
 
1702
1651
  /* ### Declare and assign variables. ### */
1703
1652
  # define INSN_ATTR(x) attr_ ## x ## _swap()
1704
- const bool leaf = INSN_ATTR(leaf);
1653
+ const bool MAYBE_UNUSED(leaf) = INSN_ATTR(leaf);
1705
1654
  VALUE val = TOPN(1);
1706
1655
  VALUE obj = TOPN(0);
1707
1656
 
1708
1657
  /* ### Instruction preambles. ### */
1709
- if (! leaf) ADD_PC(INSN_ATTR(width));
1658
+ ADD_PC(INSN_ATTR(width));
1710
1659
  COLLECT_USAGE_INSN(INSN_ATTR(bin));
1711
1660
 
1712
1661
  /* ### Instruction trailers. ### */
@@ -1718,7 +1667,6 @@ INSN_ENTRY(swap)
1718
1667
  TOPN(1) = obj;
1719
1668
  VM_ASSERT(!RB_TYPE_P(TOPN(1), T_NONE));
1720
1669
  VM_ASSERT(!RB_TYPE_P(TOPN(1), T_MOVED));
1721
- if (leaf) ADD_PC(INSN_ATTR(width));
1722
1670
  # undef INSN_ATTR
1723
1671
 
1724
1672
  /* ### Leave the instruction. ### */
@@ -1735,16 +1683,16 @@ INSN_ENTRY(opt_reverse)
1735
1683
  /* ### Declare and assign variables. ### */
1736
1684
  rb_num_t n = (rb_num_t)GET_OPERAND(1);
1737
1685
  # define INSN_ATTR(x) attr_ ## x ## _opt_reverse(n)
1738
- const bool leaf = INSN_ATTR(leaf);
1686
+ const bool MAYBE_UNUSED(leaf) = INSN_ATTR(leaf);
1739
1687
 
1740
1688
  /* ### Instruction preambles. ### */
1741
- if (! leaf) ADD_PC(INSN_ATTR(width));
1689
+ ADD_PC(INSN_ATTR(width));
1742
1690
  COLLECT_USAGE_INSN(INSN_ATTR(bin));
1743
1691
  COLLECT_USAGE_OPERAND(INSN_ATTR(bin), 0, n);
1744
1692
 
1745
1693
  /* ### Here we do the instruction body. ### */
1746
1694
  # define NAME_OF_CURRENT_INSN opt_reverse
1747
- # line 630 "insns.def"
1695
+ # line 617 "insns.def"
1748
1696
  {
1749
1697
  rb_num_t i;
1750
1698
  VALUE *sp = STACK_ADDR_FROM_TOP(n);
@@ -1756,13 +1704,12 @@ INSN_ENTRY(opt_reverse)
1756
1704
  TOPN(i) = v0;
1757
1705
  }
1758
1706
  }
1759
- # line 1760 "vm.inc"
1707
+ # line 1708 "vm.inc"
1760
1708
  # undef NAME_OF_CURRENT_INSN
1761
1709
 
1762
1710
  /* ### Instruction trailers. ### */
1763
1711
  CHECK_VM_STACK_OVERFLOW_FOR_INSN(VM_REG_CFP, INSN_ATTR(retn));
1764
1712
  INC_SP(INSN_ATTR(sp_inc));
1765
- if (leaf) ADD_PC(INSN_ATTR(width));
1766
1713
  # undef INSN_ATTR
1767
1714
 
1768
1715
  /* ### Leave the instruction. ### */
@@ -1779,22 +1726,22 @@ INSN_ENTRY(topn)
1779
1726
  /* ### Declare and assign variables. ### */
1780
1727
  rb_num_t n = (rb_num_t)GET_OPERAND(1);
1781
1728
  # define INSN_ATTR(x) attr_ ## x ## _topn(n)
1782
- const bool leaf = INSN_ATTR(leaf);
1729
+ const bool MAYBE_UNUSED(leaf) = INSN_ATTR(leaf);
1783
1730
  VALUE val;
1784
1731
 
1785
1732
  /* ### Instruction preambles. ### */
1786
- if (! leaf) ADD_PC(INSN_ATTR(width));
1733
+ ADD_PC(INSN_ATTR(width));
1787
1734
  SETUP_CANARY(leaf);
1788
1735
  COLLECT_USAGE_INSN(INSN_ATTR(bin));
1789
1736
  COLLECT_USAGE_OPERAND(INSN_ATTR(bin), 0, n);
1790
1737
 
1791
1738
  /* ### Here we do the instruction body. ### */
1792
1739
  # define NAME_OF_CURRENT_INSN topn
1793
- # line 660 "insns.def"
1740
+ # line 647 "insns.def"
1794
1741
  {
1795
1742
  val = TOPN(n);
1796
1743
  }
1797
- # line 1798 "vm.inc"
1744
+ # line 1745 "vm.inc"
1798
1745
  # undef NAME_OF_CURRENT_INSN
1799
1746
 
1800
1747
  /* ### Instruction trailers. ### */
@@ -1804,7 +1751,6 @@ INSN_ENTRY(topn)
1804
1751
  TOPN(0) = val;
1805
1752
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_NONE));
1806
1753
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_MOVED));
1807
- if (leaf) ADD_PC(INSN_ATTR(width));
1808
1754
  # undef INSN_ATTR
1809
1755
 
1810
1756
  /* ### Leave the instruction. ### */
@@ -1821,22 +1767,22 @@ INSN_ENTRY(setn)
1821
1767
  /* ### Declare and assign variables. ### */
1822
1768
  rb_num_t n = (rb_num_t)GET_OPERAND(1);
1823
1769
  # define INSN_ATTR(x) attr_ ## x ## _setn(n)
1824
- const bool leaf = INSN_ATTR(leaf);
1770
+ const bool MAYBE_UNUSED(leaf) = INSN_ATTR(leaf);
1825
1771
  VALUE val = TOPN(0);
1826
1772
 
1827
1773
  /* ### Instruction preambles. ### */
1828
- if (! leaf) ADD_PC(INSN_ATTR(width));
1774
+ ADD_PC(INSN_ATTR(width));
1829
1775
  SETUP_CANARY(leaf);
1830
1776
  COLLECT_USAGE_INSN(INSN_ATTR(bin));
1831
1777
  COLLECT_USAGE_OPERAND(INSN_ATTR(bin), 0, n);
1832
1778
 
1833
1779
  /* ### Here we do the instruction body. ### */
1834
1780
  # define NAME_OF_CURRENT_INSN setn
1835
- # line 671 "insns.def"
1781
+ # line 658 "insns.def"
1836
1782
  {
1837
1783
  TOPN(n) = val;
1838
1784
  }
1839
- # line 1840 "vm.inc"
1785
+ # line 1786 "vm.inc"
1840
1786
  # undef NAME_OF_CURRENT_INSN
1841
1787
 
1842
1788
  /* ### Instruction trailers. ### */
@@ -1846,7 +1792,6 @@ INSN_ENTRY(setn)
1846
1792
  TOPN(0) = val;
1847
1793
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_NONE));
1848
1794
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_MOVED));
1849
- if (leaf) ADD_PC(INSN_ATTR(width));
1850
1795
  # undef INSN_ATTR
1851
1796
 
1852
1797
  /* ### Leave the instruction. ### */
@@ -1863,17 +1808,16 @@ INSN_ENTRY(adjuststack)
1863
1808
  /* ### Declare and assign variables. ### */
1864
1809
  rb_num_t n = (rb_num_t)GET_OPERAND(1);
1865
1810
  # define INSN_ATTR(x) attr_ ## x ## _adjuststack(n)
1866
- const bool leaf = INSN_ATTR(leaf);
1811
+ const bool MAYBE_UNUSED(leaf) = INSN_ATTR(leaf);
1867
1812
 
1868
1813
  /* ### Instruction preambles. ### */
1869
- if (! leaf) ADD_PC(INSN_ATTR(width));
1814
+ ADD_PC(INSN_ATTR(width));
1870
1815
  COLLECT_USAGE_INSN(INSN_ATTR(bin));
1871
1816
  COLLECT_USAGE_OPERAND(INSN_ATTR(bin), 0, n);
1872
1817
 
1873
1818
  /* ### Instruction trailers. ### */
1874
1819
  CHECK_VM_STACK_OVERFLOW_FOR_INSN(VM_REG_CFP, INSN_ATTR(retn));
1875
1820
  INC_SP(INSN_ATTR(sp_inc));
1876
- if (leaf) ADD_PC(INSN_ATTR(width));
1877
1821
  # undef INSN_ATTR
1878
1822
 
1879
1823
  /* ### Leave the instruction. ### */
@@ -1892,12 +1836,12 @@ INSN_ENTRY(defined)
1892
1836
  VALUE obj = (VALUE)GET_OPERAND(2);
1893
1837
  VALUE pushval = (VALUE)GET_OPERAND(3);
1894
1838
  # define INSN_ATTR(x) attr_ ## x ## _defined(op_type, obj, pushval)
1895
- const bool leaf = INSN_ATTR(leaf);
1839
+ const bool MAYBE_UNUSED(leaf) = INSN_ATTR(leaf);
1896
1840
  VALUE v = TOPN(0);
1897
1841
  VALUE val;
1898
1842
 
1899
1843
  /* ### Instruction preambles. ### */
1900
- if (! leaf) ADD_PC(INSN_ATTR(width));
1844
+ ADD_PC(INSN_ATTR(width));
1901
1845
  SETUP_CANARY(leaf);
1902
1846
  COLLECT_USAGE_INSN(INSN_ATTR(bin));
1903
1847
  COLLECT_USAGE_OPERAND(INSN_ATTR(bin), 0, op_type);
@@ -1906,14 +1850,14 @@ INSN_ENTRY(defined)
1906
1850
 
1907
1851
  /* ### Here we do the instruction body. ### */
1908
1852
  # define NAME_OF_CURRENT_INSN defined
1909
- # line 697 "insns.def"
1853
+ # line 684 "insns.def"
1910
1854
  {
1911
1855
  val = Qnil;
1912
1856
  if (vm_defined(ec, GET_CFP(), op_type, obj, v)) {
1913
1857
  val = pushval;
1914
1858
  }
1915
1859
  }
1916
- # line 1917 "vm.inc"
1860
+ # line 1861 "vm.inc"
1917
1861
  # undef NAME_OF_CURRENT_INSN
1918
1862
 
1919
1863
  /* ### Instruction trailers. ### */
@@ -1923,7 +1867,6 @@ INSN_ENTRY(defined)
1923
1867
  TOPN(0) = val;
1924
1868
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_NONE));
1925
1869
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_MOVED));
1926
- if (leaf) ADD_PC(INSN_ATTR(width));
1927
1870
  # undef INSN_ATTR
1928
1871
 
1929
1872
  /* ### Leave the instruction. ### */
@@ -1942,11 +1885,11 @@ INSN_ENTRY(definedivar)
1942
1885
  IVC ic = (IVC)GET_OPERAND(2);
1943
1886
  VALUE pushval = (VALUE)GET_OPERAND(3);
1944
1887
  # define INSN_ATTR(x) attr_ ## x ## _definedivar(id, ic, pushval)
1945
- const bool leaf = INSN_ATTR(leaf);
1888
+ const bool MAYBE_UNUSED(leaf) = INSN_ATTR(leaf);
1946
1889
  VALUE val;
1947
1890
 
1948
1891
  /* ### Instruction preambles. ### */
1949
- if (! leaf) ADD_PC(INSN_ATTR(width));
1892
+ ADD_PC(INSN_ATTR(width));
1950
1893
  SETUP_CANARY(leaf);
1951
1894
  COLLECT_USAGE_INSN(INSN_ATTR(bin));
1952
1895
  COLLECT_USAGE_OPERAND(INSN_ATTR(bin), 0, id);
@@ -1955,14 +1898,14 @@ INSN_ENTRY(definedivar)
1955
1898
 
1956
1899
  /* ### Here we do the instruction body. ### */
1957
1900
  # define NAME_OF_CURRENT_INSN definedivar
1958
- # line 711 "insns.def"
1901
+ # line 698 "insns.def"
1959
1902
  {
1960
1903
  val = Qnil;
1961
1904
  if (vm_getivar(GET_SELF(), id, GET_ISEQ(), ic, NULL, FALSE, Qundef) != Qundef) {
1962
1905
  val = pushval;
1963
1906
  }
1964
1907
  }
1965
- # line 1966 "vm.inc"
1908
+ # line 1909 "vm.inc"
1966
1909
  # undef NAME_OF_CURRENT_INSN
1967
1910
 
1968
1911
  /* ### Instruction trailers. ### */
@@ -1972,7 +1915,6 @@ INSN_ENTRY(definedivar)
1972
1915
  TOPN(0) = val;
1973
1916
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_NONE));
1974
1917
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_MOVED));
1975
- if (leaf) ADD_PC(INSN_ATTR(width));
1976
1918
  # undef INSN_ATTR
1977
1919
 
1978
1920
  /* ### Leave the instruction. ### */
@@ -1989,24 +1931,24 @@ INSN_ENTRY(checkmatch)
1989
1931
  /* ### Declare and assign variables. ### */
1990
1932
  rb_num_t flag = (rb_num_t)GET_OPERAND(1);
1991
1933
  # define INSN_ATTR(x) attr_ ## x ## _checkmatch(flag)
1992
- const bool leaf = INSN_ATTR(leaf);
1934
+ const bool MAYBE_UNUSED(leaf) = INSN_ATTR(leaf);
1993
1935
  VALUE target = TOPN(1);
1994
1936
  VALUE pattern = TOPN(0);
1995
1937
  VALUE result;
1996
1938
 
1997
1939
  /* ### Instruction preambles. ### */
1998
- if (! leaf) ADD_PC(INSN_ATTR(width));
1940
+ ADD_PC(INSN_ATTR(width));
1999
1941
  SETUP_CANARY(leaf);
2000
1942
  COLLECT_USAGE_INSN(INSN_ATTR(bin));
2001
1943
  COLLECT_USAGE_OPERAND(INSN_ATTR(bin), 0, flag);
2002
1944
 
2003
1945
  /* ### Here we do the instruction body. ### */
2004
1946
  # define NAME_OF_CURRENT_INSN checkmatch
2005
- # line 731 "insns.def"
1947
+ # line 718 "insns.def"
2006
1948
  {
2007
1949
  result = vm_check_match(ec, target, pattern, flag);
2008
1950
  }
2009
- # line 2010 "vm.inc"
1951
+ # line 1952 "vm.inc"
2010
1952
  # undef NAME_OF_CURRENT_INSN
2011
1953
 
2012
1954
  /* ### Instruction trailers. ### */
@@ -2016,7 +1958,6 @@ INSN_ENTRY(checkmatch)
2016
1958
  TOPN(0) = result;
2017
1959
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_NONE));
2018
1960
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_MOVED));
2019
- if (leaf) ADD_PC(INSN_ATTR(width));
2020
1961
  # undef INSN_ATTR
2021
1962
 
2022
1963
  /* ### Leave the instruction. ### */
@@ -2034,11 +1975,11 @@ INSN_ENTRY(checkkeyword)
2034
1975
  lindex_t kw_bits_index = (lindex_t)GET_OPERAND(1);
2035
1976
  lindex_t keyword_index = (lindex_t)GET_OPERAND(2);
2036
1977
  # define INSN_ATTR(x) attr_ ## x ## _checkkeyword(kw_bits_index, keyword_index)
2037
- const bool leaf = INSN_ATTR(leaf);
1978
+ const bool MAYBE_UNUSED(leaf) = INSN_ATTR(leaf);
2038
1979
  VALUE ret;
2039
1980
 
2040
1981
  /* ### Instruction preambles. ### */
2041
- if (! leaf) ADD_PC(INSN_ATTR(width));
1982
+ ADD_PC(INSN_ATTR(width));
2042
1983
  SETUP_CANARY(leaf);
2043
1984
  COLLECT_USAGE_INSN(INSN_ATTR(bin));
2044
1985
  COLLECT_USAGE_OPERAND(INSN_ATTR(bin), 0, kw_bits_index);
@@ -2046,11 +1987,11 @@ INSN_ENTRY(checkkeyword)
2046
1987
 
2047
1988
  /* ### Here we do the instruction body. ### */
2048
1989
  # define NAME_OF_CURRENT_INSN checkkeyword
2049
- # line 741 "insns.def"
1990
+ # line 728 "insns.def"
2050
1991
  {
2051
1992
  ret = vm_check_keyword(kw_bits_index, keyword_index, GET_EP());
2052
1993
  }
2053
- # line 2054 "vm.inc"
1994
+ # line 1995 "vm.inc"
2054
1995
  # undef NAME_OF_CURRENT_INSN
2055
1996
 
2056
1997
  /* ### Instruction trailers. ### */
@@ -2060,7 +2001,6 @@ INSN_ENTRY(checkkeyword)
2060
2001
  TOPN(0) = ret;
2061
2002
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_NONE));
2062
2003
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_MOVED));
2063
- if (leaf) ADD_PC(INSN_ATTR(width));
2064
2004
  # undef INSN_ATTR
2065
2005
 
2066
2006
  /* ### Leave the instruction. ### */
@@ -2077,23 +2017,23 @@ INSN_ENTRY(checktype)
2077
2017
  /* ### Declare and assign variables. ### */
2078
2018
  rb_num_t type = (rb_num_t)GET_OPERAND(1);
2079
2019
  # define INSN_ATTR(x) attr_ ## x ## _checktype(type)
2080
- const bool leaf = INSN_ATTR(leaf);
2020
+ const bool MAYBE_UNUSED(leaf) = INSN_ATTR(leaf);
2081
2021
  VALUE val = TOPN(0);
2082
2022
  VALUE ret;
2083
2023
 
2084
2024
  /* ### Instruction preambles. ### */
2085
- if (! leaf) ADD_PC(INSN_ATTR(width));
2025
+ ADD_PC(INSN_ATTR(width));
2086
2026
  SETUP_CANARY(leaf);
2087
2027
  COLLECT_USAGE_INSN(INSN_ATTR(bin));
2088
2028
  COLLECT_USAGE_OPERAND(INSN_ATTR(bin), 0, type);
2089
2029
 
2090
2030
  /* ### Here we do the instruction body. ### */
2091
2031
  # define NAME_OF_CURRENT_INSN checktype
2092
- # line 751 "insns.def"
2032
+ # line 738 "insns.def"
2093
2033
  {
2094
2034
  ret = RBOOL(TYPE(val) == (int)type);
2095
2035
  }
2096
- # line 2097 "vm.inc"
2036
+ # line 2037 "vm.inc"
2097
2037
  # undef NAME_OF_CURRENT_INSN
2098
2038
 
2099
2039
  /* ### Instruction trailers. ### */
@@ -2103,7 +2043,6 @@ INSN_ENTRY(checktype)
2103
2043
  TOPN(0) = ret;
2104
2044
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_NONE));
2105
2045
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_MOVED));
2106
- if (leaf) ADD_PC(INSN_ATTR(width));
2107
2046
  # undef INSN_ATTR
2108
2047
 
2109
2048
  /* ### Leave the instruction. ### */
@@ -2122,13 +2061,13 @@ INSN_ENTRY(defineclass)
2122
2061
  ISEQ class_iseq = (ISEQ)GET_OPERAND(2);
2123
2062
  rb_num_t flags = (rb_num_t)GET_OPERAND(3);
2124
2063
  # define INSN_ATTR(x) attr_ ## x ## _defineclass(id, class_iseq, flags)
2125
- const bool leaf = INSN_ATTR(leaf);
2064
+ const bool MAYBE_UNUSED(leaf) = INSN_ATTR(leaf);
2126
2065
  VALUE cbase = TOPN(1);
2127
2066
  VALUE super = TOPN(0);
2128
2067
  VALUE val;
2129
2068
 
2130
2069
  /* ### Instruction preambles. ### */
2131
- if (! leaf) ADD_PC(INSN_ATTR(width));
2070
+ ADD_PC(INSN_ATTR(width));
2132
2071
  POPN(INSN_ATTR(popn));
2133
2072
  SETUP_CANARY(leaf);
2134
2073
  COLLECT_USAGE_INSN(INSN_ATTR(bin));
@@ -2138,7 +2077,7 @@ INSN_ENTRY(defineclass)
2138
2077
 
2139
2078
  /* ### Here we do the instruction body. ### */
2140
2079
  # define NAME_OF_CURRENT_INSN defineclass
2141
- # line 767 "insns.def"
2080
+ # line 754 "insns.def"
2142
2081
  {
2143
2082
  VALUE klass = vm_find_or_create_class_by_id(id, flags, cbase, super);
2144
2083
 
@@ -2154,14 +2093,13 @@ INSN_ENTRY(defineclass)
2154
2093
  RESTORE_REGS();
2155
2094
  NEXT_INSN();
2156
2095
  }
2157
- # line 2158 "vm.inc"
2096
+ # line 2097 "vm.inc"
2158
2097
  # undef NAME_OF_CURRENT_INSN
2159
2098
 
2160
2099
  /* ### Instruction trailers. ### */
2161
2100
  CHECK_VM_STACK_OVERFLOW_FOR_INSN(VM_REG_CFP, INSN_ATTR(retn));
2162
2101
  CHECK_CANARY(leaf, INSN_ATTR(bin));
2163
2102
  PUSH(val);
2164
- if (leaf) ADD_PC(INSN_ATTR(width));
2165
2103
  # undef INSN_ATTR
2166
2104
 
2167
2105
  /* ### Leave the instruction. ### */
@@ -2179,10 +2117,10 @@ INSN_ENTRY(definemethod)
2179
2117
  ID id = (ID)GET_OPERAND(1);
2180
2118
  ISEQ iseq = (ISEQ)GET_OPERAND(2);
2181
2119
  # define INSN_ATTR(x) attr_ ## x ## _definemethod(id, iseq)
2182
- const bool leaf = INSN_ATTR(leaf);
2120
+ const bool MAYBE_UNUSED(leaf) = INSN_ATTR(leaf);
2183
2121
 
2184
2122
  /* ### Instruction preambles. ### */
2185
- if (! leaf) ADD_PC(INSN_ATTR(width));
2123
+ ADD_PC(INSN_ATTR(width));
2186
2124
  POPN(INSN_ATTR(popn));
2187
2125
  SETUP_CANARY(leaf);
2188
2126
  COLLECT_USAGE_INSN(INSN_ATTR(bin));
@@ -2191,17 +2129,16 @@ INSN_ENTRY(definemethod)
2191
2129
 
2192
2130
  /* ### Here we do the instruction body. ### */
2193
2131
  # define NAME_OF_CURRENT_INSN definemethod
2194
- # line 788 "insns.def"
2132
+ # line 775 "insns.def"
2195
2133
  {
2196
2134
  vm_define_method(ec, Qnil, id, (VALUE)iseq, FALSE);
2197
2135
  }
2198
- # line 2199 "vm.inc"
2136
+ # line 2137 "vm.inc"
2199
2137
  # undef NAME_OF_CURRENT_INSN
2200
2138
 
2201
2139
  /* ### Instruction trailers. ### */
2202
2140
  CHECK_VM_STACK_OVERFLOW_FOR_INSN(VM_REG_CFP, INSN_ATTR(retn));
2203
2141
  CHECK_CANARY(leaf, INSN_ATTR(bin));
2204
- if (leaf) ADD_PC(INSN_ATTR(width));
2205
2142
  # undef INSN_ATTR
2206
2143
 
2207
2144
  /* ### Leave the instruction. ### */
@@ -2219,11 +2156,11 @@ INSN_ENTRY(definesmethod)
2219
2156
  ID id = (ID)GET_OPERAND(1);
2220
2157
  ISEQ iseq = (ISEQ)GET_OPERAND(2);
2221
2158
  # define INSN_ATTR(x) attr_ ## x ## _definesmethod(id, iseq)
2222
- const bool leaf = INSN_ATTR(leaf);
2159
+ const bool MAYBE_UNUSED(leaf) = INSN_ATTR(leaf);
2223
2160
  VALUE obj = TOPN(0);
2224
2161
 
2225
2162
  /* ### Instruction preambles. ### */
2226
- if (! leaf) ADD_PC(INSN_ATTR(width));
2163
+ ADD_PC(INSN_ATTR(width));
2227
2164
  POPN(INSN_ATTR(popn));
2228
2165
  SETUP_CANARY(leaf);
2229
2166
  COLLECT_USAGE_INSN(INSN_ATTR(bin));
@@ -2232,17 +2169,16 @@ INSN_ENTRY(definesmethod)
2232
2169
 
2233
2170
  /* ### Here we do the instruction body. ### */
2234
2171
  # define NAME_OF_CURRENT_INSN definesmethod
2235
- # line 797 "insns.def"
2172
+ # line 784 "insns.def"
2236
2173
  {
2237
2174
  vm_define_method(ec, obj, id, (VALUE)iseq, TRUE);
2238
2175
  }
2239
- # line 2240 "vm.inc"
2176
+ # line 2177 "vm.inc"
2240
2177
  # undef NAME_OF_CURRENT_INSN
2241
2178
 
2242
2179
  /* ### Instruction trailers. ### */
2243
2180
  CHECK_VM_STACK_OVERFLOW_FOR_INSN(VM_REG_CFP, INSN_ATTR(retn));
2244
2181
  CHECK_CANARY(leaf, INSN_ATTR(bin));
2245
- if (leaf) ADD_PC(INSN_ATTR(width));
2246
2182
  # undef INSN_ATTR
2247
2183
 
2248
2184
  /* ### Leave the instruction. ### */
@@ -2260,11 +2196,11 @@ INSN_ENTRY(send)
2260
2196
  CALL_DATA cd = (CALL_DATA)GET_OPERAND(1);
2261
2197
  ISEQ blockiseq = (ISEQ)GET_OPERAND(2);
2262
2198
  # define INSN_ATTR(x) attr_ ## x ## _send(cd, blockiseq)
2263
- const bool leaf = INSN_ATTR(leaf);
2199
+ const bool MAYBE_UNUSED(leaf) = INSN_ATTR(leaf);
2264
2200
  VALUE val;
2265
2201
 
2266
2202
  /* ### Instruction preambles. ### */
2267
- if (! leaf) ADD_PC(INSN_ATTR(width));
2203
+ ADD_PC(INSN_ATTR(width));
2268
2204
  POPN(INSN_ATTR(popn));
2269
2205
  SETUP_CANARY(leaf);
2270
2206
  COLLECT_USAGE_INSN(INSN_ATTR(bin));
@@ -2273,7 +2209,7 @@ INSN_ENTRY(send)
2273
2209
 
2274
2210
  /* ### Here we do the instruction body. ### */
2275
2211
  # define NAME_OF_CURRENT_INSN send
2276
- # line 813 "insns.def"
2212
+ # line 800 "insns.def"
2277
2213
  {
2278
2214
  VALUE bh = vm_caller_setup_arg_block(ec, GET_CFP(), cd->ci, blockiseq, false);
2279
2215
  val = vm_sendish(ec, GET_CFP(), cd, bh, mexp_search_method);
@@ -2284,14 +2220,13 @@ INSN_ENTRY(send)
2284
2220
  NEXT_INSN();
2285
2221
  }
2286
2222
  }
2287
- # line 2288 "vm.inc"
2223
+ # line 2224 "vm.inc"
2288
2224
  # undef NAME_OF_CURRENT_INSN
2289
2225
 
2290
2226
  /* ### Instruction trailers. ### */
2291
2227
  CHECK_VM_STACK_OVERFLOW_FOR_INSN(VM_REG_CFP, INSN_ATTR(retn));
2292
2228
  CHECK_CANARY(leaf, INSN_ATTR(bin));
2293
2229
  PUSH(val);
2294
- if (leaf) ADD_PC(INSN_ATTR(width));
2295
2230
  # undef INSN_ATTR
2296
2231
 
2297
2232
  /* ### Leave the instruction. ### */
@@ -2308,11 +2243,11 @@ INSN_ENTRY(opt_send_without_block)
2308
2243
  /* ### Declare and assign variables. ### */
2309
2244
  CALL_DATA cd = (CALL_DATA)GET_OPERAND(1);
2310
2245
  # define INSN_ATTR(x) attr_ ## x ## _opt_send_without_block(cd)
2311
- const bool leaf = INSN_ATTR(leaf);
2246
+ const bool MAYBE_UNUSED(leaf) = INSN_ATTR(leaf);
2312
2247
  VALUE val;
2313
2248
 
2314
2249
  /* ### Instruction preambles. ### */
2315
- if (! leaf) ADD_PC(INSN_ATTR(width));
2250
+ ADD_PC(INSN_ATTR(width));
2316
2251
  POPN(INSN_ATTR(popn));
2317
2252
  SETUP_CANARY(leaf);
2318
2253
  COLLECT_USAGE_INSN(INSN_ATTR(bin));
@@ -2320,7 +2255,7 @@ INSN_ENTRY(opt_send_without_block)
2320
2255
 
2321
2256
  /* ### Here we do the instruction body. ### */
2322
2257
  # define NAME_OF_CURRENT_INSN opt_send_without_block
2323
- # line 833 "insns.def"
2258
+ # line 820 "insns.def"
2324
2259
  {
2325
2260
  VALUE bh = VM_BLOCK_HANDLER_NONE;
2326
2261
  val = vm_sendish(ec, GET_CFP(), cd, bh, mexp_search_method);
@@ -2331,14 +2266,13 @@ INSN_ENTRY(opt_send_without_block)
2331
2266
  NEXT_INSN();
2332
2267
  }
2333
2268
  }
2334
- # line 2335 "vm.inc"
2269
+ # line 2270 "vm.inc"
2335
2270
  # undef NAME_OF_CURRENT_INSN
2336
2271
 
2337
2272
  /* ### Instruction trailers. ### */
2338
2273
  CHECK_VM_STACK_OVERFLOW_FOR_INSN(VM_REG_CFP, INSN_ATTR(retn));
2339
2274
  CHECK_CANARY(leaf, INSN_ATTR(bin));
2340
2275
  PUSH(val);
2341
- if (leaf) ADD_PC(INSN_ATTR(width));
2342
2276
  # undef INSN_ATTR
2343
2277
 
2344
2278
  /* ### Leave the instruction. ### */
@@ -2355,19 +2289,19 @@ INSN_ENTRY(objtostring)
2355
2289
  /* ### Declare and assign variables. ### */
2356
2290
  CALL_DATA cd = (CALL_DATA)GET_OPERAND(1);
2357
2291
  # define INSN_ATTR(x) attr_ ## x ## _objtostring(cd)
2358
- const bool leaf = INSN_ATTR(leaf);
2292
+ const bool MAYBE_UNUSED(leaf) = INSN_ATTR(leaf);
2359
2293
  VALUE recv = TOPN(0);
2360
2294
  VALUE val;
2361
2295
 
2362
2296
  /* ### Instruction preambles. ### */
2363
- if (! leaf) ADD_PC(INSN_ATTR(width));
2297
+ ADD_PC(INSN_ATTR(width));
2364
2298
  SETUP_CANARY(leaf);
2365
2299
  COLLECT_USAGE_INSN(INSN_ATTR(bin));
2366
2300
  COLLECT_USAGE_OPERAND(INSN_ATTR(bin), 0, cd);
2367
2301
 
2368
2302
  /* ### Here we do the instruction body. ### */
2369
2303
  # define NAME_OF_CURRENT_INSN objtostring
2370
- # line 851 "insns.def"
2304
+ # line 838 "insns.def"
2371
2305
  {
2372
2306
  val = vm_objtostring(GET_ISEQ(), recv, cd);
2373
2307
 
@@ -2375,7 +2309,7 @@ INSN_ENTRY(objtostring)
2375
2309
  CALL_SIMPLE_METHOD();
2376
2310
  }
2377
2311
  }
2378
- # line 2379 "vm.inc"
2312
+ # line 2313 "vm.inc"
2379
2313
  # undef NAME_OF_CURRENT_INSN
2380
2314
 
2381
2315
  /* ### Instruction trailers. ### */
@@ -2385,7 +2319,6 @@ INSN_ENTRY(objtostring)
2385
2319
  TOPN(0) = val;
2386
2320
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_NONE));
2387
2321
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_MOVED));
2388
- if (leaf) ADD_PC(INSN_ATTR(width));
2389
2322
  # undef INSN_ATTR
2390
2323
 
2391
2324
  /* ### Leave the instruction. ### */
@@ -2403,11 +2336,11 @@ INSN_ENTRY(opt_str_freeze)
2403
2336
  VALUE str = (VALUE)GET_OPERAND(1);
2404
2337
  CALL_DATA cd = (CALL_DATA)GET_OPERAND(2);
2405
2338
  # define INSN_ATTR(x) attr_ ## x ## _opt_str_freeze(str, cd)
2406
- const bool leaf = INSN_ATTR(leaf);
2339
+ const bool MAYBE_UNUSED(leaf) = INSN_ATTR(leaf);
2407
2340
  VALUE val;
2408
2341
 
2409
2342
  /* ### Instruction preambles. ### */
2410
- if (! leaf) ADD_PC(INSN_ATTR(width));
2343
+ ADD_PC(INSN_ATTR(width));
2411
2344
  SETUP_CANARY(leaf);
2412
2345
  COLLECT_USAGE_INSN(INSN_ATTR(bin));
2413
2346
  COLLECT_USAGE_OPERAND(INSN_ATTR(bin), 0, str);
@@ -2415,7 +2348,7 @@ INSN_ENTRY(opt_str_freeze)
2415
2348
 
2416
2349
  /* ### Here we do the instruction body. ### */
2417
2350
  # define NAME_OF_CURRENT_INSN opt_str_freeze
2418
- # line 864 "insns.def"
2351
+ # line 851 "insns.def"
2419
2352
  {
2420
2353
  val = vm_opt_str_freeze(str, BOP_FREEZE, idFreeze);
2421
2354
 
@@ -2424,7 +2357,7 @@ INSN_ENTRY(opt_str_freeze)
2424
2357
  CALL_SIMPLE_METHOD();
2425
2358
  }
2426
2359
  }
2427
- # line 2428 "vm.inc"
2360
+ # line 2361 "vm.inc"
2428
2361
  # undef NAME_OF_CURRENT_INSN
2429
2362
 
2430
2363
  /* ### Instruction trailers. ### */
@@ -2434,7 +2367,6 @@ INSN_ENTRY(opt_str_freeze)
2434
2367
  TOPN(0) = val;
2435
2368
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_NONE));
2436
2369
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_MOVED));
2437
- if (leaf) ADD_PC(INSN_ATTR(width));
2438
2370
  # undef INSN_ATTR
2439
2371
 
2440
2372
  /* ### Leave the instruction. ### */
@@ -2451,19 +2383,19 @@ INSN_ENTRY(opt_nil_p)
2451
2383
  /* ### Declare and assign variables. ### */
2452
2384
  CALL_DATA cd = (CALL_DATA)GET_OPERAND(1);
2453
2385
  # define INSN_ATTR(x) attr_ ## x ## _opt_nil_p(cd)
2454
- const bool leaf = INSN_ATTR(leaf);
2386
+ const bool MAYBE_UNUSED(leaf) = INSN_ATTR(leaf);
2455
2387
  VALUE recv = TOPN(0);
2456
2388
  VALUE val;
2457
2389
 
2458
2390
  /* ### Instruction preambles. ### */
2459
- if (! leaf) ADD_PC(INSN_ATTR(width));
2391
+ ADD_PC(INSN_ATTR(width));
2460
2392
  SETUP_CANARY(leaf);
2461
2393
  COLLECT_USAGE_INSN(INSN_ATTR(bin));
2462
2394
  COLLECT_USAGE_OPERAND(INSN_ATTR(bin), 0, cd);
2463
2395
 
2464
2396
  /* ### Here we do the instruction body. ### */
2465
2397
  # define NAME_OF_CURRENT_INSN opt_nil_p
2466
- # line 879 "insns.def"
2398
+ # line 866 "insns.def"
2467
2399
  {
2468
2400
  val = vm_opt_nil_p(GET_ISEQ(), cd, recv);
2469
2401
 
@@ -2471,7 +2403,7 @@ INSN_ENTRY(opt_nil_p)
2471
2403
  CALL_SIMPLE_METHOD();
2472
2404
  }
2473
2405
  }
2474
- # line 2475 "vm.inc"
2406
+ # line 2407 "vm.inc"
2475
2407
  # undef NAME_OF_CURRENT_INSN
2476
2408
 
2477
2409
  /* ### Instruction trailers. ### */
@@ -2481,7 +2413,6 @@ INSN_ENTRY(opt_nil_p)
2481
2413
  TOPN(0) = val;
2482
2414
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_NONE));
2483
2415
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_MOVED));
2484
- if (leaf) ADD_PC(INSN_ATTR(width));
2485
2416
  # undef INSN_ATTR
2486
2417
 
2487
2418
  /* ### Leave the instruction. ### */
@@ -2499,11 +2430,11 @@ INSN_ENTRY(opt_str_uminus)
2499
2430
  VALUE str = (VALUE)GET_OPERAND(1);
2500
2431
  CALL_DATA cd = (CALL_DATA)GET_OPERAND(2);
2501
2432
  # define INSN_ATTR(x) attr_ ## x ## _opt_str_uminus(str, cd)
2502
- const bool leaf = INSN_ATTR(leaf);
2433
+ const bool MAYBE_UNUSED(leaf) = INSN_ATTR(leaf);
2503
2434
  VALUE val;
2504
2435
 
2505
2436
  /* ### Instruction preambles. ### */
2506
- if (! leaf) ADD_PC(INSN_ATTR(width));
2437
+ ADD_PC(INSN_ATTR(width));
2507
2438
  SETUP_CANARY(leaf);
2508
2439
  COLLECT_USAGE_INSN(INSN_ATTR(bin));
2509
2440
  COLLECT_USAGE_OPERAND(INSN_ATTR(bin), 0, str);
@@ -2511,7 +2442,7 @@ INSN_ENTRY(opt_str_uminus)
2511
2442
 
2512
2443
  /* ### Here we do the instruction body. ### */
2513
2444
  # define NAME_OF_CURRENT_INSN opt_str_uminus
2514
- # line 892 "insns.def"
2445
+ # line 879 "insns.def"
2515
2446
  {
2516
2447
  val = vm_opt_str_freeze(str, BOP_UMINUS, idUMinus);
2517
2448
 
@@ -2520,7 +2451,7 @@ INSN_ENTRY(opt_str_uminus)
2520
2451
  CALL_SIMPLE_METHOD();
2521
2452
  }
2522
2453
  }
2523
- # line 2524 "vm.inc"
2454
+ # line 2455 "vm.inc"
2524
2455
  # undef NAME_OF_CURRENT_INSN
2525
2456
 
2526
2457
  /* ### Instruction trailers. ### */
@@ -2530,7 +2461,6 @@ INSN_ENTRY(opt_str_uminus)
2530
2461
  TOPN(0) = val;
2531
2462
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_NONE));
2532
2463
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_MOVED));
2533
- if (leaf) ADD_PC(INSN_ATTR(width));
2534
2464
  # undef INSN_ATTR
2535
2465
 
2536
2466
  /* ### Leave the instruction. ### */
@@ -2548,11 +2478,11 @@ INSN_ENTRY(opt_newarray_send)
2548
2478
  rb_num_t num = (rb_num_t)GET_OPERAND(1);
2549
2479
  ID method = (ID)GET_OPERAND(2);
2550
2480
  # define INSN_ATTR(x) attr_ ## x ## _opt_newarray_send(num, method)
2551
- const bool leaf = INSN_ATTR(leaf);
2481
+ const bool MAYBE_UNUSED(leaf) = INSN_ATTR(leaf);
2552
2482
  VALUE val;
2553
2483
 
2554
2484
  /* ### Instruction preambles. ### */
2555
- if (! leaf) ADD_PC(INSN_ATTR(width));
2485
+ ADD_PC(INSN_ATTR(width));
2556
2486
  SETUP_CANARY(leaf);
2557
2487
  COLLECT_USAGE_INSN(INSN_ATTR(bin));
2558
2488
  COLLECT_USAGE_OPERAND(INSN_ATTR(bin), 0, num);
@@ -2560,7 +2490,7 @@ INSN_ENTRY(opt_newarray_send)
2560
2490
 
2561
2491
  /* ### Here we do the instruction body. ### */
2562
2492
  # define NAME_OF_CURRENT_INSN opt_newarray_send
2563
- # line 913 "insns.def"
2493
+ # line 900 "insns.def"
2564
2494
  {
2565
2495
  switch(method) {
2566
2496
  case idHash:
@@ -2576,7 +2506,7 @@ INSN_ENTRY(opt_newarray_send)
2576
2506
  rb_bug("unreachable");
2577
2507
  }
2578
2508
  }
2579
- # line 2580 "vm.inc"
2509
+ # line 2510 "vm.inc"
2580
2510
  # undef NAME_OF_CURRENT_INSN
2581
2511
 
2582
2512
  /* ### Instruction trailers. ### */
@@ -2586,7 +2516,6 @@ INSN_ENTRY(opt_newarray_send)
2586
2516
  TOPN(0) = val;
2587
2517
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_NONE));
2588
2518
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_MOVED));
2589
- if (leaf) ADD_PC(INSN_ATTR(width));
2590
2519
  # undef INSN_ATTR
2591
2520
 
2592
2521
  /* ### Leave the instruction. ### */
@@ -2604,11 +2533,11 @@ INSN_ENTRY(invokesuper)
2604
2533
  CALL_DATA cd = (CALL_DATA)GET_OPERAND(1);
2605
2534
  ISEQ blockiseq = (ISEQ)GET_OPERAND(2);
2606
2535
  # define INSN_ATTR(x) attr_ ## x ## _invokesuper(cd, blockiseq)
2607
- const bool leaf = INSN_ATTR(leaf);
2536
+ const bool MAYBE_UNUSED(leaf) = INSN_ATTR(leaf);
2608
2537
  VALUE val;
2609
2538
 
2610
2539
  /* ### Instruction preambles. ### */
2611
- if (! leaf) ADD_PC(INSN_ATTR(width));
2540
+ ADD_PC(INSN_ATTR(width));
2612
2541
  POPN(INSN_ATTR(popn));
2613
2542
  SETUP_CANARY(leaf);
2614
2543
  COLLECT_USAGE_INSN(INSN_ATTR(bin));
@@ -2617,7 +2546,7 @@ INSN_ENTRY(invokesuper)
2617
2546
 
2618
2547
  /* ### Here we do the instruction body. ### */
2619
2548
  # define NAME_OF_CURRENT_INSN invokesuper
2620
- # line 937 "insns.def"
2549
+ # line 924 "insns.def"
2621
2550
  {
2622
2551
  VALUE bh = vm_caller_setup_arg_block(ec, GET_CFP(), cd->ci, blockiseq, true);
2623
2552
  val = vm_sendish(ec, GET_CFP(), cd, bh, mexp_search_super);
@@ -2628,14 +2557,13 @@ INSN_ENTRY(invokesuper)
2628
2557
  NEXT_INSN();
2629
2558
  }
2630
2559
  }
2631
- # line 2632 "vm.inc"
2560
+ # line 2561 "vm.inc"
2632
2561
  # undef NAME_OF_CURRENT_INSN
2633
2562
 
2634
2563
  /* ### Instruction trailers. ### */
2635
2564
  CHECK_VM_STACK_OVERFLOW_FOR_INSN(VM_REG_CFP, INSN_ATTR(retn));
2636
2565
  CHECK_CANARY(leaf, INSN_ATTR(bin));
2637
2566
  PUSH(val);
2638
- if (leaf) ADD_PC(INSN_ATTR(width));
2639
2567
  # undef INSN_ATTR
2640
2568
 
2641
2569
  /* ### Leave the instruction. ### */
@@ -2652,11 +2580,11 @@ INSN_ENTRY(invokeblock)
2652
2580
  /* ### Declare and assign variables. ### */
2653
2581
  CALL_DATA cd = (CALL_DATA)GET_OPERAND(1);
2654
2582
  # define INSN_ATTR(x) attr_ ## x ## _invokeblock(cd)
2655
- const bool leaf = INSN_ATTR(leaf);
2583
+ const bool MAYBE_UNUSED(leaf) = INSN_ATTR(leaf);
2656
2584
  VALUE val;
2657
2585
 
2658
2586
  /* ### Instruction preambles. ### */
2659
- if (! leaf) ADD_PC(INSN_ATTR(width));
2587
+ ADD_PC(INSN_ATTR(width));
2660
2588
  POPN(INSN_ATTR(popn));
2661
2589
  SETUP_CANARY(leaf);
2662
2590
  COLLECT_USAGE_INSN(INSN_ATTR(bin));
@@ -2664,7 +2592,7 @@ INSN_ENTRY(invokeblock)
2664
2592
 
2665
2593
  /* ### Here we do the instruction body. ### */
2666
2594
  # define NAME_OF_CURRENT_INSN invokeblock
2667
- # line 957 "insns.def"
2595
+ # line 944 "insns.def"
2668
2596
  {
2669
2597
  VALUE bh = VM_BLOCK_HANDLER_NONE;
2670
2598
  val = vm_sendish(ec, GET_CFP(), cd, bh, mexp_search_invokeblock);
@@ -2675,14 +2603,13 @@ INSN_ENTRY(invokeblock)
2675
2603
  NEXT_INSN();
2676
2604
  }
2677
2605
  }
2678
- # line 2679 "vm.inc"
2606
+ # line 2607 "vm.inc"
2679
2607
  # undef NAME_OF_CURRENT_INSN
2680
2608
 
2681
2609
  /* ### Instruction trailers. ### */
2682
2610
  CHECK_VM_STACK_OVERFLOW_FOR_INSN(VM_REG_CFP, INSN_ATTR(retn));
2683
2611
  CHECK_CANARY(leaf, INSN_ATTR(bin));
2684
2612
  PUSH(val);
2685
- if (leaf) ADD_PC(INSN_ATTR(width));
2686
2613
  # undef INSN_ATTR
2687
2614
 
2688
2615
  /* ### Leave the instruction. ### */
@@ -2698,18 +2625,18 @@ INSN_ENTRY(leave)
2698
2625
 
2699
2626
  /* ### Declare and assign variables. ### */
2700
2627
  # define INSN_ATTR(x) attr_ ## x ## _leave()
2701
- const bool leaf = INSN_ATTR(leaf);
2628
+ const bool MAYBE_UNUSED(leaf) = INSN_ATTR(leaf);
2702
2629
  VALUE val = TOPN(0);
2703
2630
 
2704
2631
  /* ### Instruction preambles. ### */
2705
- if (! leaf) ADD_PC(INSN_ATTR(width));
2632
+ ADD_PC(INSN_ATTR(width));
2706
2633
  POPN(INSN_ATTR(popn));
2707
2634
  SETUP_CANARY(leaf);
2708
2635
  COLLECT_USAGE_INSN(INSN_ATTR(bin));
2709
2636
 
2710
2637
  /* ### Here we do the instruction body. ### */
2711
2638
  # define NAME_OF_CURRENT_INSN leave
2712
- # line 979 "insns.def"
2639
+ # line 966 "insns.def"
2713
2640
  {
2714
2641
  if (OPT_CHECKED_RUN) {
2715
2642
  const VALUE *const bp = vm_base_ptr(GET_CFP());
@@ -2730,14 +2657,13 @@ INSN_ENTRY(leave)
2730
2657
  RESTORE_REGS();
2731
2658
  }
2732
2659
  }
2733
- # line 2734 "vm.inc"
2660
+ # line 2661 "vm.inc"
2734
2661
  # undef NAME_OF_CURRENT_INSN
2735
2662
 
2736
2663
  /* ### Instruction trailers. ### */
2737
2664
  CHECK_VM_STACK_OVERFLOW_FOR_INSN(VM_REG_CFP, INSN_ATTR(retn));
2738
2665
  CHECK_CANARY(leaf, INSN_ATTR(bin));
2739
2666
  PUSH(val);
2740
- if (leaf) ADD_PC(INSN_ATTR(width));
2741
2667
  # undef INSN_ATTR
2742
2668
 
2743
2669
  /* ### Leave the instruction. ### */
@@ -2754,25 +2680,25 @@ INSN_ENTRY(throw)
2754
2680
  /* ### Declare and assign variables. ### */
2755
2681
  rb_num_t throw_state = (rb_num_t)GET_OPERAND(1);
2756
2682
  # define INSN_ATTR(x) attr_ ## x ## _throw(throw_state)
2757
- const bool leaf = INSN_ATTR(leaf);
2683
+ const bool MAYBE_UNUSED(leaf) = INSN_ATTR(leaf);
2758
2684
  VALUE throwobj = TOPN(0);
2759
2685
  VALUE val;
2760
2686
 
2761
2687
  /* ### Instruction preambles. ### */
2762
- if (! leaf) ADD_PC(INSN_ATTR(width));
2688
+ ADD_PC(INSN_ATTR(width));
2763
2689
  SETUP_CANARY(leaf);
2764
2690
  COLLECT_USAGE_INSN(INSN_ATTR(bin));
2765
2691
  COLLECT_USAGE_OPERAND(INSN_ATTR(bin), 0, throw_state);
2766
2692
 
2767
2693
  /* ### Here we do the instruction body. ### */
2768
2694
  # define NAME_OF_CURRENT_INSN throw
2769
- # line 1012 "insns.def"
2695
+ # line 999 "insns.def"
2770
2696
  {
2771
2697
  val = vm_throw(ec, GET_CFP(), throw_state, throwobj);
2772
2698
  THROW_EXCEPTION(val);
2773
2699
  /* unreachable */
2774
2700
  }
2775
- # line 2776 "vm.inc"
2701
+ # line 2702 "vm.inc"
2776
2702
  # undef NAME_OF_CURRENT_INSN
2777
2703
 
2778
2704
  /* ### Instruction trailers. ### */
@@ -2782,7 +2708,6 @@ INSN_ENTRY(throw)
2782
2708
  TOPN(0) = val;
2783
2709
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_NONE));
2784
2710
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_MOVED));
2785
- if (leaf) ADD_PC(INSN_ATTR(width));
2786
2711
  # undef INSN_ATTR
2787
2712
 
2788
2713
  /* ### Leave the instruction. ### */
@@ -2799,29 +2724,28 @@ INSN_ENTRY(jump)
2799
2724
  /* ### Declare and assign variables. ### */
2800
2725
  OFFSET dst = (OFFSET)GET_OPERAND(1);
2801
2726
  # define INSN_ATTR(x) attr_ ## x ## _jump(dst)
2802
- const bool leaf = INSN_ATTR(leaf);
2727
+ const bool MAYBE_UNUSED(leaf) = INSN_ATTR(leaf);
2803
2728
 
2804
2729
  /* ### Instruction preambles. ### */
2805
- if (! leaf) ADD_PC(INSN_ATTR(width));
2730
+ ADD_PC(INSN_ATTR(width));
2806
2731
  SETUP_CANARY(leaf);
2807
2732
  COLLECT_USAGE_INSN(INSN_ATTR(bin));
2808
2733
  COLLECT_USAGE_OPERAND(INSN_ATTR(bin), 0, dst);
2809
2734
 
2810
2735
  /* ### Here we do the instruction body. ### */
2811
2736
  # define NAME_OF_CURRENT_INSN jump
2812
- # line 1030 "insns.def"
2737
+ # line 1017 "insns.def"
2813
2738
  {
2814
2739
  RUBY_VM_CHECK_INTS(ec);
2815
2740
  JUMP(dst);
2816
2741
  }
2817
- # line 2818 "vm.inc"
2742
+ # line 2743 "vm.inc"
2818
2743
  # undef NAME_OF_CURRENT_INSN
2819
2744
 
2820
2745
  /* ### Instruction trailers. ### */
2821
2746
  CHECK_VM_STACK_OVERFLOW_FOR_INSN(VM_REG_CFP, INSN_ATTR(retn));
2822
2747
  CHECK_CANARY(leaf, INSN_ATTR(bin));
2823
2748
  INC_SP(INSN_ATTR(sp_inc));
2824
- if (leaf) ADD_PC(INSN_ATTR(width));
2825
2749
  # undef INSN_ATTR
2826
2750
 
2827
2751
  /* ### Leave the instruction. ### */
@@ -2838,32 +2762,31 @@ INSN_ENTRY(branchif)
2838
2762
  /* ### Declare and assign variables. ### */
2839
2763
  OFFSET dst = (OFFSET)GET_OPERAND(1);
2840
2764
  # define INSN_ATTR(x) attr_ ## x ## _branchif(dst)
2841
- const bool leaf = INSN_ATTR(leaf);
2765
+ const bool MAYBE_UNUSED(leaf) = INSN_ATTR(leaf);
2842
2766
  VALUE val = TOPN(0);
2843
2767
 
2844
2768
  /* ### Instruction preambles. ### */
2845
- if (! leaf) ADD_PC(INSN_ATTR(width));
2769
+ ADD_PC(INSN_ATTR(width));
2846
2770
  SETUP_CANARY(leaf);
2847
2771
  COLLECT_USAGE_INSN(INSN_ATTR(bin));
2848
2772
  COLLECT_USAGE_OPERAND(INSN_ATTR(bin), 0, dst);
2849
2773
 
2850
2774
  /* ### Here we do the instruction body. ### */
2851
2775
  # define NAME_OF_CURRENT_INSN branchif
2852
- # line 1043 "insns.def"
2776
+ # line 1030 "insns.def"
2853
2777
  {
2854
2778
  if (RTEST(val)) {
2855
2779
  RUBY_VM_CHECK_INTS(ec);
2856
2780
  JUMP(dst);
2857
2781
  }
2858
2782
  }
2859
- # line 2860 "vm.inc"
2783
+ # line 2784 "vm.inc"
2860
2784
  # undef NAME_OF_CURRENT_INSN
2861
2785
 
2862
2786
  /* ### Instruction trailers. ### */
2863
2787
  CHECK_VM_STACK_OVERFLOW_FOR_INSN(VM_REG_CFP, INSN_ATTR(retn));
2864
2788
  CHECK_CANARY(leaf, INSN_ATTR(bin));
2865
2789
  INC_SP(INSN_ATTR(sp_inc));
2866
- if (leaf) ADD_PC(INSN_ATTR(width));
2867
2790
  # undef INSN_ATTR
2868
2791
 
2869
2792
  /* ### Leave the instruction. ### */
@@ -2880,32 +2803,31 @@ INSN_ENTRY(branchunless)
2880
2803
  /* ### Declare and assign variables. ### */
2881
2804
  OFFSET dst = (OFFSET)GET_OPERAND(1);
2882
2805
  # define INSN_ATTR(x) attr_ ## x ## _branchunless(dst)
2883
- const bool leaf = INSN_ATTR(leaf);
2806
+ const bool MAYBE_UNUSED(leaf) = INSN_ATTR(leaf);
2884
2807
  VALUE val = TOPN(0);
2885
2808
 
2886
2809
  /* ### Instruction preambles. ### */
2887
- if (! leaf) ADD_PC(INSN_ATTR(width));
2810
+ ADD_PC(INSN_ATTR(width));
2888
2811
  SETUP_CANARY(leaf);
2889
2812
  COLLECT_USAGE_INSN(INSN_ATTR(bin));
2890
2813
  COLLECT_USAGE_OPERAND(INSN_ATTR(bin), 0, dst);
2891
2814
 
2892
2815
  /* ### Here we do the instruction body. ### */
2893
2816
  # define NAME_OF_CURRENT_INSN branchunless
2894
- # line 1058 "insns.def"
2817
+ # line 1045 "insns.def"
2895
2818
  {
2896
2819
  if (!RTEST(val)) {
2897
2820
  RUBY_VM_CHECK_INTS(ec);
2898
2821
  JUMP(dst);
2899
2822
  }
2900
2823
  }
2901
- # line 2902 "vm.inc"
2824
+ # line 2825 "vm.inc"
2902
2825
  # undef NAME_OF_CURRENT_INSN
2903
2826
 
2904
2827
  /* ### Instruction trailers. ### */
2905
2828
  CHECK_VM_STACK_OVERFLOW_FOR_INSN(VM_REG_CFP, INSN_ATTR(retn));
2906
2829
  CHECK_CANARY(leaf, INSN_ATTR(bin));
2907
2830
  INC_SP(INSN_ATTR(sp_inc));
2908
- if (leaf) ADD_PC(INSN_ATTR(width));
2909
2831
  # undef INSN_ATTR
2910
2832
 
2911
2833
  /* ### Leave the instruction. ### */
@@ -2922,32 +2844,31 @@ INSN_ENTRY(branchnil)
2922
2844
  /* ### Declare and assign variables. ### */
2923
2845
  OFFSET dst = (OFFSET)GET_OPERAND(1);
2924
2846
  # define INSN_ATTR(x) attr_ ## x ## _branchnil(dst)
2925
- const bool leaf = INSN_ATTR(leaf);
2847
+ const bool MAYBE_UNUSED(leaf) = INSN_ATTR(leaf);
2926
2848
  VALUE val = TOPN(0);
2927
2849
 
2928
2850
  /* ### Instruction preambles. ### */
2929
- if (! leaf) ADD_PC(INSN_ATTR(width));
2851
+ ADD_PC(INSN_ATTR(width));
2930
2852
  SETUP_CANARY(leaf);
2931
2853
  COLLECT_USAGE_INSN(INSN_ATTR(bin));
2932
2854
  COLLECT_USAGE_OPERAND(INSN_ATTR(bin), 0, dst);
2933
2855
 
2934
2856
  /* ### Here we do the instruction body. ### */
2935
2857
  # define NAME_OF_CURRENT_INSN branchnil
2936
- # line 1073 "insns.def"
2858
+ # line 1060 "insns.def"
2937
2859
  {
2938
2860
  if (NIL_P(val)) {
2939
2861
  RUBY_VM_CHECK_INTS(ec);
2940
2862
  JUMP(dst);
2941
2863
  }
2942
2864
  }
2943
- # line 2944 "vm.inc"
2865
+ # line 2866 "vm.inc"
2944
2866
  # undef NAME_OF_CURRENT_INSN
2945
2867
 
2946
2868
  /* ### Instruction trailers. ### */
2947
2869
  CHECK_VM_STACK_OVERFLOW_FOR_INSN(VM_REG_CFP, INSN_ATTR(retn));
2948
2870
  CHECK_CANARY(leaf, INSN_ATTR(bin));
2949
2871
  INC_SP(INSN_ATTR(sp_inc));
2950
- if (leaf) ADD_PC(INSN_ATTR(width));
2951
2872
  # undef INSN_ATTR
2952
2873
 
2953
2874
  /* ### Leave the instruction. ### */
@@ -2965,11 +2886,11 @@ INSN_ENTRY(once)
2965
2886
  ISEQ iseq = (ISEQ)GET_OPERAND(1);
2966
2887
  ISE ise = (ISE)GET_OPERAND(2);
2967
2888
  # define INSN_ATTR(x) attr_ ## x ## _once(iseq, ise)
2968
- const bool leaf = INSN_ATTR(leaf);
2889
+ const bool MAYBE_UNUSED(leaf) = INSN_ATTR(leaf);
2969
2890
  VALUE val;
2970
2891
 
2971
2892
  /* ### Instruction preambles. ### */
2972
- if (! leaf) ADD_PC(INSN_ATTR(width));
2893
+ ADD_PC(INSN_ATTR(width));
2973
2894
  POPN(INSN_ATTR(popn));
2974
2895
  SETUP_CANARY(leaf);
2975
2896
  COLLECT_USAGE_INSN(INSN_ATTR(bin));
@@ -2978,18 +2899,17 @@ INSN_ENTRY(once)
2978
2899
 
2979
2900
  /* ### Here we do the instruction body. ### */
2980
2901
  # define NAME_OF_CURRENT_INSN once
2981
- # line 1090 "insns.def"
2902
+ # line 1077 "insns.def"
2982
2903
  {
2983
2904
  val = vm_once_dispatch(ec, iseq, ise);
2984
2905
  }
2985
- # line 2986 "vm.inc"
2906
+ # line 2907 "vm.inc"
2986
2907
  # undef NAME_OF_CURRENT_INSN
2987
2908
 
2988
2909
  /* ### Instruction trailers. ### */
2989
2910
  CHECK_VM_STACK_OVERFLOW_FOR_INSN(VM_REG_CFP, INSN_ATTR(retn));
2990
2911
  CHECK_CANARY(leaf, INSN_ATTR(bin));
2991
2912
  PUSH(val);
2992
- if (leaf) ADD_PC(INSN_ATTR(width));
2993
2913
  # undef INSN_ATTR
2994
2914
 
2995
2915
  /* ### Leave the instruction. ### */
@@ -3007,11 +2927,11 @@ INSN_ENTRY(opt_case_dispatch)
3007
2927
  CDHASH hash = (CDHASH)GET_OPERAND(1);
3008
2928
  OFFSET else_offset = (OFFSET)GET_OPERAND(2);
3009
2929
  # define INSN_ATTR(x) attr_ ## x ## _opt_case_dispatch(hash, else_offset)
3010
- const bool leaf = INSN_ATTR(leaf);
2930
+ const bool MAYBE_UNUSED(leaf) = INSN_ATTR(leaf);
3011
2931
  VALUE key = TOPN(0);
3012
2932
 
3013
2933
  /* ### Instruction preambles. ### */
3014
- if (! leaf) ADD_PC(INSN_ATTR(width));
2934
+ ADD_PC(INSN_ATTR(width));
3015
2935
  SETUP_CANARY(leaf);
3016
2936
  COLLECT_USAGE_INSN(INSN_ATTR(bin));
3017
2937
  COLLECT_USAGE_OPERAND(INSN_ATTR(bin), 0, hash);
@@ -3019,7 +2939,7 @@ INSN_ENTRY(opt_case_dispatch)
3019
2939
 
3020
2940
  /* ### Here we do the instruction body. ### */
3021
2941
  # define NAME_OF_CURRENT_INSN opt_case_dispatch
3022
- # line 1101 "insns.def"
2942
+ # line 1088 "insns.def"
3023
2943
  {
3024
2944
  OFFSET dst = vm_case_dispatch(hash, else_offset, key);
3025
2945
 
@@ -3027,14 +2947,13 @@ INSN_ENTRY(opt_case_dispatch)
3027
2947
  JUMP(dst);
3028
2948
  }
3029
2949
  }
3030
- # line 3031 "vm.inc"
2950
+ # line 2951 "vm.inc"
3031
2951
  # undef NAME_OF_CURRENT_INSN
3032
2952
 
3033
2953
  /* ### Instruction trailers. ### */
3034
2954
  CHECK_VM_STACK_OVERFLOW_FOR_INSN(VM_REG_CFP, INSN_ATTR(retn));
3035
2955
  CHECK_CANARY(leaf, INSN_ATTR(bin));
3036
2956
  INC_SP(INSN_ATTR(sp_inc));
3037
- if (leaf) ADD_PC(INSN_ATTR(width));
3038
2957
  # undef INSN_ATTR
3039
2958
 
3040
2959
  /* ### Leave the instruction. ### */
@@ -3051,20 +2970,20 @@ INSN_ENTRY(opt_plus)
3051
2970
  /* ### Declare and assign variables. ### */
3052
2971
  CALL_DATA cd = (CALL_DATA)GET_OPERAND(1);
3053
2972
  # define INSN_ATTR(x) attr_ ## x ## _opt_plus(cd)
3054
- const bool leaf = INSN_ATTR(leaf);
2973
+ const bool MAYBE_UNUSED(leaf) = INSN_ATTR(leaf);
3055
2974
  VALUE recv = TOPN(1);
3056
2975
  VALUE obj = TOPN(0);
3057
2976
  VALUE val;
3058
2977
 
3059
2978
  /* ### Instruction preambles. ### */
3060
- if (! leaf) ADD_PC(INSN_ATTR(width));
2979
+ ADD_PC(INSN_ATTR(width));
3061
2980
  SETUP_CANARY(leaf);
3062
2981
  COLLECT_USAGE_INSN(INSN_ATTR(bin));
3063
2982
  COLLECT_USAGE_OPERAND(INSN_ATTR(bin), 0, cd);
3064
2983
 
3065
2984
  /* ### Here we do the instruction body. ### */
3066
2985
  # define NAME_OF_CURRENT_INSN opt_plus
3067
- # line 1117 "insns.def"
2986
+ # line 1104 "insns.def"
3068
2987
  {
3069
2988
  val = vm_opt_plus(recv, obj);
3070
2989
 
@@ -3072,7 +2991,7 @@ INSN_ENTRY(opt_plus)
3072
2991
  CALL_SIMPLE_METHOD();
3073
2992
  }
3074
2993
  }
3075
- # line 3076 "vm.inc"
2994
+ # line 2995 "vm.inc"
3076
2995
  # undef NAME_OF_CURRENT_INSN
3077
2996
 
3078
2997
  /* ### Instruction trailers. ### */
@@ -3082,7 +3001,6 @@ INSN_ENTRY(opt_plus)
3082
3001
  TOPN(0) = val;
3083
3002
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_NONE));
3084
3003
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_MOVED));
3085
- if (leaf) ADD_PC(INSN_ATTR(width));
3086
3004
  # undef INSN_ATTR
3087
3005
 
3088
3006
  /* ### Leave the instruction. ### */
@@ -3099,20 +3017,20 @@ INSN_ENTRY(opt_minus)
3099
3017
  /* ### Declare and assign variables. ### */
3100
3018
  CALL_DATA cd = (CALL_DATA)GET_OPERAND(1);
3101
3019
  # define INSN_ATTR(x) attr_ ## x ## _opt_minus(cd)
3102
- const bool leaf = INSN_ATTR(leaf);
3020
+ const bool MAYBE_UNUSED(leaf) = INSN_ATTR(leaf);
3103
3021
  VALUE recv = TOPN(1);
3104
3022
  VALUE obj = TOPN(0);
3105
3023
  VALUE val;
3106
3024
 
3107
3025
  /* ### Instruction preambles. ### */
3108
- if (! leaf) ADD_PC(INSN_ATTR(width));
3026
+ ADD_PC(INSN_ATTR(width));
3109
3027
  SETUP_CANARY(leaf);
3110
3028
  COLLECT_USAGE_INSN(INSN_ATTR(bin));
3111
3029
  COLLECT_USAGE_OPERAND(INSN_ATTR(bin), 0, cd);
3112
3030
 
3113
3031
  /* ### Here we do the instruction body. ### */
3114
3032
  # define NAME_OF_CURRENT_INSN opt_minus
3115
- # line 1131 "insns.def"
3033
+ # line 1118 "insns.def"
3116
3034
  {
3117
3035
  val = vm_opt_minus(recv, obj);
3118
3036
 
@@ -3120,7 +3038,7 @@ INSN_ENTRY(opt_minus)
3120
3038
  CALL_SIMPLE_METHOD();
3121
3039
  }
3122
3040
  }
3123
- # line 3124 "vm.inc"
3041
+ # line 3042 "vm.inc"
3124
3042
  # undef NAME_OF_CURRENT_INSN
3125
3043
 
3126
3044
  /* ### Instruction trailers. ### */
@@ -3130,7 +3048,6 @@ INSN_ENTRY(opt_minus)
3130
3048
  TOPN(0) = val;
3131
3049
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_NONE));
3132
3050
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_MOVED));
3133
- if (leaf) ADD_PC(INSN_ATTR(width));
3134
3051
  # undef INSN_ATTR
3135
3052
 
3136
3053
  /* ### Leave the instruction. ### */
@@ -3147,20 +3064,20 @@ INSN_ENTRY(opt_mult)
3147
3064
  /* ### Declare and assign variables. ### */
3148
3065
  CALL_DATA cd = (CALL_DATA)GET_OPERAND(1);
3149
3066
  # define INSN_ATTR(x) attr_ ## x ## _opt_mult(cd)
3150
- const bool leaf = INSN_ATTR(leaf);
3067
+ const bool MAYBE_UNUSED(leaf) = INSN_ATTR(leaf);
3151
3068
  VALUE recv = TOPN(1);
3152
3069
  VALUE obj = TOPN(0);
3153
3070
  VALUE val;
3154
3071
 
3155
3072
  /* ### Instruction preambles. ### */
3156
- if (! leaf) ADD_PC(INSN_ATTR(width));
3073
+ ADD_PC(INSN_ATTR(width));
3157
3074
  SETUP_CANARY(leaf);
3158
3075
  COLLECT_USAGE_INSN(INSN_ATTR(bin));
3159
3076
  COLLECT_USAGE_OPERAND(INSN_ATTR(bin), 0, cd);
3160
3077
 
3161
3078
  /* ### Here we do the instruction body. ### */
3162
3079
  # define NAME_OF_CURRENT_INSN opt_mult
3163
- # line 1145 "insns.def"
3080
+ # line 1132 "insns.def"
3164
3081
  {
3165
3082
  val = vm_opt_mult(recv, obj);
3166
3083
 
@@ -3168,7 +3085,7 @@ INSN_ENTRY(opt_mult)
3168
3085
  CALL_SIMPLE_METHOD();
3169
3086
  }
3170
3087
  }
3171
- # line 3172 "vm.inc"
3088
+ # line 3089 "vm.inc"
3172
3089
  # undef NAME_OF_CURRENT_INSN
3173
3090
 
3174
3091
  /* ### Instruction trailers. ### */
@@ -3178,7 +3095,6 @@ INSN_ENTRY(opt_mult)
3178
3095
  TOPN(0) = val;
3179
3096
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_NONE));
3180
3097
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_MOVED));
3181
- if (leaf) ADD_PC(INSN_ATTR(width));
3182
3098
  # undef INSN_ATTR
3183
3099
 
3184
3100
  /* ### Leave the instruction. ### */
@@ -3195,20 +3111,20 @@ INSN_ENTRY(opt_div)
3195
3111
  /* ### Declare and assign variables. ### */
3196
3112
  CALL_DATA cd = (CALL_DATA)GET_OPERAND(1);
3197
3113
  # define INSN_ATTR(x) attr_ ## x ## _opt_div(cd)
3198
- const bool leaf = INSN_ATTR(leaf);
3114
+ const bool MAYBE_UNUSED(leaf) = INSN_ATTR(leaf);
3199
3115
  VALUE recv = TOPN(1);
3200
3116
  VALUE obj = TOPN(0);
3201
3117
  VALUE val;
3202
3118
 
3203
3119
  /* ### Instruction preambles. ### */
3204
- if (! leaf) ADD_PC(INSN_ATTR(width));
3120
+ ADD_PC(INSN_ATTR(width));
3205
3121
  SETUP_CANARY(leaf);
3206
3122
  COLLECT_USAGE_INSN(INSN_ATTR(bin));
3207
3123
  COLLECT_USAGE_OPERAND(INSN_ATTR(bin), 0, cd);
3208
3124
 
3209
3125
  /* ### Here we do the instruction body. ### */
3210
3126
  # define NAME_OF_CURRENT_INSN opt_div
3211
- # line 1162 "insns.def"
3127
+ # line 1149 "insns.def"
3212
3128
  {
3213
3129
  val = vm_opt_div(recv, obj);
3214
3130
 
@@ -3216,7 +3132,7 @@ INSN_ENTRY(opt_div)
3216
3132
  CALL_SIMPLE_METHOD();
3217
3133
  }
3218
3134
  }
3219
- # line 3220 "vm.inc"
3135
+ # line 3136 "vm.inc"
3220
3136
  # undef NAME_OF_CURRENT_INSN
3221
3137
 
3222
3138
  /* ### Instruction trailers. ### */
@@ -3226,7 +3142,6 @@ INSN_ENTRY(opt_div)
3226
3142
  TOPN(0) = val;
3227
3143
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_NONE));
3228
3144
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_MOVED));
3229
- if (leaf) ADD_PC(INSN_ATTR(width));
3230
3145
  # undef INSN_ATTR
3231
3146
 
3232
3147
  /* ### Leave the instruction. ### */
@@ -3243,20 +3158,20 @@ INSN_ENTRY(opt_mod)
3243
3158
  /* ### Declare and assign variables. ### */
3244
3159
  CALL_DATA cd = (CALL_DATA)GET_OPERAND(1);
3245
3160
  # define INSN_ATTR(x) attr_ ## x ## _opt_mod(cd)
3246
- const bool leaf = INSN_ATTR(leaf);
3161
+ const bool MAYBE_UNUSED(leaf) = INSN_ATTR(leaf);
3247
3162
  VALUE recv = TOPN(1);
3248
3163
  VALUE obj = TOPN(0);
3249
3164
  VALUE val;
3250
3165
 
3251
3166
  /* ### Instruction preambles. ### */
3252
- if (! leaf) ADD_PC(INSN_ATTR(width));
3167
+ ADD_PC(INSN_ATTR(width));
3253
3168
  SETUP_CANARY(leaf);
3254
3169
  COLLECT_USAGE_INSN(INSN_ATTR(bin));
3255
3170
  COLLECT_USAGE_OPERAND(INSN_ATTR(bin), 0, cd);
3256
3171
 
3257
3172
  /* ### Here we do the instruction body. ### */
3258
3173
  # define NAME_OF_CURRENT_INSN opt_mod
3259
- # line 1178 "insns.def"
3174
+ # line 1165 "insns.def"
3260
3175
  {
3261
3176
  val = vm_opt_mod(recv, obj);
3262
3177
 
@@ -3264,7 +3179,7 @@ INSN_ENTRY(opt_mod)
3264
3179
  CALL_SIMPLE_METHOD();
3265
3180
  }
3266
3181
  }
3267
- # line 3268 "vm.inc"
3182
+ # line 3183 "vm.inc"
3268
3183
  # undef NAME_OF_CURRENT_INSN
3269
3184
 
3270
3185
  /* ### Instruction trailers. ### */
@@ -3274,7 +3189,6 @@ INSN_ENTRY(opt_mod)
3274
3189
  TOPN(0) = val;
3275
3190
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_NONE));
3276
3191
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_MOVED));
3277
- if (leaf) ADD_PC(INSN_ATTR(width));
3278
3192
  # undef INSN_ATTR
3279
3193
 
3280
3194
  /* ### Leave the instruction. ### */
@@ -3291,20 +3205,20 @@ INSN_ENTRY(opt_eq)
3291
3205
  /* ### Declare and assign variables. ### */
3292
3206
  CALL_DATA cd = (CALL_DATA)GET_OPERAND(1);
3293
3207
  # define INSN_ATTR(x) attr_ ## x ## _opt_eq(cd)
3294
- const bool leaf = INSN_ATTR(leaf);
3208
+ const bool MAYBE_UNUSED(leaf) = INSN_ATTR(leaf);
3295
3209
  VALUE recv = TOPN(1);
3296
3210
  VALUE obj = TOPN(0);
3297
3211
  VALUE val;
3298
3212
 
3299
3213
  /* ### Instruction preambles. ### */
3300
- if (! leaf) ADD_PC(INSN_ATTR(width));
3214
+ ADD_PC(INSN_ATTR(width));
3301
3215
  SETUP_CANARY(leaf);
3302
3216
  COLLECT_USAGE_INSN(INSN_ATTR(bin));
3303
3217
  COLLECT_USAGE_OPERAND(INSN_ATTR(bin), 0, cd);
3304
3218
 
3305
3219
  /* ### Here we do the instruction body. ### */
3306
3220
  # define NAME_OF_CURRENT_INSN opt_eq
3307
- # line 1192 "insns.def"
3221
+ # line 1179 "insns.def"
3308
3222
  {
3309
3223
  val = opt_equality(GET_ISEQ(), recv, obj, cd);
3310
3224
 
@@ -3312,7 +3226,7 @@ INSN_ENTRY(opt_eq)
3312
3226
  CALL_SIMPLE_METHOD();
3313
3227
  }
3314
3228
  }
3315
- # line 3316 "vm.inc"
3229
+ # line 3230 "vm.inc"
3316
3230
  # undef NAME_OF_CURRENT_INSN
3317
3231
 
3318
3232
  /* ### Instruction trailers. ### */
@@ -3322,7 +3236,6 @@ INSN_ENTRY(opt_eq)
3322
3236
  TOPN(0) = val;
3323
3237
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_NONE));
3324
3238
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_MOVED));
3325
- if (leaf) ADD_PC(INSN_ATTR(width));
3326
3239
  # undef INSN_ATTR
3327
3240
 
3328
3241
  /* ### Leave the instruction. ### */
@@ -3340,13 +3253,13 @@ INSN_ENTRY(opt_neq)
3340
3253
  CALL_DATA cd_eq = (CALL_DATA)GET_OPERAND(1);
3341
3254
  CALL_DATA cd = (CALL_DATA)GET_OPERAND(2);
3342
3255
  # define INSN_ATTR(x) attr_ ## x ## _opt_neq(cd_eq, cd)
3343
- const bool leaf = INSN_ATTR(leaf);
3256
+ const bool MAYBE_UNUSED(leaf) = INSN_ATTR(leaf);
3344
3257
  VALUE recv = TOPN(1);
3345
3258
  VALUE obj = TOPN(0);
3346
3259
  VALUE val;
3347
3260
 
3348
3261
  /* ### Instruction preambles. ### */
3349
- if (! leaf) ADD_PC(INSN_ATTR(width));
3262
+ ADD_PC(INSN_ATTR(width));
3350
3263
  SETUP_CANARY(leaf);
3351
3264
  COLLECT_USAGE_INSN(INSN_ATTR(bin));
3352
3265
  COLLECT_USAGE_OPERAND(INSN_ATTR(bin), 0, cd_eq);
@@ -3354,7 +3267,7 @@ INSN_ENTRY(opt_neq)
3354
3267
 
3355
3268
  /* ### Here we do the instruction body. ### */
3356
3269
  # define NAME_OF_CURRENT_INSN opt_neq
3357
- # line 1206 "insns.def"
3270
+ # line 1193 "insns.def"
3358
3271
  {
3359
3272
  val = vm_opt_neq(GET_ISEQ(), cd, cd_eq, recv, obj);
3360
3273
 
@@ -3362,7 +3275,7 @@ INSN_ENTRY(opt_neq)
3362
3275
  CALL_SIMPLE_METHOD();
3363
3276
  }
3364
3277
  }
3365
- # line 3366 "vm.inc"
3278
+ # line 3279 "vm.inc"
3366
3279
  # undef NAME_OF_CURRENT_INSN
3367
3280
 
3368
3281
  /* ### Instruction trailers. ### */
@@ -3372,7 +3285,6 @@ INSN_ENTRY(opt_neq)
3372
3285
  TOPN(0) = val;
3373
3286
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_NONE));
3374
3287
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_MOVED));
3375
- if (leaf) ADD_PC(INSN_ATTR(width));
3376
3288
  # undef INSN_ATTR
3377
3289
 
3378
3290
  /* ### Leave the instruction. ### */
@@ -3389,20 +3301,20 @@ INSN_ENTRY(opt_lt)
3389
3301
  /* ### Declare and assign variables. ### */
3390
3302
  CALL_DATA cd = (CALL_DATA)GET_OPERAND(1);
3391
3303
  # define INSN_ATTR(x) attr_ ## x ## _opt_lt(cd)
3392
- const bool leaf = INSN_ATTR(leaf);
3304
+ const bool MAYBE_UNUSED(leaf) = INSN_ATTR(leaf);
3393
3305
  VALUE recv = TOPN(1);
3394
3306
  VALUE obj = TOPN(0);
3395
3307
  VALUE val;
3396
3308
 
3397
3309
  /* ### Instruction preambles. ### */
3398
- if (! leaf) ADD_PC(INSN_ATTR(width));
3310
+ ADD_PC(INSN_ATTR(width));
3399
3311
  SETUP_CANARY(leaf);
3400
3312
  COLLECT_USAGE_INSN(INSN_ATTR(bin));
3401
3313
  COLLECT_USAGE_OPERAND(INSN_ATTR(bin), 0, cd);
3402
3314
 
3403
3315
  /* ### Here we do the instruction body. ### */
3404
3316
  # define NAME_OF_CURRENT_INSN opt_lt
3405
- # line 1220 "insns.def"
3317
+ # line 1207 "insns.def"
3406
3318
  {
3407
3319
  val = vm_opt_lt(recv, obj);
3408
3320
 
@@ -3410,7 +3322,7 @@ INSN_ENTRY(opt_lt)
3410
3322
  CALL_SIMPLE_METHOD();
3411
3323
  }
3412
3324
  }
3413
- # line 3414 "vm.inc"
3325
+ # line 3326 "vm.inc"
3414
3326
  # undef NAME_OF_CURRENT_INSN
3415
3327
 
3416
3328
  /* ### Instruction trailers. ### */
@@ -3420,7 +3332,6 @@ INSN_ENTRY(opt_lt)
3420
3332
  TOPN(0) = val;
3421
3333
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_NONE));
3422
3334
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_MOVED));
3423
- if (leaf) ADD_PC(INSN_ATTR(width));
3424
3335
  # undef INSN_ATTR
3425
3336
 
3426
3337
  /* ### Leave the instruction. ### */
@@ -3437,20 +3348,20 @@ INSN_ENTRY(opt_le)
3437
3348
  /* ### Declare and assign variables. ### */
3438
3349
  CALL_DATA cd = (CALL_DATA)GET_OPERAND(1);
3439
3350
  # define INSN_ATTR(x) attr_ ## x ## _opt_le(cd)
3440
- const bool leaf = INSN_ATTR(leaf);
3351
+ const bool MAYBE_UNUSED(leaf) = INSN_ATTR(leaf);
3441
3352
  VALUE recv = TOPN(1);
3442
3353
  VALUE obj = TOPN(0);
3443
3354
  VALUE val;
3444
3355
 
3445
3356
  /* ### Instruction preambles. ### */
3446
- if (! leaf) ADD_PC(INSN_ATTR(width));
3357
+ ADD_PC(INSN_ATTR(width));
3447
3358
  SETUP_CANARY(leaf);
3448
3359
  COLLECT_USAGE_INSN(INSN_ATTR(bin));
3449
3360
  COLLECT_USAGE_OPERAND(INSN_ATTR(bin), 0, cd);
3450
3361
 
3451
3362
  /* ### Here we do the instruction body. ### */
3452
3363
  # define NAME_OF_CURRENT_INSN opt_le
3453
- # line 1234 "insns.def"
3364
+ # line 1221 "insns.def"
3454
3365
  {
3455
3366
  val = vm_opt_le(recv, obj);
3456
3367
 
@@ -3458,7 +3369,7 @@ INSN_ENTRY(opt_le)
3458
3369
  CALL_SIMPLE_METHOD();
3459
3370
  }
3460
3371
  }
3461
- # line 3462 "vm.inc"
3372
+ # line 3373 "vm.inc"
3462
3373
  # undef NAME_OF_CURRENT_INSN
3463
3374
 
3464
3375
  /* ### Instruction trailers. ### */
@@ -3468,7 +3379,6 @@ INSN_ENTRY(opt_le)
3468
3379
  TOPN(0) = val;
3469
3380
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_NONE));
3470
3381
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_MOVED));
3471
- if (leaf) ADD_PC(INSN_ATTR(width));
3472
3382
  # undef INSN_ATTR
3473
3383
 
3474
3384
  /* ### Leave the instruction. ### */
@@ -3485,20 +3395,20 @@ INSN_ENTRY(opt_gt)
3485
3395
  /* ### Declare and assign variables. ### */
3486
3396
  CALL_DATA cd = (CALL_DATA)GET_OPERAND(1);
3487
3397
  # define INSN_ATTR(x) attr_ ## x ## _opt_gt(cd)
3488
- const bool leaf = INSN_ATTR(leaf);
3398
+ const bool MAYBE_UNUSED(leaf) = INSN_ATTR(leaf);
3489
3399
  VALUE recv = TOPN(1);
3490
3400
  VALUE obj = TOPN(0);
3491
3401
  VALUE val;
3492
3402
 
3493
3403
  /* ### Instruction preambles. ### */
3494
- if (! leaf) ADD_PC(INSN_ATTR(width));
3404
+ ADD_PC(INSN_ATTR(width));
3495
3405
  SETUP_CANARY(leaf);
3496
3406
  COLLECT_USAGE_INSN(INSN_ATTR(bin));
3497
3407
  COLLECT_USAGE_OPERAND(INSN_ATTR(bin), 0, cd);
3498
3408
 
3499
3409
  /* ### Here we do the instruction body. ### */
3500
3410
  # define NAME_OF_CURRENT_INSN opt_gt
3501
- # line 1248 "insns.def"
3411
+ # line 1235 "insns.def"
3502
3412
  {
3503
3413
  val = vm_opt_gt(recv, obj);
3504
3414
 
@@ -3506,7 +3416,7 @@ INSN_ENTRY(opt_gt)
3506
3416
  CALL_SIMPLE_METHOD();
3507
3417
  }
3508
3418
  }
3509
- # line 3510 "vm.inc"
3419
+ # line 3420 "vm.inc"
3510
3420
  # undef NAME_OF_CURRENT_INSN
3511
3421
 
3512
3422
  /* ### Instruction trailers. ### */
@@ -3516,7 +3426,6 @@ INSN_ENTRY(opt_gt)
3516
3426
  TOPN(0) = val;
3517
3427
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_NONE));
3518
3428
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_MOVED));
3519
- if (leaf) ADD_PC(INSN_ATTR(width));
3520
3429
  # undef INSN_ATTR
3521
3430
 
3522
3431
  /* ### Leave the instruction. ### */
@@ -3533,20 +3442,20 @@ INSN_ENTRY(opt_ge)
3533
3442
  /* ### Declare and assign variables. ### */
3534
3443
  CALL_DATA cd = (CALL_DATA)GET_OPERAND(1);
3535
3444
  # define INSN_ATTR(x) attr_ ## x ## _opt_ge(cd)
3536
- const bool leaf = INSN_ATTR(leaf);
3445
+ const bool MAYBE_UNUSED(leaf) = INSN_ATTR(leaf);
3537
3446
  VALUE recv = TOPN(1);
3538
3447
  VALUE obj = TOPN(0);
3539
3448
  VALUE val;
3540
3449
 
3541
3450
  /* ### Instruction preambles. ### */
3542
- if (! leaf) ADD_PC(INSN_ATTR(width));
3451
+ ADD_PC(INSN_ATTR(width));
3543
3452
  SETUP_CANARY(leaf);
3544
3453
  COLLECT_USAGE_INSN(INSN_ATTR(bin));
3545
3454
  COLLECT_USAGE_OPERAND(INSN_ATTR(bin), 0, cd);
3546
3455
 
3547
3456
  /* ### Here we do the instruction body. ### */
3548
3457
  # define NAME_OF_CURRENT_INSN opt_ge
3549
- # line 1262 "insns.def"
3458
+ # line 1249 "insns.def"
3550
3459
  {
3551
3460
  val = vm_opt_ge(recv, obj);
3552
3461
 
@@ -3554,7 +3463,7 @@ INSN_ENTRY(opt_ge)
3554
3463
  CALL_SIMPLE_METHOD();
3555
3464
  }
3556
3465
  }
3557
- # line 3558 "vm.inc"
3466
+ # line 3467 "vm.inc"
3558
3467
  # undef NAME_OF_CURRENT_INSN
3559
3468
 
3560
3469
  /* ### Instruction trailers. ### */
@@ -3564,7 +3473,6 @@ INSN_ENTRY(opt_ge)
3564
3473
  TOPN(0) = val;
3565
3474
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_NONE));
3566
3475
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_MOVED));
3567
- if (leaf) ADD_PC(INSN_ATTR(width));
3568
3476
  # undef INSN_ATTR
3569
3477
 
3570
3478
  /* ### Leave the instruction. ### */
@@ -3581,20 +3489,20 @@ INSN_ENTRY(opt_ltlt)
3581
3489
  /* ### Declare and assign variables. ### */
3582
3490
  CALL_DATA cd = (CALL_DATA)GET_OPERAND(1);
3583
3491
  # define INSN_ATTR(x) attr_ ## x ## _opt_ltlt(cd)
3584
- const bool leaf = INSN_ATTR(leaf);
3492
+ const bool MAYBE_UNUSED(leaf) = INSN_ATTR(leaf);
3585
3493
  VALUE recv = TOPN(1);
3586
3494
  VALUE obj = TOPN(0);
3587
3495
  VALUE val;
3588
3496
 
3589
3497
  /* ### Instruction preambles. ### */
3590
- if (! leaf) ADD_PC(INSN_ATTR(width));
3498
+ ADD_PC(INSN_ATTR(width));
3591
3499
  SETUP_CANARY(leaf);
3592
3500
  COLLECT_USAGE_INSN(INSN_ATTR(bin));
3593
3501
  COLLECT_USAGE_OPERAND(INSN_ATTR(bin), 0, cd);
3594
3502
 
3595
3503
  /* ### Here we do the instruction body. ### */
3596
3504
  # define NAME_OF_CURRENT_INSN opt_ltlt
3597
- # line 1280 "insns.def"
3505
+ # line 1267 "insns.def"
3598
3506
  {
3599
3507
  val = vm_opt_ltlt(recv, obj);
3600
3508
 
@@ -3602,7 +3510,7 @@ INSN_ENTRY(opt_ltlt)
3602
3510
  CALL_SIMPLE_METHOD();
3603
3511
  }
3604
3512
  }
3605
- # line 3606 "vm.inc"
3513
+ # line 3514 "vm.inc"
3606
3514
  # undef NAME_OF_CURRENT_INSN
3607
3515
 
3608
3516
  /* ### Instruction trailers. ### */
@@ -3612,7 +3520,6 @@ INSN_ENTRY(opt_ltlt)
3612
3520
  TOPN(0) = val;
3613
3521
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_NONE));
3614
3522
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_MOVED));
3615
- if (leaf) ADD_PC(INSN_ATTR(width));
3616
3523
  # undef INSN_ATTR
3617
3524
 
3618
3525
  /* ### Leave the instruction. ### */
@@ -3629,20 +3536,20 @@ INSN_ENTRY(opt_and)
3629
3536
  /* ### Declare and assign variables. ### */
3630
3537
  CALL_DATA cd = (CALL_DATA)GET_OPERAND(1);
3631
3538
  # define INSN_ATTR(x) attr_ ## x ## _opt_and(cd)
3632
- const bool leaf = INSN_ATTR(leaf);
3539
+ const bool MAYBE_UNUSED(leaf) = INSN_ATTR(leaf);
3633
3540
  VALUE recv = TOPN(1);
3634
3541
  VALUE obj = TOPN(0);
3635
3542
  VALUE val;
3636
3543
 
3637
3544
  /* ### Instruction preambles. ### */
3638
- if (! leaf) ADD_PC(INSN_ATTR(width));
3545
+ ADD_PC(INSN_ATTR(width));
3639
3546
  SETUP_CANARY(leaf);
3640
3547
  COLLECT_USAGE_INSN(INSN_ATTR(bin));
3641
3548
  COLLECT_USAGE_OPERAND(INSN_ATTR(bin), 0, cd);
3642
3549
 
3643
3550
  /* ### Here we do the instruction body. ### */
3644
3551
  # define NAME_OF_CURRENT_INSN opt_and
3645
- # line 1294 "insns.def"
3552
+ # line 1281 "insns.def"
3646
3553
  {
3647
3554
  val = vm_opt_and(recv, obj);
3648
3555
 
@@ -3650,7 +3557,7 @@ INSN_ENTRY(opt_and)
3650
3557
  CALL_SIMPLE_METHOD();
3651
3558
  }
3652
3559
  }
3653
- # line 3654 "vm.inc"
3560
+ # line 3561 "vm.inc"
3654
3561
  # undef NAME_OF_CURRENT_INSN
3655
3562
 
3656
3563
  /* ### Instruction trailers. ### */
@@ -3660,7 +3567,6 @@ INSN_ENTRY(opt_and)
3660
3567
  TOPN(0) = val;
3661
3568
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_NONE));
3662
3569
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_MOVED));
3663
- if (leaf) ADD_PC(INSN_ATTR(width));
3664
3570
  # undef INSN_ATTR
3665
3571
 
3666
3572
  /* ### Leave the instruction. ### */
@@ -3677,20 +3583,20 @@ INSN_ENTRY(opt_or)
3677
3583
  /* ### Declare and assign variables. ### */
3678
3584
  CALL_DATA cd = (CALL_DATA)GET_OPERAND(1);
3679
3585
  # define INSN_ATTR(x) attr_ ## x ## _opt_or(cd)
3680
- const bool leaf = INSN_ATTR(leaf);
3586
+ const bool MAYBE_UNUSED(leaf) = INSN_ATTR(leaf);
3681
3587
  VALUE recv = TOPN(1);
3682
3588
  VALUE obj = TOPN(0);
3683
3589
  VALUE val;
3684
3590
 
3685
3591
  /* ### Instruction preambles. ### */
3686
- if (! leaf) ADD_PC(INSN_ATTR(width));
3592
+ ADD_PC(INSN_ATTR(width));
3687
3593
  SETUP_CANARY(leaf);
3688
3594
  COLLECT_USAGE_INSN(INSN_ATTR(bin));
3689
3595
  COLLECT_USAGE_OPERAND(INSN_ATTR(bin), 0, cd);
3690
3596
 
3691
3597
  /* ### Here we do the instruction body. ### */
3692
3598
  # define NAME_OF_CURRENT_INSN opt_or
3693
- # line 1308 "insns.def"
3599
+ # line 1295 "insns.def"
3694
3600
  {
3695
3601
  val = vm_opt_or(recv, obj);
3696
3602
 
@@ -3698,7 +3604,7 @@ INSN_ENTRY(opt_or)
3698
3604
  CALL_SIMPLE_METHOD();
3699
3605
  }
3700
3606
  }
3701
- # line 3702 "vm.inc"
3607
+ # line 3608 "vm.inc"
3702
3608
  # undef NAME_OF_CURRENT_INSN
3703
3609
 
3704
3610
  /* ### Instruction trailers. ### */
@@ -3708,7 +3614,6 @@ INSN_ENTRY(opt_or)
3708
3614
  TOPN(0) = val;
3709
3615
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_NONE));
3710
3616
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_MOVED));
3711
- if (leaf) ADD_PC(INSN_ATTR(width));
3712
3617
  # undef INSN_ATTR
3713
3618
 
3714
3619
  /* ### Leave the instruction. ### */
@@ -3725,20 +3630,20 @@ INSN_ENTRY(opt_aref)
3725
3630
  /* ### Declare and assign variables. ### */
3726
3631
  CALL_DATA cd = (CALL_DATA)GET_OPERAND(1);
3727
3632
  # define INSN_ATTR(x) attr_ ## x ## _opt_aref(cd)
3728
- const bool leaf = INSN_ATTR(leaf);
3633
+ const bool MAYBE_UNUSED(leaf) = INSN_ATTR(leaf);
3729
3634
  VALUE recv = TOPN(1);
3730
3635
  VALUE obj = TOPN(0);
3731
3636
  VALUE val;
3732
3637
 
3733
3638
  /* ### Instruction preambles. ### */
3734
- if (! leaf) ADD_PC(INSN_ATTR(width));
3639
+ ADD_PC(INSN_ATTR(width));
3735
3640
  SETUP_CANARY(leaf);
3736
3641
  COLLECT_USAGE_INSN(INSN_ATTR(bin));
3737
3642
  COLLECT_USAGE_OPERAND(INSN_ATTR(bin), 0, cd);
3738
3643
 
3739
3644
  /* ### Here we do the instruction body. ### */
3740
3645
  # define NAME_OF_CURRENT_INSN opt_aref
3741
- # line 1327 "insns.def"
3646
+ # line 1314 "insns.def"
3742
3647
  {
3743
3648
  val = vm_opt_aref(recv, obj);
3744
3649
 
@@ -3746,7 +3651,7 @@ INSN_ENTRY(opt_aref)
3746
3651
  CALL_SIMPLE_METHOD();
3747
3652
  }
3748
3653
  }
3749
- # line 3750 "vm.inc"
3654
+ # line 3655 "vm.inc"
3750
3655
  # undef NAME_OF_CURRENT_INSN
3751
3656
 
3752
3657
  /* ### Instruction trailers. ### */
@@ -3756,7 +3661,6 @@ INSN_ENTRY(opt_aref)
3756
3661
  TOPN(0) = val;
3757
3662
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_NONE));
3758
3663
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_MOVED));
3759
- if (leaf) ADD_PC(INSN_ATTR(width));
3760
3664
  # undef INSN_ATTR
3761
3665
 
3762
3666
  /* ### Leave the instruction. ### */
@@ -3773,21 +3677,21 @@ INSN_ENTRY(opt_aset)
3773
3677
  /* ### Declare and assign variables. ### */
3774
3678
  CALL_DATA cd = (CALL_DATA)GET_OPERAND(1);
3775
3679
  # define INSN_ATTR(x) attr_ ## x ## _opt_aset(cd)
3776
- const bool leaf = INSN_ATTR(leaf);
3680
+ const bool MAYBE_UNUSED(leaf) = INSN_ATTR(leaf);
3777
3681
  VALUE recv = TOPN(2);
3778
3682
  VALUE obj = TOPN(1);
3779
3683
  VALUE set = TOPN(0);
3780
3684
  VALUE val;
3781
3685
 
3782
3686
  /* ### Instruction preambles. ### */
3783
- if (! leaf) ADD_PC(INSN_ATTR(width));
3687
+ ADD_PC(INSN_ATTR(width));
3784
3688
  SETUP_CANARY(leaf);
3785
3689
  COLLECT_USAGE_INSN(INSN_ATTR(bin));
3786
3690
  COLLECT_USAGE_OPERAND(INSN_ATTR(bin), 0, cd);
3787
3691
 
3788
3692
  /* ### Here we do the instruction body. ### */
3789
3693
  # define NAME_OF_CURRENT_INSN opt_aset
3790
- # line 1344 "insns.def"
3694
+ # line 1331 "insns.def"
3791
3695
  {
3792
3696
  val = vm_opt_aset(recv, obj, set);
3793
3697
 
@@ -3795,7 +3699,7 @@ INSN_ENTRY(opt_aset)
3795
3699
  CALL_SIMPLE_METHOD();
3796
3700
  }
3797
3701
  }
3798
- # line 3799 "vm.inc"
3702
+ # line 3703 "vm.inc"
3799
3703
  # undef NAME_OF_CURRENT_INSN
3800
3704
 
3801
3705
  /* ### Instruction trailers. ### */
@@ -3805,7 +3709,6 @@ INSN_ENTRY(opt_aset)
3805
3709
  TOPN(0) = val;
3806
3710
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_NONE));
3807
3711
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_MOVED));
3808
- if (leaf) ADD_PC(INSN_ATTR(width));
3809
3712
  # undef INSN_ATTR
3810
3713
 
3811
3714
  /* ### Leave the instruction. ### */
@@ -3823,12 +3726,12 @@ INSN_ENTRY(opt_aset_with)
3823
3726
  VALUE key = (VALUE)GET_OPERAND(1);
3824
3727
  CALL_DATA cd = (CALL_DATA)GET_OPERAND(2);
3825
3728
  # define INSN_ATTR(x) attr_ ## x ## _opt_aset_with(key, cd)
3826
- const bool leaf = INSN_ATTR(leaf);
3729
+ const bool MAYBE_UNUSED(leaf) = INSN_ATTR(leaf);
3827
3730
  VALUE recv = TOPN(1);
3828
3731
  VALUE val = TOPN(0);
3829
3732
 
3830
3733
  /* ### Instruction preambles. ### */
3831
- if (! leaf) ADD_PC(INSN_ATTR(width));
3734
+ ADD_PC(INSN_ATTR(width));
3832
3735
  SETUP_CANARY(leaf);
3833
3736
  COLLECT_USAGE_INSN(INSN_ATTR(bin));
3834
3737
  COLLECT_USAGE_OPERAND(INSN_ATTR(bin), 0, key);
@@ -3836,7 +3739,7 @@ INSN_ENTRY(opt_aset_with)
3836
3739
 
3837
3740
  /* ### Here we do the instruction body. ### */
3838
3741
  # define NAME_OF_CURRENT_INSN opt_aset_with
3839
- # line 1360 "insns.def"
3742
+ # line 1347 "insns.def"
3840
3743
  {
3841
3744
  VALUE tmp = vm_opt_aset_with(recv, key, val);
3842
3745
 
@@ -3849,7 +3752,7 @@ INSN_ENTRY(opt_aset_with)
3849
3752
  CALL_SIMPLE_METHOD();
3850
3753
  }
3851
3754
  }
3852
- # line 3853 "vm.inc"
3755
+ # line 3756 "vm.inc"
3853
3756
  # undef NAME_OF_CURRENT_INSN
3854
3757
 
3855
3758
  /* ### Instruction trailers. ### */
@@ -3859,7 +3762,6 @@ INSN_ENTRY(opt_aset_with)
3859
3762
  TOPN(0) = val;
3860
3763
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_NONE));
3861
3764
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_MOVED));
3862
- if (leaf) ADD_PC(INSN_ATTR(width));
3863
3765
  # undef INSN_ATTR
3864
3766
 
3865
3767
  /* ### Leave the instruction. ### */
@@ -3877,12 +3779,12 @@ INSN_ENTRY(opt_aref_with)
3877
3779
  VALUE key = (VALUE)GET_OPERAND(1);
3878
3780
  CALL_DATA cd = (CALL_DATA)GET_OPERAND(2);
3879
3781
  # define INSN_ATTR(x) attr_ ## x ## _opt_aref_with(key, cd)
3880
- const bool leaf = INSN_ATTR(leaf);
3782
+ const bool MAYBE_UNUSED(leaf) = INSN_ATTR(leaf);
3881
3783
  VALUE recv = TOPN(0);
3882
3784
  VALUE val;
3883
3785
 
3884
3786
  /* ### Instruction preambles. ### */
3885
- if (! leaf) ADD_PC(INSN_ATTR(width));
3787
+ ADD_PC(INSN_ATTR(width));
3886
3788
  SETUP_CANARY(leaf);
3887
3789
  COLLECT_USAGE_INSN(INSN_ATTR(bin));
3888
3790
  COLLECT_USAGE_OPERAND(INSN_ATTR(bin), 0, key);
@@ -3890,7 +3792,7 @@ INSN_ENTRY(opt_aref_with)
3890
3792
 
3891
3793
  /* ### Here we do the instruction body. ### */
3892
3794
  # define NAME_OF_CURRENT_INSN opt_aref_with
3893
- # line 1381 "insns.def"
3795
+ # line 1368 "insns.def"
3894
3796
  {
3895
3797
  val = vm_opt_aref_with(recv, key);
3896
3798
 
@@ -3899,7 +3801,7 @@ INSN_ENTRY(opt_aref_with)
3899
3801
  CALL_SIMPLE_METHOD();
3900
3802
  }
3901
3803
  }
3902
- # line 3903 "vm.inc"
3804
+ # line 3805 "vm.inc"
3903
3805
  # undef NAME_OF_CURRENT_INSN
3904
3806
 
3905
3807
  /* ### Instruction trailers. ### */
@@ -3909,7 +3811,6 @@ INSN_ENTRY(opt_aref_with)
3909
3811
  TOPN(0) = val;
3910
3812
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_NONE));
3911
3813
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_MOVED));
3912
- if (leaf) ADD_PC(INSN_ATTR(width));
3913
3814
  # undef INSN_ATTR
3914
3815
 
3915
3816
  /* ### Leave the instruction. ### */
@@ -3926,19 +3827,19 @@ INSN_ENTRY(opt_length)
3926
3827
  /* ### Declare and assign variables. ### */
3927
3828
  CALL_DATA cd = (CALL_DATA)GET_OPERAND(1);
3928
3829
  # define INSN_ATTR(x) attr_ ## x ## _opt_length(cd)
3929
- const bool leaf = INSN_ATTR(leaf);
3830
+ const bool MAYBE_UNUSED(leaf) = INSN_ATTR(leaf);
3930
3831
  VALUE recv = TOPN(0);
3931
3832
  VALUE val;
3932
3833
 
3933
3834
  /* ### Instruction preambles. ### */
3934
- if (! leaf) ADD_PC(INSN_ATTR(width));
3835
+ ADD_PC(INSN_ATTR(width));
3935
3836
  SETUP_CANARY(leaf);
3936
3837
  COLLECT_USAGE_INSN(INSN_ATTR(bin));
3937
3838
  COLLECT_USAGE_OPERAND(INSN_ATTR(bin), 0, cd);
3938
3839
 
3939
3840
  /* ### Here we do the instruction body. ### */
3940
3841
  # define NAME_OF_CURRENT_INSN opt_length
3941
- # line 1396 "insns.def"
3842
+ # line 1383 "insns.def"
3942
3843
  {
3943
3844
  val = vm_opt_length(recv, BOP_LENGTH);
3944
3845
 
@@ -3946,7 +3847,7 @@ INSN_ENTRY(opt_length)
3946
3847
  CALL_SIMPLE_METHOD();
3947
3848
  }
3948
3849
  }
3949
- # line 3950 "vm.inc"
3850
+ # line 3851 "vm.inc"
3950
3851
  # undef NAME_OF_CURRENT_INSN
3951
3852
 
3952
3853
  /* ### Instruction trailers. ### */
@@ -3956,7 +3857,6 @@ INSN_ENTRY(opt_length)
3956
3857
  TOPN(0) = val;
3957
3858
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_NONE));
3958
3859
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_MOVED));
3959
- if (leaf) ADD_PC(INSN_ATTR(width));
3960
3860
  # undef INSN_ATTR
3961
3861
 
3962
3862
  /* ### Leave the instruction. ### */
@@ -3973,19 +3873,19 @@ INSN_ENTRY(opt_size)
3973
3873
  /* ### Declare and assign variables. ### */
3974
3874
  CALL_DATA cd = (CALL_DATA)GET_OPERAND(1);
3975
3875
  # define INSN_ATTR(x) attr_ ## x ## _opt_size(cd)
3976
- const bool leaf = INSN_ATTR(leaf);
3876
+ const bool MAYBE_UNUSED(leaf) = INSN_ATTR(leaf);
3977
3877
  VALUE recv = TOPN(0);
3978
3878
  VALUE val;
3979
3879
 
3980
3880
  /* ### Instruction preambles. ### */
3981
- if (! leaf) ADD_PC(INSN_ATTR(width));
3881
+ ADD_PC(INSN_ATTR(width));
3982
3882
  SETUP_CANARY(leaf);
3983
3883
  COLLECT_USAGE_INSN(INSN_ATTR(bin));
3984
3884
  COLLECT_USAGE_OPERAND(INSN_ATTR(bin), 0, cd);
3985
3885
 
3986
3886
  /* ### Here we do the instruction body. ### */
3987
3887
  # define NAME_OF_CURRENT_INSN opt_size
3988
- # line 1410 "insns.def"
3888
+ # line 1397 "insns.def"
3989
3889
  {
3990
3890
  val = vm_opt_length(recv, BOP_SIZE);
3991
3891
 
@@ -3993,7 +3893,7 @@ INSN_ENTRY(opt_size)
3993
3893
  CALL_SIMPLE_METHOD();
3994
3894
  }
3995
3895
  }
3996
- # line 3997 "vm.inc"
3896
+ # line 3897 "vm.inc"
3997
3897
  # undef NAME_OF_CURRENT_INSN
3998
3898
 
3999
3899
  /* ### Instruction trailers. ### */
@@ -4003,7 +3903,6 @@ INSN_ENTRY(opt_size)
4003
3903
  TOPN(0) = val;
4004
3904
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_NONE));
4005
3905
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_MOVED));
4006
- if (leaf) ADD_PC(INSN_ATTR(width));
4007
3906
  # undef INSN_ATTR
4008
3907
 
4009
3908
  /* ### Leave the instruction. ### */
@@ -4020,19 +3919,19 @@ INSN_ENTRY(opt_empty_p)
4020
3919
  /* ### Declare and assign variables. ### */
4021
3920
  CALL_DATA cd = (CALL_DATA)GET_OPERAND(1);
4022
3921
  # define INSN_ATTR(x) attr_ ## x ## _opt_empty_p(cd)
4023
- const bool leaf = INSN_ATTR(leaf);
3922
+ const bool MAYBE_UNUSED(leaf) = INSN_ATTR(leaf);
4024
3923
  VALUE recv = TOPN(0);
4025
3924
  VALUE val;
4026
3925
 
4027
3926
  /* ### Instruction preambles. ### */
4028
- if (! leaf) ADD_PC(INSN_ATTR(width));
3927
+ ADD_PC(INSN_ATTR(width));
4029
3928
  SETUP_CANARY(leaf);
4030
3929
  COLLECT_USAGE_INSN(INSN_ATTR(bin));
4031
3930
  COLLECT_USAGE_OPERAND(INSN_ATTR(bin), 0, cd);
4032
3931
 
4033
3932
  /* ### Here we do the instruction body. ### */
4034
3933
  # define NAME_OF_CURRENT_INSN opt_empty_p
4035
- # line 1424 "insns.def"
3934
+ # line 1411 "insns.def"
4036
3935
  {
4037
3936
  val = vm_opt_empty_p(recv);
4038
3937
 
@@ -4040,7 +3939,7 @@ INSN_ENTRY(opt_empty_p)
4040
3939
  CALL_SIMPLE_METHOD();
4041
3940
  }
4042
3941
  }
4043
- # line 4044 "vm.inc"
3942
+ # line 3943 "vm.inc"
4044
3943
  # undef NAME_OF_CURRENT_INSN
4045
3944
 
4046
3945
  /* ### Instruction trailers. ### */
@@ -4050,7 +3949,6 @@ INSN_ENTRY(opt_empty_p)
4050
3949
  TOPN(0) = val;
4051
3950
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_NONE));
4052
3951
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_MOVED));
4053
- if (leaf) ADD_PC(INSN_ATTR(width));
4054
3952
  # undef INSN_ATTR
4055
3953
 
4056
3954
  /* ### Leave the instruction. ### */
@@ -4067,19 +3965,19 @@ INSN_ENTRY(opt_succ)
4067
3965
  /* ### Declare and assign variables. ### */
4068
3966
  CALL_DATA cd = (CALL_DATA)GET_OPERAND(1);
4069
3967
  # define INSN_ATTR(x) attr_ ## x ## _opt_succ(cd)
4070
- const bool leaf = INSN_ATTR(leaf);
3968
+ const bool MAYBE_UNUSED(leaf) = INSN_ATTR(leaf);
4071
3969
  VALUE recv = TOPN(0);
4072
3970
  VALUE val;
4073
3971
 
4074
3972
  /* ### Instruction preambles. ### */
4075
- if (! leaf) ADD_PC(INSN_ATTR(width));
3973
+ ADD_PC(INSN_ATTR(width));
4076
3974
  SETUP_CANARY(leaf);
4077
3975
  COLLECT_USAGE_INSN(INSN_ATTR(bin));
4078
3976
  COLLECT_USAGE_OPERAND(INSN_ATTR(bin), 0, cd);
4079
3977
 
4080
3978
  /* ### Here we do the instruction body. ### */
4081
3979
  # define NAME_OF_CURRENT_INSN opt_succ
4082
- # line 1438 "insns.def"
3980
+ # line 1425 "insns.def"
4083
3981
  {
4084
3982
  val = vm_opt_succ(recv);
4085
3983
 
@@ -4087,7 +3985,7 @@ INSN_ENTRY(opt_succ)
4087
3985
  CALL_SIMPLE_METHOD();
4088
3986
  }
4089
3987
  }
4090
- # line 4091 "vm.inc"
3988
+ # line 3989 "vm.inc"
4091
3989
  # undef NAME_OF_CURRENT_INSN
4092
3990
 
4093
3991
  /* ### Instruction trailers. ### */
@@ -4097,7 +3995,6 @@ INSN_ENTRY(opt_succ)
4097
3995
  TOPN(0) = val;
4098
3996
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_NONE));
4099
3997
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_MOVED));
4100
- if (leaf) ADD_PC(INSN_ATTR(width));
4101
3998
  # undef INSN_ATTR
4102
3999
 
4103
4000
  /* ### Leave the instruction. ### */
@@ -4114,19 +4011,19 @@ INSN_ENTRY(opt_not)
4114
4011
  /* ### Declare and assign variables. ### */
4115
4012
  CALL_DATA cd = (CALL_DATA)GET_OPERAND(1);
4116
4013
  # define INSN_ATTR(x) attr_ ## x ## _opt_not(cd)
4117
- const bool leaf = INSN_ATTR(leaf);
4014
+ const bool MAYBE_UNUSED(leaf) = INSN_ATTR(leaf);
4118
4015
  VALUE recv = TOPN(0);
4119
4016
  VALUE val;
4120
4017
 
4121
4018
  /* ### Instruction preambles. ### */
4122
- if (! leaf) ADD_PC(INSN_ATTR(width));
4019
+ ADD_PC(INSN_ATTR(width));
4123
4020
  SETUP_CANARY(leaf);
4124
4021
  COLLECT_USAGE_INSN(INSN_ATTR(bin));
4125
4022
  COLLECT_USAGE_OPERAND(INSN_ATTR(bin), 0, cd);
4126
4023
 
4127
4024
  /* ### Here we do the instruction body. ### */
4128
4025
  # define NAME_OF_CURRENT_INSN opt_not
4129
- # line 1452 "insns.def"
4026
+ # line 1439 "insns.def"
4130
4027
  {
4131
4028
  val = vm_opt_not(GET_ISEQ(), cd, recv);
4132
4029
 
@@ -4134,7 +4031,7 @@ INSN_ENTRY(opt_not)
4134
4031
  CALL_SIMPLE_METHOD();
4135
4032
  }
4136
4033
  }
4137
- # line 4138 "vm.inc"
4034
+ # line 4035 "vm.inc"
4138
4035
  # undef NAME_OF_CURRENT_INSN
4139
4036
 
4140
4037
  /* ### Instruction trailers. ### */
@@ -4144,7 +4041,6 @@ INSN_ENTRY(opt_not)
4144
4041
  TOPN(0) = val;
4145
4042
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_NONE));
4146
4043
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_MOVED));
4147
- if (leaf) ADD_PC(INSN_ATTR(width));
4148
4044
  # undef INSN_ATTR
4149
4045
 
4150
4046
  /* ### Leave the instruction. ### */
@@ -4161,20 +4057,20 @@ INSN_ENTRY(opt_regexpmatch2)
4161
4057
  /* ### Declare and assign variables. ### */
4162
4058
  CALL_DATA cd = (CALL_DATA)GET_OPERAND(1);
4163
4059
  # define INSN_ATTR(x) attr_ ## x ## _opt_regexpmatch2(cd)
4164
- const bool leaf = INSN_ATTR(leaf);
4060
+ const bool MAYBE_UNUSED(leaf) = INSN_ATTR(leaf);
4165
4061
  VALUE obj2 = TOPN(1);
4166
4062
  VALUE obj1 = TOPN(0);
4167
4063
  VALUE val;
4168
4064
 
4169
4065
  /* ### Instruction preambles. ### */
4170
- if (! leaf) ADD_PC(INSN_ATTR(width));
4066
+ ADD_PC(INSN_ATTR(width));
4171
4067
  SETUP_CANARY(leaf);
4172
4068
  COLLECT_USAGE_INSN(INSN_ATTR(bin));
4173
4069
  COLLECT_USAGE_OPERAND(INSN_ATTR(bin), 0, cd);
4174
4070
 
4175
4071
  /* ### Here we do the instruction body. ### */
4176
4072
  # define NAME_OF_CURRENT_INSN opt_regexpmatch2
4177
- # line 1467 "insns.def"
4073
+ # line 1454 "insns.def"
4178
4074
  {
4179
4075
  val = vm_opt_regexpmatch2(obj2, obj1);
4180
4076
 
@@ -4182,7 +4078,7 @@ INSN_ENTRY(opt_regexpmatch2)
4182
4078
  CALL_SIMPLE_METHOD();
4183
4079
  }
4184
4080
  }
4185
- # line 4186 "vm.inc"
4081
+ # line 4082 "vm.inc"
4186
4082
  # undef NAME_OF_CURRENT_INSN
4187
4083
 
4188
4084
  /* ### Instruction trailers. ### */
@@ -4192,7 +4088,6 @@ INSN_ENTRY(opt_regexpmatch2)
4192
4088
  TOPN(0) = val;
4193
4089
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_NONE));
4194
4090
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_MOVED));
4195
- if (leaf) ADD_PC(INSN_ATTR(width));
4196
4091
  # undef INSN_ATTR
4197
4092
 
4198
4093
  /* ### Leave the instruction. ### */
@@ -4209,22 +4104,22 @@ INSN_ENTRY(invokebuiltin)
4209
4104
  /* ### Declare and assign variables. ### */
4210
4105
  RB_BUILTIN bf = (RB_BUILTIN)GET_OPERAND(1);
4211
4106
  # define INSN_ATTR(x) attr_ ## x ## _invokebuiltin(bf)
4212
- const bool leaf = INSN_ATTR(leaf);
4107
+ const bool MAYBE_UNUSED(leaf) = INSN_ATTR(leaf);
4213
4108
  VALUE val;
4214
4109
 
4215
4110
  /* ### Instruction preambles. ### */
4216
- if (! leaf) ADD_PC(INSN_ATTR(width));
4111
+ ADD_PC(INSN_ATTR(width));
4217
4112
  SETUP_CANARY(leaf);
4218
4113
  COLLECT_USAGE_INSN(INSN_ATTR(bin));
4219
4114
  COLLECT_USAGE_OPERAND(INSN_ATTR(bin), 0, bf);
4220
4115
 
4221
4116
  /* ### Here we do the instruction body. ### */
4222
4117
  # define NAME_OF_CURRENT_INSN invokebuiltin
4223
- # line 1483 "insns.def"
4118
+ # line 1470 "insns.def"
4224
4119
  {
4225
4120
  val = vm_invoke_builtin(ec, reg_cfp, bf, STACK_ADDR_FROM_TOP(bf->argc));
4226
4121
  }
4227
- # line 4228 "vm.inc"
4122
+ # line 4123 "vm.inc"
4228
4123
  # undef NAME_OF_CURRENT_INSN
4229
4124
 
4230
4125
  /* ### Instruction trailers. ### */
@@ -4234,7 +4129,6 @@ INSN_ENTRY(invokebuiltin)
4234
4129
  TOPN(0) = val;
4235
4130
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_NONE));
4236
4131
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_MOVED));
4237
- if (leaf) ADD_PC(INSN_ATTR(width));
4238
4132
  # undef INSN_ATTR
4239
4133
 
4240
4134
  /* ### Leave the instruction. ### */
@@ -4252,11 +4146,11 @@ INSN_ENTRY(opt_invokebuiltin_delegate)
4252
4146
  RB_BUILTIN bf = (RB_BUILTIN)GET_OPERAND(1);
4253
4147
  rb_num_t index = (rb_num_t)GET_OPERAND(2);
4254
4148
  # define INSN_ATTR(x) attr_ ## x ## _opt_invokebuiltin_delegate(bf, index)
4255
- const bool leaf = INSN_ATTR(leaf);
4149
+ const bool MAYBE_UNUSED(leaf) = INSN_ATTR(leaf);
4256
4150
  VALUE val;
4257
4151
 
4258
4152
  /* ### Instruction preambles. ### */
4259
- if (! leaf) ADD_PC(INSN_ATTR(width));
4153
+ ADD_PC(INSN_ATTR(width));
4260
4154
  SETUP_CANARY(leaf);
4261
4155
  COLLECT_USAGE_INSN(INSN_ATTR(bin));
4262
4156
  COLLECT_USAGE_OPERAND(INSN_ATTR(bin), 0, bf);
@@ -4264,11 +4158,11 @@ INSN_ENTRY(opt_invokebuiltin_delegate)
4264
4158
 
4265
4159
  /* ### Here we do the instruction body. ### */
4266
4160
  # define NAME_OF_CURRENT_INSN opt_invokebuiltin_delegate
4267
- # line 1494 "insns.def"
4161
+ # line 1481 "insns.def"
4268
4162
  {
4269
4163
  val = vm_invoke_builtin_delegate(ec, reg_cfp, bf, (unsigned int)index);
4270
4164
  }
4271
- # line 4272 "vm.inc"
4165
+ # line 4166 "vm.inc"
4272
4166
  # undef NAME_OF_CURRENT_INSN
4273
4167
 
4274
4168
  /* ### Instruction trailers. ### */
@@ -4278,7 +4172,6 @@ INSN_ENTRY(opt_invokebuiltin_delegate)
4278
4172
  TOPN(0) = val;
4279
4173
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_NONE));
4280
4174
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_MOVED));
4281
- if (leaf) ADD_PC(INSN_ATTR(width));
4282
4175
  # undef INSN_ATTR
4283
4176
 
4284
4177
  /* ### Leave the instruction. ### */
@@ -4296,11 +4189,11 @@ INSN_ENTRY(opt_invokebuiltin_delegate_leave)
4296
4189
  RB_BUILTIN bf = (RB_BUILTIN)GET_OPERAND(1);
4297
4190
  rb_num_t index = (rb_num_t)GET_OPERAND(2);
4298
4191
  # define INSN_ATTR(x) attr_ ## x ## _opt_invokebuiltin_delegate_leave(bf, index)
4299
- const bool leaf = INSN_ATTR(leaf);
4192
+ const bool MAYBE_UNUSED(leaf) = INSN_ATTR(leaf);
4300
4193
  VALUE val;
4301
4194
 
4302
4195
  /* ### Instruction preambles. ### */
4303
- if (! leaf) ADD_PC(INSN_ATTR(width));
4196
+ ADD_PC(INSN_ATTR(width));
4304
4197
  SETUP_CANARY(leaf);
4305
4198
  COLLECT_USAGE_INSN(INSN_ATTR(bin));
4306
4199
  COLLECT_USAGE_OPERAND(INSN_ATTR(bin), 0, bf);
@@ -4308,7 +4201,7 @@ INSN_ENTRY(opt_invokebuiltin_delegate_leave)
4308
4201
 
4309
4202
  /* ### Here we do the instruction body. ### */
4310
4203
  # define NAME_OF_CURRENT_INSN opt_invokebuiltin_delegate_leave
4311
- # line 1505 "insns.def"
4204
+ # line 1492 "insns.def"
4312
4205
  {
4313
4206
  val = vm_invoke_builtin_delegate(ec, reg_cfp, bf, (unsigned int)index);
4314
4207
 
@@ -4326,7 +4219,7 @@ INSN_ENTRY(opt_invokebuiltin_delegate_leave)
4326
4219
  RESTORE_REGS();
4327
4220
  }
4328
4221
  }
4329
- # line 4330 "vm.inc"
4222
+ # line 4223 "vm.inc"
4330
4223
  # undef NAME_OF_CURRENT_INSN
4331
4224
 
4332
4225
  /* ### Instruction trailers. ### */
@@ -4336,7 +4229,6 @@ INSN_ENTRY(opt_invokebuiltin_delegate_leave)
4336
4229
  TOPN(0) = val;
4337
4230
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_NONE));
4338
4231
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_MOVED));
4339
- if (leaf) ADD_PC(INSN_ATTR(width));
4340
4232
  # undef INSN_ATTR
4341
4233
 
4342
4234
  /* ### Leave the instruction. ### */
@@ -4353,14 +4245,14 @@ INSN_ENTRY(getlocal_WC_0)
4353
4245
  /* ### Declare and assign variables. ### */
4354
4246
  #line 10 "defs/opt_operand.def"
4355
4247
  const rb_num_t level = 0;
4356
- #line 4357 "vm.inc"
4248
+ #line 4249 "vm.inc"
4357
4249
  lindex_t idx = (lindex_t)GET_OPERAND(1);
4358
4250
  # define INSN_ATTR(x) attr_ ## x ## _getlocal_WC_0(idx)
4359
- const bool leaf = INSN_ATTR(leaf);
4251
+ const bool MAYBE_UNUSED(leaf) = INSN_ATTR(leaf);
4360
4252
  VALUE val;
4361
4253
 
4362
4254
  /* ### Instruction preambles. ### */
4363
- if (! leaf) ADD_PC(INSN_ATTR(width));
4255
+ ADD_PC(INSN_ATTR(width));
4364
4256
  SETUP_CANARY(leaf);
4365
4257
  COLLECT_USAGE_INSN(INSN_ATTR(bin));
4366
4258
  COLLECT_USAGE_OPERAND(INSN_ATTR(bin), 0, idx);
@@ -4373,7 +4265,7 @@ INSN_ENTRY(getlocal_WC_0)
4373
4265
  RB_DEBUG_COUNTER_INC(lvar_get);
4374
4266
  (void)RB_DEBUG_COUNTER_INC_IF(lvar_get_dynamic, level > 0);
4375
4267
  }
4376
- # line 4377 "vm.inc"
4268
+ # line 4269 "vm.inc"
4377
4269
  # undef NAME_OF_CURRENT_INSN
4378
4270
 
4379
4271
  /* ### Instruction trailers. ### */
@@ -4383,7 +4275,6 @@ INSN_ENTRY(getlocal_WC_0)
4383
4275
  TOPN(0) = val;
4384
4276
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_NONE));
4385
4277
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_MOVED));
4386
- if (leaf) ADD_PC(INSN_ATTR(width));
4387
4278
  # undef INSN_ATTR
4388
4279
 
4389
4280
  /* ### Leave the instruction. ### */
@@ -4400,14 +4291,14 @@ INSN_ENTRY(getlocal_WC_1)
4400
4291
  /* ### Declare and assign variables. ### */
4401
4292
  #line 11 "defs/opt_operand.def"
4402
4293
  const rb_num_t level = 1;
4403
- #line 4404 "vm.inc"
4294
+ #line 4295 "vm.inc"
4404
4295
  lindex_t idx = (lindex_t)GET_OPERAND(1);
4405
4296
  # define INSN_ATTR(x) attr_ ## x ## _getlocal_WC_1(idx)
4406
- const bool leaf = INSN_ATTR(leaf);
4297
+ const bool MAYBE_UNUSED(leaf) = INSN_ATTR(leaf);
4407
4298
  VALUE val;
4408
4299
 
4409
4300
  /* ### Instruction preambles. ### */
4410
- if (! leaf) ADD_PC(INSN_ATTR(width));
4301
+ ADD_PC(INSN_ATTR(width));
4411
4302
  SETUP_CANARY(leaf);
4412
4303
  COLLECT_USAGE_INSN(INSN_ATTR(bin));
4413
4304
  COLLECT_USAGE_OPERAND(INSN_ATTR(bin), 0, idx);
@@ -4420,7 +4311,7 @@ INSN_ENTRY(getlocal_WC_1)
4420
4311
  RB_DEBUG_COUNTER_INC(lvar_get);
4421
4312
  (void)RB_DEBUG_COUNTER_INC_IF(lvar_get_dynamic, level > 0);
4422
4313
  }
4423
- # line 4424 "vm.inc"
4314
+ # line 4315 "vm.inc"
4424
4315
  # undef NAME_OF_CURRENT_INSN
4425
4316
 
4426
4317
  /* ### Instruction trailers. ### */
@@ -4430,7 +4321,6 @@ INSN_ENTRY(getlocal_WC_1)
4430
4321
  TOPN(0) = val;
4431
4322
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_NONE));
4432
4323
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_MOVED));
4433
- if (leaf) ADD_PC(INSN_ATTR(width));
4434
4324
  # undef INSN_ATTR
4435
4325
 
4436
4326
  /* ### Leave the instruction. ### */
@@ -4447,14 +4337,14 @@ INSN_ENTRY(setlocal_WC_0)
4447
4337
  /* ### Declare and assign variables. ### */
4448
4338
  #line 12 "defs/opt_operand.def"
4449
4339
  const rb_num_t level = 0;
4450
- #line 4451 "vm.inc"
4340
+ #line 4341 "vm.inc"
4451
4341
  lindex_t idx = (lindex_t)GET_OPERAND(1);
4452
4342
  # define INSN_ATTR(x) attr_ ## x ## _setlocal_WC_0(idx)
4453
- const bool leaf = INSN_ATTR(leaf);
4343
+ const bool MAYBE_UNUSED(leaf) = INSN_ATTR(leaf);
4454
4344
  VALUE val = TOPN(0);
4455
4345
 
4456
4346
  /* ### Instruction preambles. ### */
4457
- if (! leaf) ADD_PC(INSN_ATTR(width));
4347
+ ADD_PC(INSN_ATTR(width));
4458
4348
  SETUP_CANARY(leaf);
4459
4349
  COLLECT_USAGE_INSN(INSN_ATTR(bin));
4460
4350
  COLLECT_USAGE_OPERAND(INSN_ATTR(bin), 0, idx);
@@ -4467,14 +4357,13 @@ INSN_ENTRY(setlocal_WC_0)
4467
4357
  RB_DEBUG_COUNTER_INC(lvar_set);
4468
4358
  (void)RB_DEBUG_COUNTER_INC_IF(lvar_set_dynamic, level > 0);
4469
4359
  }
4470
- # line 4471 "vm.inc"
4360
+ # line 4361 "vm.inc"
4471
4361
  # undef NAME_OF_CURRENT_INSN
4472
4362
 
4473
4363
  /* ### Instruction trailers. ### */
4474
4364
  CHECK_VM_STACK_OVERFLOW_FOR_INSN(VM_REG_CFP, INSN_ATTR(retn));
4475
4365
  CHECK_CANARY(leaf, INSN_ATTR(bin));
4476
4366
  INC_SP(INSN_ATTR(sp_inc));
4477
- if (leaf) ADD_PC(INSN_ATTR(width));
4478
4367
  # undef INSN_ATTR
4479
4368
 
4480
4369
  /* ### Leave the instruction. ### */
@@ -4491,14 +4380,14 @@ INSN_ENTRY(setlocal_WC_1)
4491
4380
  /* ### Declare and assign variables. ### */
4492
4381
  #line 13 "defs/opt_operand.def"
4493
4382
  const rb_num_t level = 1;
4494
- #line 4495 "vm.inc"
4383
+ #line 4384 "vm.inc"
4495
4384
  lindex_t idx = (lindex_t)GET_OPERAND(1);
4496
4385
  # define INSN_ATTR(x) attr_ ## x ## _setlocal_WC_1(idx)
4497
- const bool leaf = INSN_ATTR(leaf);
4386
+ const bool MAYBE_UNUSED(leaf) = INSN_ATTR(leaf);
4498
4387
  VALUE val = TOPN(0);
4499
4388
 
4500
4389
  /* ### Instruction preambles. ### */
4501
- if (! leaf) ADD_PC(INSN_ATTR(width));
4390
+ ADD_PC(INSN_ATTR(width));
4502
4391
  SETUP_CANARY(leaf);
4503
4392
  COLLECT_USAGE_INSN(INSN_ATTR(bin));
4504
4393
  COLLECT_USAGE_OPERAND(INSN_ATTR(bin), 0, idx);
@@ -4511,14 +4400,13 @@ INSN_ENTRY(setlocal_WC_1)
4511
4400
  RB_DEBUG_COUNTER_INC(lvar_set);
4512
4401
  (void)RB_DEBUG_COUNTER_INC_IF(lvar_set_dynamic, level > 0);
4513
4402
  }
4514
- # line 4515 "vm.inc"
4403
+ # line 4404 "vm.inc"
4515
4404
  # undef NAME_OF_CURRENT_INSN
4516
4405
 
4517
4406
  /* ### Instruction trailers. ### */
4518
4407
  CHECK_VM_STACK_OVERFLOW_FOR_INSN(VM_REG_CFP, INSN_ATTR(retn));
4519
4408
  CHECK_CANARY(leaf, INSN_ATTR(bin));
4520
4409
  INC_SP(INSN_ATTR(sp_inc));
4521
- if (leaf) ADD_PC(INSN_ATTR(width));
4522
4410
  # undef INSN_ATTR
4523
4411
 
4524
4412
  /* ### Leave the instruction. ### */
@@ -4535,12 +4423,12 @@ INSN_ENTRY(putobject_INT2FIX_0_)
4535
4423
  /* ### Declare and assign variables. ### */
4536
4424
  #line 15 "defs/opt_operand.def"
4537
4425
  const VALUE val = INT2FIX(0);
4538
- #line 4539 "vm.inc"
4426
+ #line 4427 "vm.inc"
4539
4427
  # define INSN_ATTR(x) attr_ ## x ## _putobject_INT2FIX_0_()
4540
- const bool leaf = INSN_ATTR(leaf);
4428
+ const bool MAYBE_UNUSED(leaf) = INSN_ATTR(leaf);
4541
4429
 
4542
4430
  /* ### Instruction preambles. ### */
4543
- if (! leaf) ADD_PC(INSN_ATTR(width));
4431
+ ADD_PC(INSN_ATTR(width));
4544
4432
  COLLECT_USAGE_INSN(INSN_ATTR(bin));
4545
4433
 
4546
4434
  /* ### Instruction trailers. ### */
@@ -4549,7 +4437,6 @@ INSN_ENTRY(putobject_INT2FIX_0_)
4549
4437
  TOPN(0) = val;
4550
4438
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_NONE));
4551
4439
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_MOVED));
4552
- if (leaf) ADD_PC(INSN_ATTR(width));
4553
4440
  # undef INSN_ATTR
4554
4441
 
4555
4442
  /* ### Leave the instruction. ### */
@@ -4566,12 +4453,12 @@ INSN_ENTRY(putobject_INT2FIX_1_)
4566
4453
  /* ### Declare and assign variables. ### */
4567
4454
  #line 16 "defs/opt_operand.def"
4568
4455
  const VALUE val = INT2FIX(1);
4569
- #line 4570 "vm.inc"
4456
+ #line 4457 "vm.inc"
4570
4457
  # define INSN_ATTR(x) attr_ ## x ## _putobject_INT2FIX_1_()
4571
- const bool leaf = INSN_ATTR(leaf);
4458
+ const bool MAYBE_UNUSED(leaf) = INSN_ATTR(leaf);
4572
4459
 
4573
4460
  /* ### Instruction preambles. ### */
4574
- if (! leaf) ADD_PC(INSN_ATTR(width));
4461
+ ADD_PC(INSN_ATTR(width));
4575
4462
  COLLECT_USAGE_INSN(INSN_ATTR(bin));
4576
4463
 
4577
4464
  /* ### Instruction trailers. ### */
@@ -4580,7 +4467,6 @@ INSN_ENTRY(putobject_INT2FIX_1_)
4580
4467
  TOPN(0) = val;
4581
4468
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_NONE));
4582
4469
  VM_ASSERT(!RB_TYPE_P(TOPN(0), T_MOVED));
4583
- if (leaf) ADD_PC(INSN_ATTR(width));
4584
4470
  # undef INSN_ATTR
4585
4471
 
4586
4472
  /* ### Leave the instruction. ### */