debase-ruby_core_source 3.2.1 → 3.2.3

Sign up to get free protection for your applications and to get access to all the features.
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. ### */