debase-ruby_core_source 0.9.1 → 0.9.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (52) hide show
  1. checksums.yaml +4 -4
  2. data/CHANGELOG.md +4 -0
  3. data/lib/debase/ruby_core_source.rb +1 -0
  4. data/lib/debase/ruby_core_source/ruby-2.4.0-preview2/addr2line.h +21 -0
  5. data/lib/debase/ruby_core_source/ruby-2.4.0-preview2/ccan/build_assert/build_assert.h +40 -0
  6. data/lib/debase/ruby_core_source/ruby-2.4.0-preview2/ccan/check_type/check_type.h +63 -0
  7. data/lib/debase/ruby_core_source/ruby-2.4.0-preview2/ccan/container_of/container_of.h +142 -0
  8. data/lib/debase/ruby_core_source/ruby-2.4.0-preview2/ccan/list/list.h +773 -0
  9. data/lib/debase/ruby_core_source/ruby-2.4.0-preview2/ccan/str/str.h +16 -0
  10. data/lib/debase/ruby_core_source/ruby-2.4.0-preview2/constant.h +50 -0
  11. data/lib/debase/ruby_core_source/ruby-2.4.0-preview2/dln.h +51 -0
  12. data/lib/debase/ruby_core_source/ruby-2.4.0-preview2/encindex.h +67 -0
  13. data/lib/debase/ruby_core_source/ruby-2.4.0-preview2/eval_intern.h +315 -0
  14. data/lib/debase/ruby_core_source/ruby-2.4.0-preview2/gc.h +114 -0
  15. data/lib/debase/ruby_core_source/ruby-2.4.0-preview2/id.h +220 -0
  16. data/lib/debase/ruby_core_source/ruby-2.4.0-preview2/id_table.h +31 -0
  17. data/lib/debase/ruby_core_source/ruby-2.4.0-preview2/insns.inc +112 -0
  18. data/lib/debase/ruby_core_source/ruby-2.4.0-preview2/insns_info.inc +796 -0
  19. data/lib/debase/ruby_core_source/ruby-2.4.0-preview2/internal.h +1700 -0
  20. data/lib/debase/ruby_core_source/ruby-2.4.0-preview2/iseq.h +252 -0
  21. data/lib/debase/ruby_core_source/ruby-2.4.0-preview2/known_errors.inc +746 -0
  22. data/lib/debase/ruby_core_source/ruby-2.4.0-preview2/method.h +213 -0
  23. data/lib/debase/ruby_core_source/ruby-2.4.0-preview2/node.h +520 -0
  24. data/lib/debase/ruby_core_source/ruby-2.4.0-preview2/node_name.inc +208 -0
  25. data/lib/debase/ruby_core_source/ruby-2.4.0-preview2/opt_sc.inc +774 -0
  26. data/lib/debase/ruby_core_source/ruby-2.4.0-preview2/optinsn.inc +83 -0
  27. data/lib/debase/ruby_core_source/ruby-2.4.0-preview2/optunifs.inc +129 -0
  28. data/lib/debase/ruby_core_source/ruby-2.4.0-preview2/parse.h +204 -0
  29. data/lib/debase/ruby_core_source/ruby-2.4.0-preview2/probes_helper.h +43 -0
  30. data/lib/debase/ruby_core_source/ruby-2.4.0-preview2/regenc.h +237 -0
  31. data/lib/debase/ruby_core_source/ruby-2.4.0-preview2/regint.h +995 -0
  32. data/lib/debase/ruby_core_source/ruby-2.4.0-preview2/regparse.h +367 -0
  33. data/lib/debase/ruby_core_source/ruby-2.4.0-preview2/revision.h +1 -0
  34. data/lib/debase/ruby_core_source/ruby-2.4.0-preview2/ruby_assert.h +54 -0
  35. data/lib/debase/ruby_core_source/ruby-2.4.0-preview2/ruby_atomic.h +233 -0
  36. data/lib/debase/ruby_core_source/ruby-2.4.0-preview2/siphash.h +48 -0
  37. data/lib/debase/ruby_core_source/ruby-2.4.0-preview2/symbol.h +108 -0
  38. data/lib/debase/ruby_core_source/ruby-2.4.0-preview2/thread_pthread.h +54 -0
  39. data/lib/debase/ruby_core_source/ruby-2.4.0-preview2/thread_win32.h +36 -0
  40. data/lib/debase/ruby_core_source/ruby-2.4.0-preview2/timev.h +42 -0
  41. data/lib/debase/ruby_core_source/ruby-2.4.0-preview2/transcode_data.h +139 -0
  42. data/lib/debase/ruby_core_source/ruby-2.4.0-preview2/version.h +73 -0
  43. data/lib/debase/ruby_core_source/ruby-2.4.0-preview2/vm.inc +3417 -0
  44. data/lib/debase/ruby_core_source/ruby-2.4.0-preview2/vm_call_iseq_optimized.inc +212 -0
  45. data/lib/debase/ruby_core_source/ruby-2.4.0-preview2/vm_core.h +1642 -0
  46. data/lib/debase/ruby_core_source/ruby-2.4.0-preview2/vm_debug.h +37 -0
  47. data/lib/debase/ruby_core_source/ruby-2.4.0-preview2/vm_exec.h +182 -0
  48. data/lib/debase/ruby_core_source/ruby-2.4.0-preview2/vm_insnhelper.h +227 -0
  49. data/lib/debase/ruby_core_source/ruby-2.4.0-preview2/vm_opts.h +57 -0
  50. data/lib/debase/ruby_core_source/ruby-2.4.0-preview2/vmtc.inc +110 -0
  51. data/lib/debase/ruby_core_source/version.rb +1 -1
  52. metadata +49 -2
data/lib/debase/ruby_core_source/ruby-2.4.0-preview2/vm.inc ADDED
@@ -0,0 +1,3417 @@
1
+ /* -*-c-*- *********************************************************/
2
+ /*******************************************************************/
3
+ /*******************************************************************/
4
+ /**
5
+ This file is VM main loop.
6
+
7
+ ----
8
+ This file is auto generated by insns2vm.rb
9
+ DO NOT TOUCH!
10
+
11
+ If you want to fix something, you must edit 'insns.def'
12
+ */
13
+
14
+
15
+ INSN_ENTRY(nop){
16
+ {
17
+
18
+
19
+ DEBUG_ENTER_INSN("nop");
20
+ ADD_PC(1+0);
21
+ PREFETCH(GET_PC());
22
+ #define CURRENT_INSN_nop 1
23
+ #define INSN_IS_SC() 0
24
+ #define INSN_LABEL(lab) LABEL_nop_##lab
25
+ #define LABEL_IS_SC(lab) LABEL_##lab##_##t
26
+ COLLECT_USAGE_INSN(BIN(nop));
27
+ {
28
+ #line 40 "insns.def"
29
+ /* none */
30
+
31
+ #line 32 "vm.inc"
32
+ #undef CURRENT_INSN_nop
33
+ #undef INSN_IS_SC
34
+ #undef INSN_LABEL
35
+ #undef LABEL_IS_SC
36
+ END_INSN(nop);}}}
37
+ INSN_ENTRY(getlocal){
38
+ {
39
+ VALUE val;
40
+ rb_num_t level = (rb_num_t)GET_OPERAND(2);
41
+ lindex_t idx = (lindex_t)GET_OPERAND(1);
42
+
43
+ DEBUG_ENTER_INSN("getlocal");
44
+ ADD_PC(1+2);
45
+ PREFETCH(GET_PC());
46
+ #define CURRENT_INSN_getlocal 1
47
+ #define INSN_IS_SC() 0
48
+ #define INSN_LABEL(lab) LABEL_getlocal_##lab
49
+ #define LABEL_IS_SC(lab) LABEL_##lab##_##t
50
+ COLLECT_USAGE_INSN(BIN(getlocal));
51
+ COLLECT_USAGE_OPERAND(BIN(getlocal), 0, idx);
52
+ COLLECT_USAGE_OPERAND(BIN(getlocal), 1, level);
53
+ {
54
+ #line 60 "insns.def"
55
+ int i, lev = (int)level;
56
+ const VALUE *ep = GET_EP();
57
+
58
+ /* optimized insns generated for level == (0|1) in defs/opt_operand.def */
59
+ for (i = 0; i < lev; i++) {
60
+ ep = GET_PREV_EP(ep);
61
+ }
62
+ val = *(ep - idx);
63
+
64
+ #line 65 "vm.inc"
65
+ CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1);
66
+ PUSH(val);
67
+ #undef CURRENT_INSN_getlocal
68
+ #undef INSN_IS_SC
69
+ #undef INSN_LABEL
70
+ #undef LABEL_IS_SC
71
+ END_INSN(getlocal);}}}
72
+ INSN_ENTRY(setlocal){
73
+ {
74
+ rb_num_t level = (rb_num_t)GET_OPERAND(2);
75
+ lindex_t idx = (lindex_t)GET_OPERAND(1);
76
+ VALUE val = TOPN(0);
77
+ DEBUG_ENTER_INSN("setlocal");
78
+ ADD_PC(1+2);
79
+ PREFETCH(GET_PC());
80
+ POPN(1);
81
+ #define CURRENT_INSN_setlocal 1
82
+ #define INSN_IS_SC() 0
83
+ #define INSN_LABEL(lab) LABEL_setlocal_##lab
84
+ #define LABEL_IS_SC(lab) LABEL_##lab##_##t
85
+ COLLECT_USAGE_INSN(BIN(setlocal));
86
+ COLLECT_USAGE_OPERAND(BIN(setlocal), 0, idx);
87
+ COLLECT_USAGE_OPERAND(BIN(setlocal), 1, level);
88
+ {
89
+ #line 83 "insns.def"
90
+ int i, lev = (int)level;
91
+ const VALUE *ep = GET_EP();
92
+
93
+ /* optimized insns generated for level == (0|1) in defs/opt_operand.def */
94
+ for (i = 0; i < lev; i++) {
95
+ ep = GET_PREV_EP(ep);
96
+ }
97
+ vm_env_write(ep, -(int)idx, val);
98
+
99
+ #line 100 "vm.inc"
100
+ #undef CURRENT_INSN_setlocal
101
+ #undef INSN_IS_SC
102
+ #undef INSN_LABEL
103
+ #undef LABEL_IS_SC
104
+ END_INSN(setlocal);}}}
105
+ INSN_ENTRY(getspecial){
106
+ {
107
+ VALUE val;
108
+ rb_num_t type = (rb_num_t)GET_OPERAND(2);
109
+ rb_num_t key = (rb_num_t)GET_OPERAND(1);
110
+
111
+ DEBUG_ENTER_INSN("getspecial");
112
+ ADD_PC(1+2);
113
+ PREFETCH(GET_PC());
114
+ #define CURRENT_INSN_getspecial 1
115
+ #define INSN_IS_SC() 0
116
+ #define INSN_LABEL(lab) LABEL_getspecial_##lab
117
+ #define LABEL_IS_SC(lab) LABEL_##lab##_##t
118
+ COLLECT_USAGE_INSN(BIN(getspecial));
119
+ COLLECT_USAGE_OPERAND(BIN(getspecial), 0, key);
120
+ COLLECT_USAGE_OPERAND(BIN(getspecial), 1, type);
121
+ {
122
+ #line 104 "insns.def"
123
+ val = vm_getspecial(th, GET_LEP(), key, type);
124
+
125
+ #line 126 "vm.inc"
126
+ CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1);
127
+ PUSH(val);
128
+ #undef CURRENT_INSN_getspecial
129
+ #undef INSN_IS_SC
130
+ #undef INSN_LABEL
131
+ #undef LABEL_IS_SC
132
+ END_INSN(getspecial);}}}
133
+ INSN_ENTRY(setspecial){
134
+ {
135
+ rb_num_t key = (rb_num_t)GET_OPERAND(1);
136
+ VALUE obj = TOPN(0);
137
+ DEBUG_ENTER_INSN("setspecial");
138
+ ADD_PC(1+1);
139
+ PREFETCH(GET_PC());
140
+ POPN(1);
141
+ #define CURRENT_INSN_setspecial 1
142
+ #define INSN_IS_SC() 0
143
+ #define INSN_LABEL(lab) LABEL_setspecial_##lab
144
+ #define LABEL_IS_SC(lab) LABEL_##lab##_##t
145
+ COLLECT_USAGE_INSN(BIN(setspecial));
146
+ COLLECT_USAGE_OPERAND(BIN(setspecial), 0, key);
147
+ {
148
+ #line 118 "insns.def"
149
+ lep_svar_set(th, GET_LEP(), key, obj);
150
+
151
+ #line 152 "vm.inc"
152
+ #undef CURRENT_INSN_setspecial
153
+ #undef INSN_IS_SC
154
+ #undef INSN_LABEL
155
+ #undef LABEL_IS_SC
156
+ END_INSN(setspecial);}}}
157
+ INSN_ENTRY(getinstancevariable){
158
+ {
159
+ VALUE val;
160
+ IC ic = (IC)GET_OPERAND(2);
161
+ ID id = (ID)GET_OPERAND(1);
162
+
163
+ DEBUG_ENTER_INSN("getinstancevariable");
164
+ ADD_PC(1+2);
165
+ PREFETCH(GET_PC());
166
+ #define CURRENT_INSN_getinstancevariable 1
167
+ #define INSN_IS_SC() 0
168
+ #define INSN_LABEL(lab) LABEL_getinstancevariable_##lab
169
+ #define LABEL_IS_SC(lab) LABEL_##lab##_##t
170
+ COLLECT_USAGE_INSN(BIN(getinstancevariable));
171
+ COLLECT_USAGE_OPERAND(BIN(getinstancevariable), 0, id);
172
+ COLLECT_USAGE_OPERAND(BIN(getinstancevariable), 1, ic);
173
+ {
174
+ #line 133 "insns.def"
175
+ val = vm_getinstancevariable(GET_SELF(), id, ic);
176
+
177
+ #line 178 "vm.inc"
178
+ CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1);
179
+ PUSH(val);
180
+ #undef CURRENT_INSN_getinstancevariable
181
+ #undef INSN_IS_SC
182
+ #undef INSN_LABEL
183
+ #undef LABEL_IS_SC
184
+ END_INSN(getinstancevariable);}}}
185
+ INSN_ENTRY(setinstancevariable){
186
+ {
187
+ IC ic = (IC)GET_OPERAND(2);
188
+ ID id = (ID)GET_OPERAND(1);
189
+ VALUE val = TOPN(0);
190
+ DEBUG_ENTER_INSN("setinstancevariable");
191
+ ADD_PC(1+2);
192
+ PREFETCH(GET_PC());
193
+ POPN(1);
194
+ #define CURRENT_INSN_setinstancevariable 1
195
+ #define INSN_IS_SC() 0
196
+ #define INSN_LABEL(lab) LABEL_setinstancevariable_##lab
197
+ #define LABEL_IS_SC(lab) LABEL_##lab##_##t
198
+ COLLECT_USAGE_INSN(BIN(setinstancevariable));
199
+ COLLECT_USAGE_OPERAND(BIN(setinstancevariable), 0, id);
200
+ COLLECT_USAGE_OPERAND(BIN(setinstancevariable), 1, ic);
201
+ {
202
+ #line 148 "insns.def"
203
+ vm_setinstancevariable(GET_SELF(), id, val, ic);
204
+
205
+ #line 206 "vm.inc"
206
+ #undef CURRENT_INSN_setinstancevariable
207
+ #undef INSN_IS_SC
208
+ #undef INSN_LABEL
209
+ #undef LABEL_IS_SC
210
+ END_INSN(setinstancevariable);}}}
211
+ INSN_ENTRY(getclassvariable){
212
+ {
213
+ VALUE val;
214
+ ID id = (ID)GET_OPERAND(1);
215
+
216
+ DEBUG_ENTER_INSN("getclassvariable");
217
+ ADD_PC(1+1);
218
+ PREFETCH(GET_PC());
219
+ #define CURRENT_INSN_getclassvariable 1
220
+ #define INSN_IS_SC() 0
221
+ #define INSN_LABEL(lab) LABEL_getclassvariable_##lab
222
+ #define LABEL_IS_SC(lab) LABEL_##lab##_##t
223
+ COLLECT_USAGE_INSN(BIN(getclassvariable));
224
+ COLLECT_USAGE_OPERAND(BIN(getclassvariable), 0, id);
225
+ {
226
+ #line 162 "insns.def"
227
+ val = rb_cvar_get(vm_get_cvar_base(rb_vm_get_cref(GET_EP()), GET_CFP()), id);
228
+
229
+ #line 230 "vm.inc"
230
+ CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1);
231
+ PUSH(val);
232
+ #undef CURRENT_INSN_getclassvariable
233
+ #undef INSN_IS_SC
234
+ #undef INSN_LABEL
235
+ #undef LABEL_IS_SC
236
+ END_INSN(getclassvariable);}}}
237
+ INSN_ENTRY(setclassvariable){
238
+ {
239
+ ID id = (ID)GET_OPERAND(1);
240
+ VALUE val = TOPN(0);
241
+ DEBUG_ENTER_INSN("setclassvariable");
242
+ ADD_PC(1+1);
243
+ PREFETCH(GET_PC());
244
+ POPN(1);
245
+ #define CURRENT_INSN_setclassvariable 1
246
+ #define INSN_IS_SC() 0
247
+ #define INSN_LABEL(lab) LABEL_setclassvariable_##lab
248
+ #define LABEL_IS_SC(lab) LABEL_##lab##_##t
249
+ COLLECT_USAGE_INSN(BIN(setclassvariable));
250
+ COLLECT_USAGE_OPERAND(BIN(setclassvariable), 0, id);
251
+ {
252
+ #line 176 "insns.def"
253
+ vm_ensure_not_refinement_module(GET_SELF());
254
+ rb_cvar_set(vm_get_cvar_base(rb_vm_get_cref(GET_EP()), GET_CFP()), id, val);
255
+
256
+ #line 257 "vm.inc"
257
+ #undef CURRENT_INSN_setclassvariable
258
+ #undef INSN_IS_SC
259
+ #undef INSN_LABEL
260
+ #undef LABEL_IS_SC
261
+ END_INSN(setclassvariable);}}}
262
+ INSN_ENTRY(getconstant){
263
+ {
264
+ VALUE val;
265
+ ID id = (ID)GET_OPERAND(1);
266
+ VALUE klass = TOPN(0);
267
+ DEBUG_ENTER_INSN("getconstant");
268
+ ADD_PC(1+1);
269
+ PREFETCH(GET_PC());
270
+ POPN(1);
271
+ #define CURRENT_INSN_getconstant 1
272
+ #define INSN_IS_SC() 0
273
+ #define INSN_LABEL(lab) LABEL_getconstant_##lab
274
+ #define LABEL_IS_SC(lab) LABEL_##lab##_##t
275
+ COLLECT_USAGE_INSN(BIN(getconstant));
276
+ COLLECT_USAGE_OPERAND(BIN(getconstant), 0, id);
277
+ {
278
+ #line 198 "insns.def"
279
+ val = vm_get_ev_const(th, klass, id, 0);
280
+
281
+ #line 282 "vm.inc"
282
+ CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1);
283
+ PUSH(val);
284
+ #undef CURRENT_INSN_getconstant
285
+ #undef INSN_IS_SC
286
+ #undef INSN_LABEL
287
+ #undef LABEL_IS_SC
288
+ END_INSN(getconstant);}}}
289
+ INSN_ENTRY(setconstant){
290
+ {
291
+ ID id = (ID)GET_OPERAND(1);
292
+ VALUE val = TOPN(1);
293
+ VALUE cbase = TOPN(0);
294
+ DEBUG_ENTER_INSN("setconstant");
295
+ ADD_PC(1+1);
296
+ PREFETCH(GET_PC());
297
+ POPN(2);
298
+ #define CURRENT_INSN_setconstant 1
299
+ #define INSN_IS_SC() 0
300
+ #define INSN_LABEL(lab) LABEL_setconstant_##lab
301
+ #define LABEL_IS_SC(lab) LABEL_##lab##_##t
302
+ COLLECT_USAGE_INSN(BIN(setconstant));
303
+ COLLECT_USAGE_OPERAND(BIN(setconstant), 0, id);
304
+ {
305
+ #line 220 "insns.def"
306
+ vm_check_if_namespace(cbase);
307
+ vm_ensure_not_refinement_module(GET_SELF());
308
+ rb_const_set(cbase, id, val);
309
+
310
+ #line 311 "vm.inc"
311
+ #undef CURRENT_INSN_setconstant
312
+ #undef INSN_IS_SC
313
+ #undef INSN_LABEL
314
+ #undef LABEL_IS_SC
315
+ END_INSN(setconstant);}}}
316
+ INSN_ENTRY(getglobal){
317
+ {
318
+ VALUE val;
319
+ GENTRY entry = (GENTRY)GET_OPERAND(1);
320
+
321
+ DEBUG_ENTER_INSN("getglobal");
322
+ ADD_PC(1+1);
323
+ PREFETCH(GET_PC());
324
+ #define CURRENT_INSN_getglobal 1
325
+ #define INSN_IS_SC() 0
326
+ #define INSN_LABEL(lab) LABEL_getglobal_##lab
327
+ #define LABEL_IS_SC(lab) LABEL_##lab##_##t
328
+ COLLECT_USAGE_INSN(BIN(getglobal));
329
+ COLLECT_USAGE_OPERAND(BIN(getglobal), 0, entry);
330
+ {
331
+ #line 236 "insns.def"
332
+ val = GET_GLOBAL((VALUE)entry);
333
+
334
+ #line 335 "vm.inc"
335
+ CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1);
336
+ PUSH(val);
337
+ #undef CURRENT_INSN_getglobal
338
+ #undef INSN_IS_SC
339
+ #undef INSN_LABEL
340
+ #undef LABEL_IS_SC
341
+ END_INSN(getglobal);}}}
342
+ INSN_ENTRY(setglobal){
343
+ {
344
+ GENTRY entry = (GENTRY)GET_OPERAND(1);
345
+ VALUE val = TOPN(0);
346
+ DEBUG_ENTER_INSN("setglobal");
347
+ ADD_PC(1+1);
348
+ PREFETCH(GET_PC());
349
+ POPN(1);
350
+ #define CURRENT_INSN_setglobal 1
351
+ #define INSN_IS_SC() 0
352
+ #define INSN_LABEL(lab) LABEL_setglobal_##lab
353
+ #define LABEL_IS_SC(lab) LABEL_##lab##_##t
354
+ COLLECT_USAGE_INSN(BIN(setglobal));
355
+ COLLECT_USAGE_OPERAND(BIN(setglobal), 0, entry);
356
+ {
357
+ #line 250 "insns.def"
358
+ SET_GLOBAL((VALUE)entry, val);
359
+
360
+ #line 361 "vm.inc"
361
+ #undef CURRENT_INSN_setglobal
362
+ #undef INSN_IS_SC
363
+ #undef INSN_LABEL
364
+ #undef LABEL_IS_SC
365
+ END_INSN(setglobal);}}}
366
+ INSN_ENTRY(putnil){
367
+ {
368
+ VALUE val;
369
+
370
+
371
+ DEBUG_ENTER_INSN("putnil");
372
+ ADD_PC(1+0);
373
+ PREFETCH(GET_PC());
374
+ #define CURRENT_INSN_putnil 1
375
+ #define INSN_IS_SC() 0
376
+ #define INSN_LABEL(lab) LABEL_putnil_##lab
377
+ #define LABEL_IS_SC(lab) LABEL_##lab##_##t
378
+ COLLECT_USAGE_INSN(BIN(putnil));
379
+ {
380
+ #line 269 "insns.def"
381
+ val = Qnil;
382
+
383
+ #line 384 "vm.inc"
384
+ CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1);
385
+ PUSH(val);
386
+ #undef CURRENT_INSN_putnil
387
+ #undef INSN_IS_SC
388
+ #undef INSN_LABEL
389
+ #undef LABEL_IS_SC
390
+ END_INSN(putnil);}}}
391
+ INSN_ENTRY(putself){
392
+ {
393
+ VALUE val;
394
+
395
+
396
+ DEBUG_ENTER_INSN("putself");
397
+ ADD_PC(1+0);
398
+ PREFETCH(GET_PC());
399
+ #define CURRENT_INSN_putself 1
400
+ #define INSN_IS_SC() 0
401
+ #define INSN_LABEL(lab) LABEL_putself_##lab
402
+ #define LABEL_IS_SC(lab) LABEL_##lab##_##t
403
+ COLLECT_USAGE_INSN(BIN(putself));
404
+ {
405
+ #line 283 "insns.def"
406
+ val = GET_SELF();
407
+
408
+ #line 409 "vm.inc"
409
+ CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1);
410
+ PUSH(val);
411
+ #undef CURRENT_INSN_putself
412
+ #undef INSN_IS_SC
413
+ #undef INSN_LABEL
414
+ #undef LABEL_IS_SC
415
+ END_INSN(putself);}}}
416
+ INSN_ENTRY(putobject){
417
+ {
418
+ VALUE val = (VALUE)GET_OPERAND(1);
419
+
420
+ DEBUG_ENTER_INSN("putobject");
421
+ ADD_PC(1+1);
422
+ PREFETCH(GET_PC());
423
+ #define CURRENT_INSN_putobject 1
424
+ #define INSN_IS_SC() 0
425
+ #define INSN_LABEL(lab) LABEL_putobject_##lab
426
+ #define LABEL_IS_SC(lab) LABEL_##lab##_##t
427
+ COLLECT_USAGE_INSN(BIN(putobject));
428
+ COLLECT_USAGE_OPERAND(BIN(putobject), 0, val);
429
+ {
430
+ #line 299 "insns.def"
431
+ /* */
432
+
433
+ #line 434 "vm.inc"
434
+ CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1);
435
+ PUSH(val);
436
+ #undef CURRENT_INSN_putobject
437
+ #undef INSN_IS_SC
438
+ #undef INSN_LABEL
439
+ #undef LABEL_IS_SC
440
+ END_INSN(putobject);}}}
441
+ INSN_ENTRY(putspecialobject){
442
+ {
443
+ VALUE val;
444
+ rb_num_t value_type = (rb_num_t)GET_OPERAND(1);
445
+
446
+ DEBUG_ENTER_INSN("putspecialobject");
447
+ ADD_PC(1+1);
448
+ PREFETCH(GET_PC());
449
+ #define CURRENT_INSN_putspecialobject 1
450
+ #define INSN_IS_SC() 0
451
+ #define INSN_LABEL(lab) LABEL_putspecialobject_##lab
452
+ #define LABEL_IS_SC(lab) LABEL_##lab##_##t
453
+ COLLECT_USAGE_INSN(BIN(putspecialobject));
454
+ COLLECT_USAGE_OPERAND(BIN(putspecialobject), 0, value_type);
455
+ {
456
+ #line 314 "insns.def"
457
+ enum vm_special_object_type type = (enum vm_special_object_type)value_type;
458
+
459
+ switch (type) {
460
+ case VM_SPECIAL_OBJECT_VMCORE:
461
+ val = rb_mRubyVMFrozenCore;
462
+ break;
463
+ case VM_SPECIAL_OBJECT_CBASE:
464
+ val = vm_get_cbase(GET_EP());
465
+ break;
466
+ case VM_SPECIAL_OBJECT_CONST_BASE:
467
+ val = vm_get_const_base(GET_EP());
468
+ break;
469
+ default:
470
+ rb_bug("putspecialobject insn: unknown value_type");
471
+ }
472
+
473
+ #line 474 "vm.inc"
474
+ CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1);
475
+ PUSH(val);
476
+ #undef CURRENT_INSN_putspecialobject
477
+ #undef INSN_IS_SC
478
+ #undef INSN_LABEL
479
+ #undef LABEL_IS_SC
480
+ END_INSN(putspecialobject);}}}
481
+ INSN_ENTRY(putiseq){
482
+ {
483
+ VALUE ret;
484
+ ISEQ iseq = (ISEQ)GET_OPERAND(1);
485
+
486
+ DEBUG_ENTER_INSN("putiseq");
487
+ ADD_PC(1+1);
488
+ PREFETCH(GET_PC());
489
+ #define CURRENT_INSN_putiseq 1
490
+ #define INSN_IS_SC() 0
491
+ #define INSN_LABEL(lab) LABEL_putiseq_##lab
492
+ #define LABEL_IS_SC(lab) LABEL_##lab##_##t
493
+ COLLECT_USAGE_INSN(BIN(putiseq));
494
+ COLLECT_USAGE_OPERAND(BIN(putiseq), 0, iseq);
495
+ {
496
+ #line 342 "insns.def"
497
+ ret = (VALUE)iseq;
498
+
499
+ #line 500 "vm.inc"
500
+ CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1);
501
+ PUSH(ret);
502
+ #undef CURRENT_INSN_putiseq
503
+ #undef INSN_IS_SC
504
+ #undef INSN_LABEL
505
+ #undef LABEL_IS_SC
506
+ END_INSN(putiseq);}}}
507
+ INSN_ENTRY(putstring){
508
+ {
509
+ VALUE val;
510
+ VALUE str = (VALUE)GET_OPERAND(1);
511
+
512
+ DEBUG_ENTER_INSN("putstring");
513
+ ADD_PC(1+1);
514
+ PREFETCH(GET_PC());
515
+ #define CURRENT_INSN_putstring 1
516
+ #define INSN_IS_SC() 0
517
+ #define INSN_LABEL(lab) LABEL_putstring_##lab
518
+ #define LABEL_IS_SC(lab) LABEL_##lab##_##t
519
+ COLLECT_USAGE_INSN(BIN(putstring));
520
+ COLLECT_USAGE_OPERAND(BIN(putstring), 0, str);
521
+ {
522
+ #line 356 "insns.def"
523
+ val = rb_str_resurrect(str);
524
+
525
+ #line 526 "vm.inc"
526
+ CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1);
527
+ PUSH(val);
528
+ #undef CURRENT_INSN_putstring
529
+ #undef INSN_IS_SC
530
+ #undef INSN_LABEL
531
+ #undef LABEL_IS_SC
532
+ END_INSN(putstring);}}}
533
+ INSN_ENTRY(concatstrings){
534
+ {
535
+ VALUE val;
536
+ rb_num_t num = (rb_num_t)GET_OPERAND(1);
537
+
538
+ DEBUG_ENTER_INSN("concatstrings");
539
+ ADD_PC(1+1);
540
+ PREFETCH(GET_PC());
541
+ #define CURRENT_INSN_concatstrings 1
542
+ #define INSN_IS_SC() 0
543
+ #define INSN_LABEL(lab) LABEL_concatstrings_##lab
544
+ #define LABEL_IS_SC(lab) LABEL_##lab##_##t
545
+ COLLECT_USAGE_INSN(BIN(concatstrings));
546
+ COLLECT_USAGE_OPERAND(BIN(concatstrings), 0, num);
547
+ {
548
+ #line 370 "insns.def"
549
+ val = rb_str_concat_literals(num, &TOPN(num-1));
550
+ POPN(num);
551
+
552
+ #line 553 "vm.inc"
553
+ CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1);
554
+ PUSH(val);
555
+ #undef CURRENT_INSN_concatstrings
556
+ #undef INSN_IS_SC
557
+ #undef INSN_LABEL
558
+ #undef LABEL_IS_SC
559
+ END_INSN(concatstrings);}}}
560
+ INSN_ENTRY(tostring){
561
+ {
562
+
563
+ VALUE val = TOPN(0);
564
+ DEBUG_ENTER_INSN("tostring");
565
+ ADD_PC(1+0);
566
+ PREFETCH(GET_PC());
567
+ POPN(1);
568
+ #define CURRENT_INSN_tostring 1
569
+ #define INSN_IS_SC() 0
570
+ #define INSN_LABEL(lab) LABEL_tostring_##lab
571
+ #define LABEL_IS_SC(lab) LABEL_##lab##_##t
572
+ COLLECT_USAGE_INSN(BIN(tostring));
573
+ {
574
+ #line 385 "insns.def"
575
+ val = rb_obj_as_string(val);
576
+
577
+ #line 578 "vm.inc"
578
+ CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1);
579
+ PUSH(val);
580
+ #undef CURRENT_INSN_tostring
581
+ #undef INSN_IS_SC
582
+ #undef INSN_LABEL
583
+ #undef LABEL_IS_SC
584
+ END_INSN(tostring);}}}
585
+ INSN_ENTRY(freezestring){
586
+ {
587
+ VALUE debug_info = (VALUE)GET_OPERAND(1);
588
+ VALUE str = TOPN(0);
589
+ DEBUG_ENTER_INSN("freezestring");
590
+ ADD_PC(1+1);
591
+ PREFETCH(GET_PC());
592
+ POPN(1);
593
+ #define CURRENT_INSN_freezestring 1
594
+ #define INSN_IS_SC() 0
595
+ #define INSN_LABEL(lab) LABEL_freezestring_##lab
596
+ #define LABEL_IS_SC(lab) LABEL_##lab##_##t
597
+ COLLECT_USAGE_INSN(BIN(freezestring));
598
+ COLLECT_USAGE_OPERAND(BIN(freezestring), 0, debug_info);
599
+ {
600
+ #line 399 "insns.def"
601
+ if (!NIL_P(debug_info)) {
602
+ rb_ivar_set(str, id_debug_created_info, debug_info);
603
+ }
604
+ rb_str_freeze(str);
605
+
606
+ #line 607 "vm.inc"
607
+ CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1);
608
+ PUSH(str);
609
+ #undef CURRENT_INSN_freezestring
610
+ #undef INSN_IS_SC
611
+ #undef INSN_LABEL
612
+ #undef LABEL_IS_SC
613
+ END_INSN(freezestring);}}}
614
+ INSN_ENTRY(toregexp){
615
+ {
616
+ VALUE val;
617
+ rb_num_t cnt = (rb_num_t)GET_OPERAND(2);
618
+ rb_num_t opt = (rb_num_t)GET_OPERAND(1);
619
+
620
+ DEBUG_ENTER_INSN("toregexp");
621
+ ADD_PC(1+2);
622
+ PREFETCH(GET_PC());
623
+ #define CURRENT_INSN_toregexp 1
624
+ #define INSN_IS_SC() 0
625
+ #define INSN_LABEL(lab) LABEL_toregexp_##lab
626
+ #define LABEL_IS_SC(lab) LABEL_##lab##_##t
627
+ COLLECT_USAGE_INSN(BIN(toregexp));
628
+ COLLECT_USAGE_OPERAND(BIN(toregexp), 0, opt);
629
+ COLLECT_USAGE_OPERAND(BIN(toregexp), 1, cnt);
630
+ {
631
+ #line 418 "insns.def"
632
+ VALUE rb_reg_new_ary(VALUE ary, int options);
633
+ rb_num_t i;
634
+ const VALUE ary = rb_ary_tmp_new(cnt);
635
+ for (i = 0; i < cnt; i++) {
636
+ rb_ary_store(ary, cnt-i-1, TOPN(i));
637
+ }
638
+ POPN(cnt);
639
+ val = rb_reg_new_ary(ary, (int)opt);
640
+ rb_ary_clear(ary);
641
+
642
+ #line 643 "vm.inc"
643
+ CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1);
644
+ PUSH(val);
645
+ #undef CURRENT_INSN_toregexp
646
+ #undef INSN_IS_SC
647
+ #undef INSN_LABEL
648
+ #undef LABEL_IS_SC
649
+ END_INSN(toregexp);}}}
650
+ INSN_ENTRY(newarray){
651
+ {
652
+ VALUE val;
653
+ rb_num_t num = (rb_num_t)GET_OPERAND(1);
654
+
655
+ DEBUG_ENTER_INSN("newarray");
656
+ ADD_PC(1+1);
657
+ PREFETCH(GET_PC());
658
+ #define CURRENT_INSN_newarray 1
659
+ #define INSN_IS_SC() 0
660
+ #define INSN_LABEL(lab) LABEL_newarray_##lab
661
+ #define LABEL_IS_SC(lab) LABEL_##lab##_##t
662
+ COLLECT_USAGE_INSN(BIN(newarray));
663
+ COLLECT_USAGE_OPERAND(BIN(newarray), 0, num);
664
+ {
665
+ #line 440 "insns.def"
666
+ val = rb_ary_new4((long)num, STACK_ADDR_FROM_TOP(num));
667
+ POPN(num);
668
+
669
+ #line 670 "vm.inc"
670
+ CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1);
671
+ PUSH(val);
672
+ #undef CURRENT_INSN_newarray
673
+ #undef INSN_IS_SC
674
+ #undef INSN_LABEL
675
+ #undef LABEL_IS_SC
676
+ END_INSN(newarray);}}}
677
+ INSN_ENTRY(duparray){
678
+ {
679
+ VALUE val;
680
+ VALUE ary = (VALUE)GET_OPERAND(1);
681
+
682
+ DEBUG_ENTER_INSN("duparray");
683
+ ADD_PC(1+1);
684
+ PREFETCH(GET_PC());
685
+ #define CURRENT_INSN_duparray 1
686
+ #define INSN_IS_SC() 0
687
+ #define INSN_LABEL(lab) LABEL_duparray_##lab
688
+ #define LABEL_IS_SC(lab) LABEL_##lab##_##t
689
+ COLLECT_USAGE_INSN(BIN(duparray));
690
+ COLLECT_USAGE_OPERAND(BIN(duparray), 0, ary);
691
+ {
692
+ #line 455 "insns.def"
693
+ val = rb_ary_resurrect(ary);
694
+
695
+ #line 696 "vm.inc"
696
+ CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1);
697
+ PUSH(val);
698
+ #undef CURRENT_INSN_duparray
699
+ #undef INSN_IS_SC
700
+ #undef INSN_LABEL
701
+ #undef LABEL_IS_SC
702
+ END_INSN(duparray);}}}
703
+ INSN_ENTRY(expandarray){
704
+ {
705
+ rb_num_t flag = (rb_num_t)GET_OPERAND(2);
706
+ rb_num_t num = (rb_num_t)GET_OPERAND(1);
707
+ VALUE ary = TOPN(0);
708
+ DEBUG_ENTER_INSN("expandarray");
709
+ ADD_PC(1+2);
710
+ PREFETCH(GET_PC());
711
+ POPN(1);
712
+ #define CURRENT_INSN_expandarray 1
713
+ #define INSN_IS_SC() 0
714
+ #define INSN_LABEL(lab) LABEL_expandarray_##lab
715
+ #define LABEL_IS_SC(lab) LABEL_##lab##_##t
716
+ COLLECT_USAGE_INSN(BIN(expandarray));
717
+ COLLECT_USAGE_OPERAND(BIN(expandarray), 0, num);
718
+ COLLECT_USAGE_OPERAND(BIN(expandarray), 1, flag);
719
+ {
720
+ #line 483 "insns.def"
721
+ vm_expandarray(GET_CFP(), ary, num, (int)flag);
722
+
723
+ #line 724 "vm.inc"
724
+ #undef CURRENT_INSN_expandarray
725
+ #undef INSN_IS_SC
726
+ #undef INSN_LABEL
727
+ #undef LABEL_IS_SC
728
+ END_INSN(expandarray);}}}
729
+ INSN_ENTRY(concatarray){
730
+ {
731
+ VALUE ary;
732
+
733
+ VALUE ary1 = TOPN(1);
734
+ VALUE ary2st = TOPN(0);
735
+ DEBUG_ENTER_INSN("concatarray");
736
+ ADD_PC(1+0);
737
+ PREFETCH(GET_PC());
738
+ POPN(2);
739
+ #define CURRENT_INSN_concatarray 1
740
+ #define INSN_IS_SC() 0
741
+ #define INSN_LABEL(lab) LABEL_concatarray_##lab
742
+ #define LABEL_IS_SC(lab) LABEL_##lab##_##t
743
+ COLLECT_USAGE_INSN(BIN(concatarray));
744
+ {
745
+ #line 497 "insns.def"
746
+ const VALUE ary2 = ary2st;
747
+ VALUE tmp1 = rb_check_convert_type(ary1, T_ARRAY, "Array", "to_a");
748
+ VALUE tmp2 = rb_check_convert_type(ary2, T_ARRAY, "Array", "to_a");
749
+
750
+ if (NIL_P(tmp1)) {
751
+ tmp1 = rb_ary_new3(1, ary1);
752
+ }
753
+
754
+ if (NIL_P(tmp2)) {
755
+ tmp2 = rb_ary_new3(1, ary2);
756
+ }
757
+
758
+ if (tmp1 == ary1) {
759
+ tmp1 = rb_ary_dup(ary1);
760
+ }
761
+ ary = rb_ary_concat(tmp1, tmp2);
762
+
763
+ #line 764 "vm.inc"
764
+ CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1);
765
+ PUSH(ary);
766
+ #undef CURRENT_INSN_concatarray
767
+ #undef INSN_IS_SC
768
+ #undef INSN_LABEL
769
+ #undef LABEL_IS_SC
770
+ END_INSN(concatarray);}}}
771
+ INSN_ENTRY(splatarray){
772
+ {
773
+ VALUE obj;
774
+ VALUE flag = (VALUE)GET_OPERAND(1);
775
+ VALUE ary = TOPN(0);
776
+ DEBUG_ENTER_INSN("splatarray");
777
+ ADD_PC(1+1);
778
+ PREFETCH(GET_PC());
779
+ POPN(1);
780
+ #define CURRENT_INSN_splatarray 1
781
+ #define INSN_IS_SC() 0
782
+ #define INSN_LABEL(lab) LABEL_splatarray_##lab
783
+ #define LABEL_IS_SC(lab) LABEL_##lab##_##t
784
+ COLLECT_USAGE_INSN(BIN(splatarray));
785
+ COLLECT_USAGE_OPERAND(BIN(splatarray), 0, flag);
786
+ {
787
+ #line 526 "insns.def"
788
+ VALUE tmp = rb_check_convert_type(ary, T_ARRAY, "Array", "to_a");
789
+ if (NIL_P(tmp)) {
790
+ tmp = rb_ary_new3(1, ary);
791
+ }
792
+ else if (RTEST(flag)) {
793
+ tmp = rb_ary_dup(tmp);
794
+ }
795
+ obj = tmp;
796
+
797
+ #line 798 "vm.inc"
798
+ CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1);
799
+ PUSH(obj);
800
+ #undef CURRENT_INSN_splatarray
801
+ #undef INSN_IS_SC
802
+ #undef INSN_LABEL
803
+ #undef LABEL_IS_SC
804
+ END_INSN(splatarray);}}}
805
+ INSN_ENTRY(newhash){
806
+ {
807
+ VALUE val;
808
+ rb_num_t num = (rb_num_t)GET_OPERAND(1);
809
+
810
+ DEBUG_ENTER_INSN("newhash");
811
+ ADD_PC(1+1);
812
+ PREFETCH(GET_PC());
813
+ #define CURRENT_INSN_newhash 1
814
+ #define INSN_IS_SC() 0
815
+ #define INSN_LABEL(lab) LABEL_newhash_##lab
816
+ #define LABEL_IS_SC(lab) LABEL_##lab##_##t
817
+ COLLECT_USAGE_INSN(BIN(newhash));
818
+ COLLECT_USAGE_OPERAND(BIN(newhash), 0, num);
819
+ {
820
+ #line 548 "insns.def"
821
+ rb_num_t i;
822
+
823
+ RUBY_DTRACE_CREATE_HOOK(HASH, num);
824
+
825
+ val = rb_hash_new();
826
+
827
+ for (i = num; i > 0; i -= 2) {
828
+ const VALUE v = TOPN(i - 2);
829
+ const VALUE k = TOPN(i - 1);
830
+ rb_hash_aset(val, k, v);
831
+ }
832
+ POPN(num);
833
+
834
+ #line 835 "vm.inc"
835
+ CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1);
836
+ PUSH(val);
837
+ #undef CURRENT_INSN_newhash
838
+ #undef INSN_IS_SC
839
+ #undef INSN_LABEL
840
+ #undef LABEL_IS_SC
841
+ END_INSN(newhash);}}}
842
+ INSN_ENTRY(newrange){
843
+ {
844
+ VALUE val;
845
+ rb_num_t flag = (rb_num_t)GET_OPERAND(1);
846
+ VALUE low = TOPN(1);
847
+ VALUE high = TOPN(0);
848
+ DEBUG_ENTER_INSN("newrange");
849
+ ADD_PC(1+1);
850
+ PREFETCH(GET_PC());
851
+ POPN(2);
852
+ #define CURRENT_INSN_newrange 1
853
+ #define INSN_IS_SC() 0
854
+ #define INSN_LABEL(lab) LABEL_newrange_##lab
855
+ #define LABEL_IS_SC(lab) LABEL_##lab##_##t
856
+ COLLECT_USAGE_INSN(BIN(newrange));
857
+ COLLECT_USAGE_OPERAND(BIN(newrange), 0, flag);
858
+ {
859
+ #line 573 "insns.def"
860
+ val = rb_range_new(low, high, (int)flag);
861
+
862
+ #line 863 "vm.inc"
863
+ CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1);
864
+ PUSH(val);
865
+ #undef CURRENT_INSN_newrange
866
+ #undef INSN_IS_SC
867
+ #undef INSN_LABEL
868
+ #undef LABEL_IS_SC
869
+ END_INSN(newrange);}}}
870
+ INSN_ENTRY(pop){
871
+ {
872
+
873
+ VALUE val = TOPN(0);
874
+ DEBUG_ENTER_INSN("pop");
875
+ ADD_PC(1+0);
876
+ PREFETCH(GET_PC());
877
+ POPN(1);
878
+ #define CURRENT_INSN_pop 1
879
+ #define INSN_IS_SC() 0
880
+ #define INSN_LABEL(lab) LABEL_pop_##lab
881
+ #define LABEL_IS_SC(lab) LABEL_##lab##_##t
882
+ COLLECT_USAGE_INSN(BIN(pop));
883
+ {
884
+ #line 591 "insns.def"
885
+ (void)val;
886
+ /* none */
887
+
888
+ #line 889 "vm.inc"
889
+ #undef CURRENT_INSN_pop
890
+ #undef INSN_IS_SC
891
+ #undef INSN_LABEL
892
+ #undef LABEL_IS_SC
893
+ END_INSN(pop);}}}
894
+ INSN_ENTRY(dup){
895
+ {
896
+ VALUE val2;
897
+ VALUE val1;
898
+
899
+ VALUE val = TOPN(0);
900
+ DEBUG_ENTER_INSN("dup");
901
+ ADD_PC(1+0);
902
+ PREFETCH(GET_PC());
903
+ POPN(1);
904
+ #define CURRENT_INSN_dup 1
905
+ #define INSN_IS_SC() 0
906
+ #define INSN_LABEL(lab) LABEL_dup_##lab
907
+ #define LABEL_IS_SC(lab) LABEL_##lab##_##t
908
+ COLLECT_USAGE_INSN(BIN(dup));
909
+ {
910
+ #line 606 "insns.def"
911
+ val1 = val2 = val;
912
+
913
+ #line 914 "vm.inc"
914
+ CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 2);
915
+ PUSH(val1);
916
+ PUSH(val2);
917
+ #undef CURRENT_INSN_dup
918
+ #undef INSN_IS_SC
919
+ #undef INSN_LABEL
920
+ #undef LABEL_IS_SC
921
+ END_INSN(dup);}}}
922
+ INSN_ENTRY(dupn){
923
+ {
924
+ rb_num_t n = (rb_num_t)GET_OPERAND(1);
925
+
926
+ DEBUG_ENTER_INSN("dupn");
927
+ ADD_PC(1+1);
928
+ PREFETCH(GET_PC());
929
+ #define CURRENT_INSN_dupn 1
930
+ #define INSN_IS_SC() 0
931
+ #define INSN_LABEL(lab) LABEL_dupn_##lab
932
+ #define LABEL_IS_SC(lab) LABEL_##lab##_##t
933
+ COLLECT_USAGE_INSN(BIN(dupn));
934
+ COLLECT_USAGE_OPERAND(BIN(dupn), 0, n);
935
+ {
936
+ #line 620 "insns.def"
937
+ rb_num_t i;
938
+ VALUE *sp = STACK_ADDR_FROM_TOP(n);
939
+ for (i = 0; i < n; i++) {
940
+ GET_SP()[i] = sp[i];
941
+ }
942
+ INC_SP(n);
943
+
944
+ #line 945 "vm.inc"
945
+ #undef CURRENT_INSN_dupn
946
+ #undef INSN_IS_SC
947
+ #undef INSN_LABEL
948
+ #undef LABEL_IS_SC
949
+ END_INSN(dupn);}}}
950
+ INSN_ENTRY(swap){
951
+ {
952
+
953
+ VALUE val = TOPN(1);
954
+ VALUE obj = TOPN(0);
955
+ DEBUG_ENTER_INSN("swap");
956
+ ADD_PC(1+0);
957
+ PREFETCH(GET_PC());
958
+ POPN(2);
959
+ #define CURRENT_INSN_swap 1
960
+ #define INSN_IS_SC() 0
961
+ #define INSN_LABEL(lab) LABEL_swap_##lab
962
+ #define LABEL_IS_SC(lab) LABEL_##lab##_##t
963
+ COLLECT_USAGE_INSN(BIN(swap));
964
+ {
965
+ #line 640 "insns.def"
966
+ /* none */
967
+
968
+ #line 969 "vm.inc"
969
+ CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 2);
970
+ PUSH(obj);
971
+ PUSH(val);
972
+ #undef CURRENT_INSN_swap
973
+ #undef INSN_IS_SC
974
+ #undef INSN_LABEL
975
+ #undef LABEL_IS_SC
976
+ END_INSN(swap);}}}
977
+ INSN_ENTRY(reverse){
978
+ {
979
+ rb_num_t n = (rb_num_t)GET_OPERAND(1);
980
+
981
+ DEBUG_ENTER_INSN("reverse");
982
+ ADD_PC(1+1);
983
+ PREFETCH(GET_PC());
984
+ #define CURRENT_INSN_reverse 1
985
+ #define INSN_IS_SC() 0
986
+ #define INSN_LABEL(lab) LABEL_reverse_##lab
987
+ #define LABEL_IS_SC(lab) LABEL_##lab##_##t
988
+ COLLECT_USAGE_INSN(BIN(reverse));
989
+ COLLECT_USAGE_OPERAND(BIN(reverse), 0, n);
990
+ {
991
+ #line 654 "insns.def"
992
+ rb_num_t i;
993
+ VALUE *sp = STACK_ADDR_FROM_TOP(n);
994
+
995
+ for (i=0; i<n/2; i++) {
996
+ VALUE v0 = sp[i];
997
+ VALUE v1 = TOPN(i);
998
+ sp[i] = v1;
999
+ TOPN(i) = v0;
1000
+ }
1001
+
1002
+ #line 1003 "vm.inc"
1003
+ #undef CURRENT_INSN_reverse
1004
+ #undef INSN_IS_SC
1005
+ #undef INSN_LABEL
1006
+ #undef LABEL_IS_SC
1007
+ END_INSN(reverse);}}}
1008
+ INSN_ENTRY(reput){
1009
+ {
1010
+
1011
+ VALUE val = TOPN(0);
1012
+ DEBUG_ENTER_INSN("reput");
1013
+ ADD_PC(1+0);
1014
+ PREFETCH(GET_PC());
1015
+ POPN(1);
1016
+ #define CURRENT_INSN_reput 1
1017
+ #define INSN_IS_SC() 0
1018
+ #define INSN_LABEL(lab) LABEL_reput_##lab
1019
+ #define LABEL_IS_SC(lab) LABEL_##lab##_##t
1020
+ COLLECT_USAGE_INSN(BIN(reput));
1021
+ {
1022
+ #line 676 "insns.def"
1023
+ /* none */
1024
+
1025
+ #line 1026 "vm.inc"
1026
+ CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1);
1027
+ PUSH(val);
1028
+ #undef CURRENT_INSN_reput
1029
+ #undef INSN_IS_SC
1030
+ #undef INSN_LABEL
1031
+ #undef LABEL_IS_SC
1032
+ END_INSN(reput);}}}
1033
+ INSN_ENTRY(topn){
1034
+ {
1035
+ VALUE val;
1036
+ rb_num_t n = (rb_num_t)GET_OPERAND(1);
1037
+
1038
+ DEBUG_ENTER_INSN("topn");
1039
+ ADD_PC(1+1);
1040
+ PREFETCH(GET_PC());
1041
+ #define CURRENT_INSN_topn 1
1042
+ #define INSN_IS_SC() 0
1043
+ #define INSN_LABEL(lab) LABEL_topn_##lab
1044
+ #define LABEL_IS_SC(lab) LABEL_##lab##_##t
1045
+ COLLECT_USAGE_INSN(BIN(topn));
1046
+ COLLECT_USAGE_OPERAND(BIN(topn), 0, n);
1047
+ {
1048
+ #line 690 "insns.def"
1049
+ val = TOPN(n);
1050
+
1051
+ #line 1052 "vm.inc"
1052
+ CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1);
1053
+ PUSH(val);
1054
+ #undef CURRENT_INSN_topn
1055
+ #undef INSN_IS_SC
1056
+ #undef INSN_LABEL
1057
+ #undef LABEL_IS_SC
1058
+ END_INSN(topn);}}}
1059
+ INSN_ENTRY(setn){
1060
+ {
1061
+ rb_num_t n = (rb_num_t)GET_OPERAND(1);
1062
+ VALUE val = TOPN(0);
1063
+ DEBUG_ENTER_INSN("setn");
1064
+ ADD_PC(1+1);
1065
+ PREFETCH(GET_PC());
1066
+ POPN(1);
1067
+ #define CURRENT_INSN_setn 1
1068
+ #define INSN_IS_SC() 0
1069
+ #define INSN_LABEL(lab) LABEL_setn_##lab
1070
+ #define LABEL_IS_SC(lab) LABEL_##lab##_##t
1071
+ COLLECT_USAGE_INSN(BIN(setn));
1072
+ COLLECT_USAGE_OPERAND(BIN(setn), 0, n);
1073
+ {
1074
+ #line 704 "insns.def"
1075
+ TOPN(n-1) = val;
1076
+
1077
+ #line 1078 "vm.inc"
1078
+ CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1);
1079
+ PUSH(val);
1080
+ #undef CURRENT_INSN_setn
1081
+ #undef INSN_IS_SC
1082
+ #undef INSN_LABEL
1083
+ #undef LABEL_IS_SC
1084
+ END_INSN(setn);}}}
1085
+ INSN_ENTRY(adjuststack){
1086
+ {
1087
+ rb_num_t n = (rb_num_t)GET_OPERAND(1);
1088
+
1089
+ DEBUG_ENTER_INSN("adjuststack");
1090
+ ADD_PC(1+1);
1091
+ PREFETCH(GET_PC());
1092
+ #define CURRENT_INSN_adjuststack 1
1093
+ #define INSN_IS_SC() 0
1094
+ #define INSN_LABEL(lab) LABEL_adjuststack_##lab
1095
+ #define LABEL_IS_SC(lab) LABEL_##lab##_##t
1096
+ COLLECT_USAGE_INSN(BIN(adjuststack));
1097
+ COLLECT_USAGE_OPERAND(BIN(adjuststack), 0, n);
1098
+ {
1099
+ #line 718 "insns.def"
1100
+ DEC_SP(n);
1101
+
1102
+ #line 1103 "vm.inc"
1103
+ #undef CURRENT_INSN_adjuststack
1104
+ #undef INSN_IS_SC
1105
+ #undef INSN_LABEL
1106
+ #undef LABEL_IS_SC
1107
+ END_INSN(adjuststack);}}}
1108
+ INSN_ENTRY(defined){
1109
+ {
1110
+ VALUE val;
1111
+ VALUE needstr = (VALUE)GET_OPERAND(3);
1112
+ VALUE obj = (VALUE)GET_OPERAND(2);
1113
+ rb_num_t op_type = (rb_num_t)GET_OPERAND(1);
1114
+ VALUE v = TOPN(0);
1115
+ DEBUG_ENTER_INSN("defined");
1116
+ ADD_PC(1+3);
1117
+ PREFETCH(GET_PC());
1118
+ POPN(1);
1119
+ #define CURRENT_INSN_defined 1
1120
+ #define INSN_IS_SC() 0
1121
+ #define INSN_LABEL(lab) LABEL_defined_##lab
1122
+ #define LABEL_IS_SC(lab) LABEL_##lab##_##t
1123
+ COLLECT_USAGE_INSN(BIN(defined));
1124
+ COLLECT_USAGE_OPERAND(BIN(defined), 0, op_type);
1125
+ COLLECT_USAGE_OPERAND(BIN(defined), 1, obj);
1126
+ COLLECT_USAGE_OPERAND(BIN(defined), 2, needstr);
1127
+ {
1128
+ #line 737 "insns.def"
1129
+ val = vm_defined(th, GET_CFP(), op_type, obj, needstr, v);
1130
+
1131
+ #line 1132 "vm.inc"
1132
+ CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1);
1133
+ PUSH(val);
1134
+ #undef CURRENT_INSN_defined
1135
+ #undef INSN_IS_SC
1136
+ #undef INSN_LABEL
1137
+ #undef LABEL_IS_SC
1138
+ END_INSN(defined);}}}
1139
+ INSN_ENTRY(checkmatch){
1140
+ {
1141
+ VALUE result;
1142
+ rb_num_t flag = (rb_num_t)GET_OPERAND(1);
1143
+ VALUE target = TOPN(1);
1144
+ VALUE pattern = TOPN(0);
1145
+ DEBUG_ENTER_INSN("checkmatch");
1146
+ ADD_PC(1+1);
1147
+ PREFETCH(GET_PC());
1148
+ POPN(2);
1149
+ #define CURRENT_INSN_checkmatch 1
1150
+ #define INSN_IS_SC() 0
1151
+ #define INSN_LABEL(lab) LABEL_checkmatch_##lab
1152
+ #define LABEL_IS_SC(lab) LABEL_##lab##_##t
1153
+ COLLECT_USAGE_INSN(BIN(checkmatch));
1154
+ COLLECT_USAGE_OPERAND(BIN(checkmatch), 0, flag);
1155
+ {
1156
+ #line 756 "insns.def"
1157
+ enum vm_check_match_type checkmatch_type =
1158
+ (enum vm_check_match_type)(flag & VM_CHECKMATCH_TYPE_MASK);
1159
+ result = Qfalse;
1160
+
1161
+ if (flag & VM_CHECKMATCH_ARRAY) {
1162
+ int i;
1163
+ for (i = 0; i < RARRAY_LEN(pattern); i++) {
1164
+ if (RTEST(check_match(RARRAY_AREF(pattern, i), target, checkmatch_type))) {
1165
+ result = Qtrue;
1166
+ break;
1167
+ }
1168
+ }
1169
+ }
1170
+ else {
1171
+ if (RTEST(check_match(pattern, target, checkmatch_type))) {
1172
+ result = Qtrue;
1173
+ }
1174
+ }
1175
+
1176
+ #line 1177 "vm.inc"
1177
+ CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1);
1178
+ PUSH(result);
1179
+ #undef CURRENT_INSN_checkmatch
1180
+ #undef INSN_IS_SC
1181
+ #undef INSN_LABEL
1182
+ #undef LABEL_IS_SC
1183
+ END_INSN(checkmatch);}}}
1184
+ INSN_ENTRY(checkkeyword){
1185
+ {
1186
+ VALUE ret;
1187
+ rb_num_t keyword_index = (rb_num_t)GET_OPERAND(2);
1188
+ lindex_t kw_bits_index = (lindex_t)GET_OPERAND(1);
1189
+
1190
+ DEBUG_ENTER_INSN("checkkeyword");
1191
+ ADD_PC(1+2);
1192
+ PREFETCH(GET_PC());
1193
+ #define CURRENT_INSN_checkkeyword 1
1194
+ #define INSN_IS_SC() 0
1195
+ #define INSN_LABEL(lab) LABEL_checkkeyword_##lab
1196
+ #define LABEL_IS_SC(lab) LABEL_##lab##_##t
1197
+ COLLECT_USAGE_INSN(BIN(checkkeyword));
1198
+ COLLECT_USAGE_OPERAND(BIN(checkkeyword), 0, kw_bits_index);
1199
+ COLLECT_USAGE_OPERAND(BIN(checkkeyword), 1, keyword_index);
1200
+ {
1201
+ #line 787 "insns.def"
1202
+ const VALUE *ep = GET_EP();
1203
+ const VALUE kw_bits = *(ep - kw_bits_index);
1204
+
1205
+ if (FIXNUM_P(kw_bits)) {
1206
+ int bits = FIX2INT(kw_bits);
1207
+ ret = (bits & (0x01 << keyword_index)) ? Qfalse : Qtrue;
1208
+ }
1209
+ else {
1210
+ VM_ASSERT(RB_TYPE_P(kw_bits, T_HASH));
1211
+ ret = rb_hash_has_key(kw_bits, INT2FIX(keyword_index)) ? Qfalse : Qtrue;
1212
+ }
1213
+
1214
+ #line 1215 "vm.inc"
1215
+ CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1);
1216
+ PUSH(ret);
1217
+ #undef CURRENT_INSN_checkkeyword
1218
+ #undef INSN_IS_SC
1219
+ #undef INSN_LABEL
1220
+ #undef LABEL_IS_SC
1221
+ END_INSN(checkkeyword);}}}
1222
+ INSN_ENTRY(trace){
1223
+ {
1224
+ rb_num_t nf = (rb_num_t)GET_OPERAND(1);
1225
+
1226
+ DEBUG_ENTER_INSN("trace");
1227
+ ADD_PC(1+1);
1228
+ PREFETCH(GET_PC());
1229
+ #define CURRENT_INSN_trace 1
1230
+ #define INSN_IS_SC() 0
1231
+ #define INSN_LABEL(lab) LABEL_trace_##lab
1232
+ #define LABEL_IS_SC(lab) LABEL_##lab##_##t
1233
+ COLLECT_USAGE_INSN(BIN(trace));
1234
+ COLLECT_USAGE_OPERAND(BIN(trace), 0, nf);
1235
+ {
1236
+ #line 811 "insns.def"
1237
+ rb_event_flag_t flag = (rb_event_flag_t)nf;
1238
+
1239
+ if (RUBY_DTRACE_METHOD_ENTRY_ENABLED() ||
1240
+ RUBY_DTRACE_METHOD_RETURN_ENABLED() ||
1241
+ RUBY_DTRACE_CMETHOD_ENTRY_ENABLED() ||
1242
+ RUBY_DTRACE_CMETHOD_RETURN_ENABLED()) {
1243
+
1244
+ switch (flag) {
1245
+ case RUBY_EVENT_CALL:
1246
+ RUBY_DTRACE_METHOD_ENTRY_HOOK(th, 0, 0);
1247
+ break;
1248
+ case RUBY_EVENT_C_CALL:
1249
+ RUBY_DTRACE_CMETHOD_ENTRY_HOOK(th, 0, 0);
1250
+ break;
1251
+ case RUBY_EVENT_RETURN:
1252
+ RUBY_DTRACE_METHOD_RETURN_HOOK(th, 0, 0);
1253
+ break;
1254
+ case RUBY_EVENT_C_RETURN:
1255
+ RUBY_DTRACE_CMETHOD_RETURN_HOOK(th, 0, 0);
1256
+ break;
1257
+ }
1258
+ }
1259
+
1260
+ EXEC_EVENT_HOOK(th, flag, GET_SELF(), 0, 0 /* id and klass are resolved at callee */,
1261
+ (flag & (RUBY_EVENT_RETURN | RUBY_EVENT_B_RETURN)) ? TOPN(0) : Qundef);
1262
+
1263
+ #line 1264 "vm.inc"
1264
+ #undef CURRENT_INSN_trace
1265
+ #undef INSN_IS_SC
1266
+ #undef INSN_LABEL
1267
+ #undef LABEL_IS_SC
1268
+ END_INSN(trace);}}}
1269
+ INSN_ENTRY(defineclass){
1270
+ {
1271
+ VALUE val;
1272
+ rb_num_t flags = (rb_num_t)GET_OPERAND(3);
1273
+ ISEQ class_iseq = (ISEQ)GET_OPERAND(2);
1274
+ ID id = (ID)GET_OPERAND(1);
1275
+ VALUE cbase = TOPN(1);
1276
+ VALUE super = TOPN(0);
1277
+ DEBUG_ENTER_INSN("defineclass");
1278
+ ADD_PC(1+3);
1279
+ PREFETCH(GET_PC());
1280
+ POPN(2);
1281
+ #define CURRENT_INSN_defineclass 1
1282
+ #define INSN_IS_SC() 0
1283
+ #define INSN_LABEL(lab) LABEL_defineclass_##lab
1284
+ #define LABEL_IS_SC(lab) LABEL_##lab##_##t
1285
+ COLLECT_USAGE_INSN(BIN(defineclass));
1286
+ COLLECT_USAGE_OPERAND(BIN(defineclass), 0, id);
1287
+ COLLECT_USAGE_OPERAND(BIN(defineclass), 1, class_iseq);
1288
+ COLLECT_USAGE_OPERAND(BIN(defineclass), 2, flags);
1289
+ {
1290
+ #line 857 "insns.def"
1291
+ VALUE klass;
1292
+ rb_vm_defineclass_type_t type = VM_DEFINECLASS_TYPE(flags);
1293
+
1294
+ switch (type) {
1295
+ case VM_DEFINECLASS_TYPE_CLASS:
1296
+ /* val is dummy. classdef returns class scope value */
1297
+
1298
+ if (VM_DEFINECLASS_HAS_SUPERCLASS_P(flags) &&
1299
+ !RB_TYPE_P(super, T_CLASS)) {
1300
+ rb_raise(rb_eTypeError, "superclass must be a Class (%"PRIsVALUE" given)",
1301
+ rb_obj_class(super));
1302
+ }
1303
+
1304
+ vm_check_if_namespace(cbase);
1305
+
1306
+ /* find klass */
1307
+ rb_autoload_load(cbase, id);
1308
+ if ((klass = vm_search_const_defined_class(cbase, id)) != 0) {
1309
+ /* already exist */
1310
+ klass = VM_DEFINECLASS_SCOPED_P(flags) ?
1311
+ rb_public_const_get_at(klass, id) : rb_const_get_at(klass, id);
1312
+ if (!RB_TYPE_P(klass, T_CLASS)) {
1313
+ rb_raise(rb_eTypeError, "%"PRIsVALUE" is not a class", rb_id2str(id));
1314
+ }
1315
+
1316
+ if (VM_DEFINECLASS_HAS_SUPERCLASS_P(flags)) {
1317
+ VALUE tmp;
1318
+ tmp = rb_class_real(RCLASS_SUPER(klass));
1319
+
1320
+ if (tmp != super) {
1321
+ rb_raise(rb_eTypeError, "superclass mismatch for class %"PRIsVALUE"",
1322
+ rb_id2str(id));
1323
+ }
1324
+ }
1325
+ }
1326
+ else {
1327
+ if (!VM_DEFINECLASS_HAS_SUPERCLASS_P(flags)) {
1328
+ super = rb_cObject;
1329
+ }
1330
+ /* new class declaration */
1331
+ klass = rb_define_class_id(id, super);
1332
+ rb_set_class_path_string(klass, cbase, rb_id2str(id));
1333
+ rb_const_set(cbase, id, klass);
1334
+ rb_class_inherited(super, klass);
1335
+ }
1336
+ break;
1337
+ case VM_DEFINECLASS_TYPE_SINGLETON_CLASS:
1338
+ /* val is dummy. classdef returns class scope value */
1339
+ /* super is dummy */
1340
+ klass = rb_singleton_class(cbase);
1341
+ break;
1342
+ case VM_DEFINECLASS_TYPE_MODULE:
1343
+ /* val is dummy. classdef returns class scope value */
1344
+ /* super is dummy */
1345
+
1346
+ vm_check_if_namespace(cbase);
1347
+
1348
+ /* find klass */
1349
+ if ((klass = vm_search_const_defined_class(cbase, id)) != 0) {
1350
+ klass = VM_DEFINECLASS_SCOPED_P(flags) ?
1351
+ rb_public_const_get_at(klass, id) : rb_const_get_at(klass, id);
1352
+ /* already exist */
1353
+ if (!RB_TYPE_P(klass, T_MODULE)) {
1354
+ rb_raise(rb_eTypeError, "%"PRIsVALUE" is not a module", rb_id2str(id));
1355
+ }
1356
+ }
1357
+ else {
1358
+ /* new module declaration */
1359
+ klass = rb_define_module_id(id);
1360
+ rb_set_class_path_string(klass, cbase, rb_id2str(id));
1361
+ rb_const_set(cbase, id, klass);
1362
+ }
1363
+ break;
1364
+ default:
1365
+ rb_bug("unknown defineclass type: %d", (int)type);
1366
+ }
1367
+
1368
+ rb_iseq_check(class_iseq);
1369
+
1370
+ /* enter scope */
1371
+ vm_push_frame(th, class_iseq, VM_FRAME_MAGIC_CLASS | VM_ENV_FLAG_LOCAL, klass,
1372
+ GET_BLOCK_HANDLER(),
1373
+ (VALUE)vm_cref_push(th, klass, NULL, FALSE),
1374
+ class_iseq->body->iseq_encoded, GET_SP(),
1375
+ class_iseq->body->local_table_size,
1376
+ class_iseq->body->stack_max);
1377
+ RESTORE_REGS();
1378
+ NEXT_INSN();
1379
+
1380
+ #line 1381 "vm.inc"
1381
+ CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1);
1382
+ PUSH(val);
1383
+ #undef CURRENT_INSN_defineclass
1384
+ #undef INSN_IS_SC
1385
+ #undef INSN_LABEL
1386
+ #undef LABEL_IS_SC
1387
+ END_INSN(defineclass);}}}
1388
+ INSN_ENTRY(send){
1389
+ {
1390
+ VALUE val;
1391
+ ISEQ blockiseq = (ISEQ)GET_OPERAND(3);
1392
+ CALL_CACHE cc = (CALL_CACHE)GET_OPERAND(2);
1393
+ CALL_INFO ci = (CALL_INFO)GET_OPERAND(1);
1394
+
1395
+ DEBUG_ENTER_INSN("send");
1396
+ ADD_PC(1+3);
1397
+ PREFETCH(GET_PC());
1398
+ #define CURRENT_INSN_send 1
1399
+ #define INSN_IS_SC() 0
1400
+ #define INSN_LABEL(lab) LABEL_send_##lab
1401
+ #define LABEL_IS_SC(lab) LABEL_##lab##_##t
1402
+ COLLECT_USAGE_INSN(BIN(send));
1403
+ COLLECT_USAGE_OPERAND(BIN(send), 0, ci);
1404
+ COLLECT_USAGE_OPERAND(BIN(send), 1, cc);
1405
+ COLLECT_USAGE_OPERAND(BIN(send), 2, blockiseq);
1406
+ {
1407
+ #line 963 "insns.def"
1408
+ struct rb_calling_info calling;
1409
+
1410
+ vm_caller_setup_arg_block(th, reg_cfp, &calling, ci, blockiseq, FALSE);
1411
+ vm_search_method(ci, cc, calling.recv = TOPN(calling.argc = ci->orig_argc));
1412
+ CALL_METHOD(&calling, ci, cc);
1413
+
1414
+ #line 1415 "vm.inc"
1415
+ CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1);
1416
+ PUSH(val);
1417
+ #undef CURRENT_INSN_send
1418
+ #undef INSN_IS_SC
1419
+ #undef INSN_LABEL
1420
+ #undef LABEL_IS_SC
1421
+ END_INSN(send);}}}
1422
+ INSN_ENTRY(opt_str_freeze){
1423
+ {
1424
+ VALUE val;
1425
+ VALUE str = (VALUE)GET_OPERAND(1);
1426
+
1427
+ DEBUG_ENTER_INSN("opt_str_freeze");
1428
+ ADD_PC(1+1);
1429
+ PREFETCH(GET_PC());
1430
+ #define CURRENT_INSN_opt_str_freeze 1
1431
+ #define INSN_IS_SC() 0
1432
+ #define INSN_LABEL(lab) LABEL_opt_str_freeze_##lab
1433
+ #define LABEL_IS_SC(lab) LABEL_##lab##_##t
1434
+ COLLECT_USAGE_INSN(BIN(opt_str_freeze));
1435
+ COLLECT_USAGE_OPERAND(BIN(opt_str_freeze), 0, str);
1436
+ {
1437
+ #line 976 "insns.def"
1438
+ if (BASIC_OP_UNREDEFINED_P(BOP_FREEZE, STRING_REDEFINED_OP_FLAG)) {
1439
+ val = str;
1440
+ }
1441
+ else {
1442
+ val = rb_funcall(rb_str_resurrect(str), idFreeze, 0);
1443
+ }
1444
+
1445
+ #line 1446 "vm.inc"
1446
+ CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1);
1447
+ PUSH(val);
1448
+ #undef CURRENT_INSN_opt_str_freeze
1449
+ #undef INSN_IS_SC
1450
+ #undef INSN_LABEL
1451
+ #undef LABEL_IS_SC
1452
+ END_INSN(opt_str_freeze);}}}
1453
+ INSN_ENTRY(opt_newarray_max){
1454
+ {
1455
+ VALUE val;
1456
+ rb_num_t num = (rb_num_t)GET_OPERAND(1);
1457
+
1458
+ DEBUG_ENTER_INSN("opt_newarray_max");
1459
+ ADD_PC(1+1);
1460
+ PREFETCH(GET_PC());
1461
+ #define CURRENT_INSN_opt_newarray_max 1
1462
+ #define INSN_IS_SC() 0
1463
+ #define INSN_LABEL(lab) LABEL_opt_newarray_max_##lab
1464
+ #define LABEL_IS_SC(lab) LABEL_##lab##_##t
1465
+ COLLECT_USAGE_INSN(BIN(opt_newarray_max));
1466
+ COLLECT_USAGE_OPERAND(BIN(opt_newarray_max), 0, num);
1467
+ {
1468
+ #line 990 "insns.def"
1469
+ #define id_cmp idCmp
1470
+ if (BASIC_OP_UNREDEFINED_P(BOP_MAX, ARRAY_REDEFINED_OP_FLAG)) {
1471
+ if (num == 0) {
1472
+ val = Qnil;
1473
+ }
1474
+ else {
1475
+ struct cmp_opt_data cmp_opt = { 0, 0 };
1476
+ VALUE result = Qundef;
1477
+ rb_num_t i = num - 1;
1478
+ result = TOPN(i);
1479
+ while (i-- > 0) {
1480
+ const VALUE v = TOPN(i);
1481
+ if (result == Qundef || OPTIMIZED_CMP(v, result, cmp_opt) > 0) {
1482
+ result = v;
1483
+ }
1484
+ }
1485
+ val = result == Qundef ? Qnil : result;
1486
+ }
1487
+ POPN(num);
1488
+ }
1489
+ else {
1490
+ VALUE ary = rb_ary_new4((long)num, STACK_ADDR_FROM_TOP(num));
1491
+ val = rb_funcall(ary, idMax, 0);
1492
+ POPN(num);
1493
+ }
1494
+ #undef id_cmp
1495
+
1496
+ #line 1497 "vm.inc"
1497
+ CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1);
1498
+ PUSH(val);
1499
+ #undef CURRENT_INSN_opt_newarray_max
1500
+ #undef INSN_IS_SC
1501
+ #undef INSN_LABEL
1502
+ #undef LABEL_IS_SC
1503
+ END_INSN(opt_newarray_max);}}}
1504
+ INSN_ENTRY(opt_newarray_min){
1505
+ {
1506
+ VALUE val;
1507
+ rb_num_t num = (rb_num_t)GET_OPERAND(1);
1508
+
1509
+ DEBUG_ENTER_INSN("opt_newarray_min");
1510
+ ADD_PC(1+1);
1511
+ PREFETCH(GET_PC());
1512
+ #define CURRENT_INSN_opt_newarray_min 1
1513
+ #define INSN_IS_SC() 0
1514
+ #define INSN_LABEL(lab) LABEL_opt_newarray_min_##lab
1515
+ #define LABEL_IS_SC(lab) LABEL_##lab##_##t
1516
+ COLLECT_USAGE_INSN(BIN(opt_newarray_min));
1517
+ COLLECT_USAGE_OPERAND(BIN(opt_newarray_min), 0, num);
1518
+ {
1519
+ #line 1024 "insns.def"
1520
+ #define id_cmp idCmp
1521
+ if (BASIC_OP_UNREDEFINED_P(BOP_MIN, ARRAY_REDEFINED_OP_FLAG)) {
1522
+ if (num == 0) {
1523
+ val = Qnil;
1524
+ }
1525
+ else {
1526
+ struct cmp_opt_data cmp_opt = { 0, 0 };
1527
+ VALUE result = Qundef;
1528
+ rb_num_t i = num - 1;
1529
+ result = TOPN(i);
1530
+ while (i-- > 0) {
1531
+ const VALUE v = TOPN(i);
1532
+ if (result == Qundef || OPTIMIZED_CMP(v, result, cmp_opt) < 0) {
1533
+ result = v;
1534
+ }
1535
+ }
1536
+ val = result == Qundef ? Qnil : result;
1537
+ }
1538
+ POPN(num);
1539
+ }
1540
+ else {
1541
+ VALUE ary = rb_ary_new4((long)num, STACK_ADDR_FROM_TOP(num));
1542
+ val = rb_funcall(ary, idMin, 0);
1543
+ POPN(num);
1544
+ }
1545
+ #undef id_cmp
1546
+
1547
+ #line 1548 "vm.inc"
1548
+ CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1);
1549
+ PUSH(val);
1550
+ #undef CURRENT_INSN_opt_newarray_min
1551
+ #undef INSN_IS_SC
1552
+ #undef INSN_LABEL
1553
+ #undef LABEL_IS_SC
1554
+ END_INSN(opt_newarray_min);}}}
1555
+ INSN_ENTRY(opt_send_without_block){
1556
+ {
1557
+ VALUE val;
1558
+ CALL_CACHE cc = (CALL_CACHE)GET_OPERAND(2);
1559
+ CALL_INFO ci = (CALL_INFO)GET_OPERAND(1);
1560
+
1561
+ DEBUG_ENTER_INSN("opt_send_without_block");
1562
+ ADD_PC(1+2);
1563
+ PREFETCH(GET_PC());
1564
+ #define CURRENT_INSN_opt_send_without_block 1
1565
+ #define INSN_IS_SC() 0
1566
+ #define INSN_LABEL(lab) LABEL_opt_send_without_block_##lab
1567
+ #define LABEL_IS_SC(lab) LABEL_##lab##_##t
1568
+ COLLECT_USAGE_INSN(BIN(opt_send_without_block));
1569
+ COLLECT_USAGE_OPERAND(BIN(opt_send_without_block), 0, ci);
1570
+ COLLECT_USAGE_OPERAND(BIN(opt_send_without_block), 1, cc);
1571
+ {
1572
+ #line 1063 "insns.def"
1573
+ struct rb_calling_info calling;
1574
+ calling.block_handler = VM_BLOCK_HANDLER_NONE;
1575
+ vm_search_method(ci, cc, calling.recv = TOPN(calling.argc = ci->orig_argc));
1576
+ CALL_METHOD(&calling, ci, cc);
1577
+
1578
+ #line 1579 "vm.inc"
1579
+ CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1);
1580
+ PUSH(val);
1581
+ #undef CURRENT_INSN_opt_send_without_block
1582
+ #undef INSN_IS_SC
1583
+ #undef INSN_LABEL
1584
+ #undef LABEL_IS_SC
1585
+ END_INSN(opt_send_without_block);}}}
1586
+ INSN_ENTRY(invokesuper){
1587
+ {
1588
+ VALUE val;
1589
+ ISEQ blockiseq = (ISEQ)GET_OPERAND(3);
1590
+ CALL_CACHE cc = (CALL_CACHE)GET_OPERAND(2);
1591
+ CALL_INFO ci = (CALL_INFO)GET_OPERAND(1);
1592
+
1593
+ DEBUG_ENTER_INSN("invokesuper");
1594
+ ADD_PC(1+3);
1595
+ PREFETCH(GET_PC());
1596
+ #define CURRENT_INSN_invokesuper 1
1597
+ #define INSN_IS_SC() 0
1598
+ #define INSN_LABEL(lab) LABEL_invokesuper_##lab
1599
+ #define LABEL_IS_SC(lab) LABEL_##lab##_##t
1600
+ COLLECT_USAGE_INSN(BIN(invokesuper));
1601
+ COLLECT_USAGE_OPERAND(BIN(invokesuper), 0, ci);
1602
+ COLLECT_USAGE_OPERAND(BIN(invokesuper), 1, cc);
1603
+ COLLECT_USAGE_OPERAND(BIN(invokesuper), 2, blockiseq);
1604
+ {
1605
+ #line 1080 "insns.def"
1606
+ struct rb_calling_info calling;
1607
+ calling.argc = ci->orig_argc;
1608
+
1609
+ vm_caller_setup_arg_block(th, reg_cfp, &calling, ci, blockiseq, TRUE);
1610
+ calling.recv = GET_SELF();
1611
+ vm_search_super_method(th, GET_CFP(), &calling, ci, cc);
1612
+ CALL_METHOD(&calling, ci, cc);
1613
+
1614
+ #line 1615 "vm.inc"
1615
+ CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1);
1616
+ PUSH(val);
1617
+ #undef CURRENT_INSN_invokesuper
1618
+ #undef INSN_IS_SC
1619
+ #undef INSN_LABEL
1620
+ #undef LABEL_IS_SC
1621
+ END_INSN(invokesuper);}}}
1622
+ INSN_ENTRY(invokeblock){
1623
+ {
1624
+ VALUE val;
1625
+ CALL_INFO ci = (CALL_INFO)GET_OPERAND(1);
1626
+
1627
+ DEBUG_ENTER_INSN("invokeblock");
1628
+ ADD_PC(1+1);
1629
+ PREFETCH(GET_PC());
1630
+ #define CURRENT_INSN_invokeblock 1
1631
+ #define INSN_IS_SC() 0
1632
+ #define INSN_LABEL(lab) LABEL_invokeblock_##lab
1633
+ #define LABEL_IS_SC(lab) LABEL_##lab##_##t
1634
+ COLLECT_USAGE_INSN(BIN(invokeblock));
1635
+ COLLECT_USAGE_OPERAND(BIN(invokeblock), 0, ci);
1636
+ {
1637
+ #line 1100 "insns.def"
1638
+ struct rb_calling_info calling;
1639
+ calling.argc = ci->orig_argc;
1640
+ calling.block_handler = VM_BLOCK_HANDLER_NONE;
1641
+ calling.recv = GET_SELF();
1642
+
1643
+ val = vm_invoke_block(th, GET_CFP(), &calling, ci);
1644
+ if (val == Qundef) {
1645
+ RESTORE_REGS();
1646
+ NEXT_INSN();
1647
+ }
1648
+
1649
+ #line 1650 "vm.inc"
1650
+ CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1);
1651
+ PUSH(val);
1652
+ #undef CURRENT_INSN_invokeblock
1653
+ #undef INSN_IS_SC
1654
+ #undef INSN_LABEL
1655
+ #undef LABEL_IS_SC
1656
+ END_INSN(invokeblock);}}}
1657
+ INSN_ENTRY(leave){
1658
+ {
1659
+
1660
+ VALUE val = TOPN(0);
1661
+ DEBUG_ENTER_INSN("leave");
1662
+ ADD_PC(1+0);
1663
+ PREFETCH(GET_PC());
1664
+ POPN(1);
1665
+ #define CURRENT_INSN_leave 1
1666
+ #define INSN_IS_SC() 0
1667
+ #define INSN_LABEL(lab) LABEL_leave_##lab
1668
+ #define LABEL_IS_SC(lab) LABEL_##lab##_##t
1669
+ COLLECT_USAGE_INSN(BIN(leave));
1670
+ {
1671
+ #line 1123 "insns.def"
1672
+ if (OPT_CHECKED_RUN) {
1673
+ const VALUE *const bp = vm_base_ptr(reg_cfp);
1674
+ if (reg_cfp->sp != bp) {
1675
+ rb_bug("Stack consistency error (sp: %"PRIdPTRDIFF", bp: %"PRIdPTRDIFF")",
1676
+ VM_SP_CNT(th, reg_cfp->sp), VM_SP_CNT(th, bp));
1677
+ }
1678
+ }
1679
+
1680
+ RUBY_VM_CHECK_INTS(th);
1681
+
1682
+ if (vm_pop_frame(th, GET_CFP(), GET_EP())) {
1683
+ #if OPT_CALL_THREADED_CODE
1684
+ th->retval = val;
1685
+ return 0;
1686
+ #else
1687
+ return val;
1688
+ #endif
1689
+ }
1690
+ else {
1691
+ RESTORE_REGS();
1692
+ }
1693
+
1694
+ #line 1695 "vm.inc"
1695
+ CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1);
1696
+ PUSH(val);
1697
+ #undef CURRENT_INSN_leave
1698
+ #undef INSN_IS_SC
1699
+ #undef INSN_LABEL
1700
+ #undef LABEL_IS_SC
1701
+ END_INSN(leave);}}}
1702
+ INSN_ENTRY(throw){
1703
+ {
1704
+ VALUE val;
1705
+ rb_num_t throw_state = (rb_num_t)GET_OPERAND(1);
1706
+ VALUE throwobj = TOPN(0);
1707
+ DEBUG_ENTER_INSN("throw");
1708
+ ADD_PC(1+1);
1709
+ PREFETCH(GET_PC());
1710
+ POPN(1);
1711
+ #define CURRENT_INSN_throw 1
1712
+ #define INSN_IS_SC() 0
1713
+ #define INSN_LABEL(lab) LABEL_throw_##lab
1714
+ #define LABEL_IS_SC(lab) LABEL_##lab##_##t
1715
+ COLLECT_USAGE_INSN(BIN(throw));
1716
+ COLLECT_USAGE_OPERAND(BIN(throw), 0, throw_state);
1717
+ {
1718
+ #line 1161 "insns.def"
1719
+ RUBY_VM_CHECK_INTS(th);
1720
+ val = vm_throw(th, GET_CFP(), throw_state, throwobj);
1721
+ THROW_EXCEPTION(val);
1722
+ /* unreachable */
1723
+
1724
+ #line 1725 "vm.inc"
1725
+ CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1);
1726
+ PUSH(val);
1727
+ #undef CURRENT_INSN_throw
1728
+ #undef INSN_IS_SC
1729
+ #undef INSN_LABEL
1730
+ #undef LABEL_IS_SC
1731
+ END_INSN(throw);}}}
1732
+ INSN_ENTRY(jump){
1733
+ {
1734
+ OFFSET dst = (OFFSET)GET_OPERAND(1);
1735
+
1736
+ DEBUG_ENTER_INSN("jump");
1737
+ ADD_PC(1+1);
1738
+ PREFETCH(GET_PC());
1739
+ #define CURRENT_INSN_jump 1
1740
+ #define INSN_IS_SC() 0
1741
+ #define INSN_LABEL(lab) LABEL_jump_##lab
1742
+ #define LABEL_IS_SC(lab) LABEL_##lab##_##t
1743
+ COLLECT_USAGE_INSN(BIN(jump));
1744
+ COLLECT_USAGE_OPERAND(BIN(jump), 0, dst);
1745
+ {
1746
+ #line 1182 "insns.def"
1747
+ RUBY_VM_CHECK_INTS(th);
1748
+ JUMP(dst);
1749
+
1750
+ #line 1751 "vm.inc"
1751
+ #undef CURRENT_INSN_jump
1752
+ #undef INSN_IS_SC
1753
+ #undef INSN_LABEL
1754
+ #undef LABEL_IS_SC
1755
+ END_INSN(jump);}}}
1756
+ INSN_ENTRY(branchif){
1757
+ {
1758
+ OFFSET dst = (OFFSET)GET_OPERAND(1);
1759
+ VALUE val = TOPN(0);
1760
+ DEBUG_ENTER_INSN("branchif");
1761
+ ADD_PC(1+1);
1762
+ PREFETCH(GET_PC());
1763
+ POPN(1);
1764
+ #define CURRENT_INSN_branchif 1
1765
+ #define INSN_IS_SC() 0
1766
+ #define INSN_LABEL(lab) LABEL_branchif_##lab
1767
+ #define LABEL_IS_SC(lab) LABEL_##lab##_##t
1768
+ COLLECT_USAGE_INSN(BIN(branchif));
1769
+ COLLECT_USAGE_OPERAND(BIN(branchif), 0, dst);
1770
+ {
1771
+ #line 1197 "insns.def"
1772
+ if (RTEST(val)) {
1773
+ RUBY_VM_CHECK_INTS(th);
1774
+ JUMP(dst);
1775
+ }
1776
+
1777
+ #line 1778 "vm.inc"
1778
+ #undef CURRENT_INSN_branchif
1779
+ #undef INSN_IS_SC
1780
+ #undef INSN_LABEL
1781
+ #undef LABEL_IS_SC
1782
+ END_INSN(branchif);}}}
1783
+ INSN_ENTRY(branchunless){
1784
+ {
1785
+ OFFSET dst = (OFFSET)GET_OPERAND(1);
1786
+ VALUE val = TOPN(0);
1787
+ DEBUG_ENTER_INSN("branchunless");
1788
+ ADD_PC(1+1);
1789
+ PREFETCH(GET_PC());
1790
+ POPN(1);
1791
+ #define CURRENT_INSN_branchunless 1
1792
+ #define INSN_IS_SC() 0
1793
+ #define INSN_LABEL(lab) LABEL_branchunless_##lab
1794
+ #define LABEL_IS_SC(lab) LABEL_##lab##_##t
1795
+ COLLECT_USAGE_INSN(BIN(branchunless));
1796
+ COLLECT_USAGE_OPERAND(BIN(branchunless), 0, dst);
1797
+ {
1798
+ #line 1214 "insns.def"
1799
+ if (!RTEST(val)) {
1800
+ RUBY_VM_CHECK_INTS(th);
1801
+ JUMP(dst);
1802
+ }
1803
+
1804
+ #line 1805 "vm.inc"
1805
+ #undef CURRENT_INSN_branchunless
1806
+ #undef INSN_IS_SC
1807
+ #undef INSN_LABEL
1808
+ #undef LABEL_IS_SC
1809
+ END_INSN(branchunless);}}}
1810
+ INSN_ENTRY(branchnil){
1811
+ {
1812
+ OFFSET dst = (OFFSET)GET_OPERAND(1);
1813
+ VALUE val = TOPN(0);
1814
+ DEBUG_ENTER_INSN("branchnil");
1815
+ ADD_PC(1+1);
1816
+ PREFETCH(GET_PC());
1817
+ POPN(1);
1818
+ #define CURRENT_INSN_branchnil 1
1819
+ #define INSN_IS_SC() 0
1820
+ #define INSN_LABEL(lab) LABEL_branchnil_##lab
1821
+ #define LABEL_IS_SC(lab) LABEL_##lab##_##t
1822
+ COLLECT_USAGE_INSN(BIN(branchnil));
1823
+ COLLECT_USAGE_OPERAND(BIN(branchnil), 0, dst);
1824
+ {
1825
+ #line 1231 "insns.def"
1826
+ if (NIL_P(val)) {
1827
+ RUBY_VM_CHECK_INTS(th);
1828
+ JUMP(dst);
1829
+ }
1830
+
1831
+ #line 1832 "vm.inc"
1832
+ #undef CURRENT_INSN_branchnil
1833
+ #undef INSN_IS_SC
1834
+ #undef INSN_LABEL
1835
+ #undef LABEL_IS_SC
1836
+ END_INSN(branchnil);}}}
1837
+ INSN_ENTRY(getinlinecache){
1838
+ {
1839
+ VALUE val;
1840
+ IC ic = (IC)GET_OPERAND(2);
1841
+ OFFSET dst = (OFFSET)GET_OPERAND(1);
1842
+
1843
+ DEBUG_ENTER_INSN("getinlinecache");
1844
+ ADD_PC(1+2);
1845
+ PREFETCH(GET_PC());
1846
+ #define CURRENT_INSN_getinlinecache 1
1847
+ #define INSN_IS_SC() 0
1848
+ #define INSN_LABEL(lab) LABEL_getinlinecache_##lab
1849
+ #define LABEL_IS_SC(lab) LABEL_##lab##_##t
1850
+ COLLECT_USAGE_INSN(BIN(getinlinecache));
1851
+ COLLECT_USAGE_OPERAND(BIN(getinlinecache), 0, dst);
1852
+ COLLECT_USAGE_OPERAND(BIN(getinlinecache), 1, ic);
1853
+ {
1854
+ #line 1253 "insns.def"
1855
+ if (ic->ic_serial == GET_GLOBAL_CONSTANT_STATE() &&
1856
+ (ic->ic_cref == NULL || ic->ic_cref == rb_vm_get_cref(GET_EP()))) {
1857
+ val = ic->ic_value.value;
1858
+ JUMP(dst);
1859
+ }
1860
+ else {
1861
+ /* none */
1862
+ val = Qnil;
1863
+ }
1864
+
1865
+ #line 1866 "vm.inc"
1866
+ CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1);
1867
+ PUSH(val);
1868
+ #undef CURRENT_INSN_getinlinecache
1869
+ #undef INSN_IS_SC
1870
+ #undef INSN_LABEL
1871
+ #undef LABEL_IS_SC
1872
+ END_INSN(getinlinecache);}}}
1873
+ INSN_ENTRY(setinlinecache){
1874
+ {
1875
+ IC ic = (IC)GET_OPERAND(1);
1876
+ VALUE val = TOPN(0);
1877
+ DEBUG_ENTER_INSN("setinlinecache");
1878
+ ADD_PC(1+1);
1879
+ PREFETCH(GET_PC());
1880
+ POPN(1);
1881
+ #define CURRENT_INSN_setinlinecache 1
1882
+ #define INSN_IS_SC() 0
1883
+ #define INSN_LABEL(lab) LABEL_setinlinecache_##lab
1884
+ #define LABEL_IS_SC(lab) LABEL_##lab##_##t
1885
+ COLLECT_USAGE_INSN(BIN(setinlinecache));
1886
+ COLLECT_USAGE_OPERAND(BIN(setinlinecache), 0, ic);
1887
+ {
1888
+ #line 1275 "insns.def"
1889
+ VM_ASSERT(ic->ic_value.value != Qundef);
1890
+ ic->ic_value.value = val;
1891
+ ic->ic_serial = GET_GLOBAL_CONSTANT_STATE() - ruby_vm_const_missing_count;
1892
+ ic->ic_cref = vm_get_const_key_cref(GET_EP());
1893
+ ruby_vm_const_missing_count = 0;
1894
+
1895
+ #line 1896 "vm.inc"
1896
+ CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1);
1897
+ PUSH(val);
1898
+ #undef CURRENT_INSN_setinlinecache
1899
+ #undef INSN_IS_SC
1900
+ #undef INSN_LABEL
1901
+ #undef LABEL_IS_SC
1902
+ END_INSN(setinlinecache);}}}
1903
+ INSN_ENTRY(once){
1904
+ {
1905
+ VALUE val;
1906
+ IC ic = (IC)GET_OPERAND(2);
1907
+ ISEQ iseq = (ISEQ)GET_OPERAND(1);
1908
+
1909
+ DEBUG_ENTER_INSN("once");
1910
+ ADD_PC(1+2);
1911
+ PREFETCH(GET_PC());
1912
+ #define CURRENT_INSN_once 1
1913
+ #define INSN_IS_SC() 0
1914
+ #define INSN_LABEL(lab) LABEL_once_##lab
1915
+ #define LABEL_IS_SC(lab) LABEL_##lab##_##t
1916
+ COLLECT_USAGE_INSN(BIN(once));
1917
+ COLLECT_USAGE_OPERAND(BIN(once), 0, iseq);
1918
+ COLLECT_USAGE_OPERAND(BIN(once), 1, ic);
1919
+ {
1920
+ #line 1293 "insns.def"
1921
+ union iseq_inline_storage_entry *is = (union iseq_inline_storage_entry *)ic;
1922
+
1923
+ #define RUNNING_THREAD_ONCE_DONE ((rb_thread_t *)(0x1))
1924
+ retry:
1925
+ if (is->once.running_thread == RUNNING_THREAD_ONCE_DONE) {
1926
+ val = is->once.value;
1927
+ }
1928
+ else if (is->once.running_thread == NULL) {
1929
+ is->once.running_thread = th;
1930
+ val = is->once.value = rb_ensure(vm_once_exec, (VALUE)iseq, vm_once_clear, (VALUE)is);
1931
+ /* is->once.running_thread is cleared by vm_once_clear() */
1932
+ is->once.running_thread = RUNNING_THREAD_ONCE_DONE; /* success */
1933
+ rb_iseq_add_mark_object(GET_ISEQ(), val);
1934
+ }
1935
+ else if (is->once.running_thread == th) {
1936
+ /* recursive once */
1937
+ val = vm_once_exec((VALUE)iseq);
1938
+ }
1939
+ else {
1940
+ /* waiting for finish */
1941
+ RUBY_VM_CHECK_INTS(th);
1942
+ rb_thread_schedule();
1943
+ goto retry;
1944
+ }
1945
+
1946
+ #line 1947 "vm.inc"
1947
+ CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1);
1948
+ PUSH(val);
1949
+ #undef CURRENT_INSN_once
1950
+ #undef INSN_IS_SC
1951
+ #undef INSN_LABEL
1952
+ #undef LABEL_IS_SC
1953
+ END_INSN(once);}}}
1954
+ INSN_ENTRY(opt_case_dispatch){
1955
+ {
1956
+ OFFSET else_offset = (OFFSET)GET_OPERAND(2);
1957
+ CDHASH hash = (CDHASH)GET_OPERAND(1);
1958
+ VALUE key = TOPN(0);
1959
+ DEBUG_ENTER_INSN("opt_case_dispatch");
1960
+ ADD_PC(1+2);
1961
+ PREFETCH(GET_PC());
1962
+ POPN(1);
1963
+ #define CURRENT_INSN_opt_case_dispatch 1
1964
+ #define INSN_IS_SC() 0
1965
+ #define INSN_LABEL(lab) LABEL_opt_case_dispatch_##lab
1966
+ #define LABEL_IS_SC(lab) LABEL_##lab##_##t
1967
+ COLLECT_USAGE_INSN(BIN(opt_case_dispatch));
1968
+ COLLECT_USAGE_OPERAND(BIN(opt_case_dispatch), 0, hash);
1969
+ COLLECT_USAGE_OPERAND(BIN(opt_case_dispatch), 1, else_offset);
1970
+ {
1971
+ #line 1330 "insns.def"
1972
+ switch(TYPE(key)) {
1973
+ case T_FLOAT: {
1974
+ double ival;
1975
+ if (modf(RFLOAT_VALUE(key), &ival) == 0.0 && !isinf(ival)) {
1976
+ key = FIXABLE(ival) ? LONG2FIX((long)ival) : rb_dbl2big(ival);
1977
+ }
1978
+ }
1979
+ case T_TRUE: /* fall through */
1980
+ case T_FALSE:
1981
+ case T_NIL:
1982
+ case T_SYMBOL:
1983
+ case T_FIXNUM:
1984
+ case T_BIGNUM:
1985
+ case T_STRING:
1986
+ if (BASIC_OP_UNREDEFINED_P(BOP_EQQ,
1987
+ SYMBOL_REDEFINED_OP_FLAG |
1988
+ INTEGER_REDEFINED_OP_FLAG |
1989
+ FLOAT_REDEFINED_OP_FLAG |
1990
+ NIL_REDEFINED_OP_FLAG |
1991
+ TRUE_REDEFINED_OP_FLAG |
1992
+ FALSE_REDEFINED_OP_FLAG |
1993
+ STRING_REDEFINED_OP_FLAG)) {
1994
+ st_data_t val;
1995
+ if (st_lookup(RHASH_TBL_RAW(hash), key, &val)) {
1996
+ JUMP(FIX2INT((VALUE)val));
1997
+ }
1998
+ else {
1999
+ JUMP(else_offset);
2000
+ }
2001
+ break;
2002
+ }
2003
+ default:
2004
+ break;
2005
+ }
2006
+
2007
+ #line 2008 "vm.inc"
2008
+ #undef CURRENT_INSN_opt_case_dispatch
2009
+ #undef INSN_IS_SC
2010
+ #undef INSN_LABEL
2011
+ #undef LABEL_IS_SC
2012
+ END_INSN(opt_case_dispatch);}}}
2013
+ INSN_ENTRY(opt_plus){
2014
+ {
2015
+ VALUE val;
2016
+ CALL_CACHE cc = (CALL_CACHE)GET_OPERAND(2);
2017
+ CALL_INFO ci = (CALL_INFO)GET_OPERAND(1);
2018
+ VALUE recv = TOPN(1);
2019
+ VALUE obj = TOPN(0);
2020
+ DEBUG_ENTER_INSN("opt_plus");
2021
+ ADD_PC(1+2);
2022
+ PREFETCH(GET_PC());
2023
+ POPN(2);
2024
+ #define CURRENT_INSN_opt_plus 1
2025
+ #define INSN_IS_SC() 0
2026
+ #define INSN_LABEL(lab) LABEL_opt_plus_##lab
2027
+ #define LABEL_IS_SC(lab) LABEL_##lab##_##t
2028
+ COLLECT_USAGE_INSN(BIN(opt_plus));
2029
+ COLLECT_USAGE_OPERAND(BIN(opt_plus), 0, ci);
2030
+ COLLECT_USAGE_OPERAND(BIN(opt_plus), 1, cc);
2031
+ {
2032
+ #line 1379 "insns.def"
2033
+ if (FIXNUM_2_P(recv, obj) &&
2034
+ BASIC_OP_UNREDEFINED_P(BOP_PLUS,INTEGER_REDEFINED_OP_FLAG)) {
2035
+ /* fixnum + fixnum */
2036
+ #ifndef LONG_LONG_VALUE
2037
+ VALUE msb = (VALUE)1 << ((sizeof(VALUE) * CHAR_BIT) - 1);
2038
+ val = recv - 1 + obj;
2039
+ if ((~(recv ^ obj) & (recv ^ val)) & msb) {
2040
+ val = rb_int2big((SIGNED_VALUE)((val>>1) | (recv & msb)));
2041
+ }
2042
+ #else
2043
+ val = LONG2NUM(FIX2LONG(recv) + FIX2LONG(obj));
2044
+ #endif
2045
+ }
2046
+ else if (FLONUM_2_P(recv, obj) &&
2047
+ BASIC_OP_UNREDEFINED_P(BOP_PLUS, FLOAT_REDEFINED_OP_FLAG)) {
2048
+ val = DBL2NUM(RFLOAT_VALUE(recv) + RFLOAT_VALUE(obj));
2049
+ }
2050
+ else if (!SPECIAL_CONST_P(recv) && !SPECIAL_CONST_P(obj)) {
2051
+ if (RBASIC_CLASS(recv) == rb_cFloat && RBASIC_CLASS(obj) == rb_cFloat &&
2052
+ BASIC_OP_UNREDEFINED_P(BOP_PLUS, FLOAT_REDEFINED_OP_FLAG)) {
2053
+ val = DBL2NUM(RFLOAT_VALUE(recv) + RFLOAT_VALUE(obj));
2054
+ }
2055
+ else if (RBASIC_CLASS(recv) == rb_cString && RBASIC_CLASS(obj) == rb_cString &&
2056
+ BASIC_OP_UNREDEFINED_P(BOP_PLUS, STRING_REDEFINED_OP_FLAG)) {
2057
+ val = rb_str_plus(recv, obj);
2058
+ }
2059
+ else if (RBASIC_CLASS(recv) == rb_cArray &&
2060
+ BASIC_OP_UNREDEFINED_P(BOP_PLUS, ARRAY_REDEFINED_OP_FLAG)) {
2061
+ val = rb_ary_plus(recv, obj);
2062
+ }
2063
+ else {
2064
+ goto INSN_LABEL(normal_dispatch);
2065
+ }
2066
+ }
2067
+ else {
2068
+ INSN_LABEL(normal_dispatch):
2069
+ PUSH(recv);
2070
+ PUSH(obj);
2071
+ CALL_SIMPLE_METHOD(recv);
2072
+ }
2073
+
2074
+ #line 2075 "vm.inc"
2075
+ CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1);
2076
+ PUSH(val);
2077
+ #undef CURRENT_INSN_opt_plus
2078
+ #undef INSN_IS_SC
2079
+ #undef INSN_LABEL
2080
+ #undef LABEL_IS_SC
2081
+ END_INSN(opt_plus);}}}
2082
+ INSN_ENTRY(opt_minus){
2083
+ {
2084
+ VALUE val;
2085
+ CALL_CACHE cc = (CALL_CACHE)GET_OPERAND(2);
2086
+ CALL_INFO ci = (CALL_INFO)GET_OPERAND(1);
2087
+ VALUE recv = TOPN(1);
2088
+ VALUE obj = TOPN(0);
2089
+ DEBUG_ENTER_INSN("opt_minus");
2090
+ ADD_PC(1+2);
2091
+ PREFETCH(GET_PC());
2092
+ POPN(2);
2093
+ #define CURRENT_INSN_opt_minus 1
2094
+ #define INSN_IS_SC() 0
2095
+ #define INSN_LABEL(lab) LABEL_opt_minus_##lab
2096
+ #define LABEL_IS_SC(lab) LABEL_##lab##_##t
2097
+ COLLECT_USAGE_INSN(BIN(opt_minus));
2098
+ COLLECT_USAGE_OPERAND(BIN(opt_minus), 0, ci);
2099
+ COLLECT_USAGE_OPERAND(BIN(opt_minus), 1, cc);
2100
+ {
2101
+ #line 1432 "insns.def"
2102
+ if (FIXNUM_2_P(recv, obj) &&
2103
+ BASIC_OP_UNREDEFINED_P(BOP_MINUS, INTEGER_REDEFINED_OP_FLAG)) {
2104
+ long a, b, c;
2105
+
2106
+ a = FIX2LONG(recv);
2107
+ b = FIX2LONG(obj);
2108
+ c = a - b;
2109
+ val = LONG2NUM(c);
2110
+ }
2111
+ else if (FLONUM_2_P(recv, obj) &&
2112
+ BASIC_OP_UNREDEFINED_P(BOP_MINUS, FLOAT_REDEFINED_OP_FLAG)) {
2113
+ val = DBL2NUM(RFLOAT_VALUE(recv) - RFLOAT_VALUE(obj));
2114
+ }
2115
+ else if (!SPECIAL_CONST_P(recv) && !SPECIAL_CONST_P(obj)) {
2116
+ if (RBASIC_CLASS(recv) == rb_cFloat && RBASIC_CLASS(obj) == rb_cFloat &&
2117
+ BASIC_OP_UNREDEFINED_P(BOP_MINUS, FLOAT_REDEFINED_OP_FLAG)) {
2118
+ val = DBL2NUM(RFLOAT_VALUE(recv) - RFLOAT_VALUE(obj));
2119
+ }
2120
+ else {
2121
+ goto INSN_LABEL(normal_dispatch);
2122
+ }
2123
+ }
2124
+ else {
2125
+ /* other */
2126
+ INSN_LABEL(normal_dispatch):
2127
+ PUSH(recv);
2128
+ PUSH(obj);
2129
+ CALL_SIMPLE_METHOD(recv);
2130
+ }
2131
+
2132
+ #line 2133 "vm.inc"
2133
+ CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1);
2134
+ PUSH(val);
2135
+ #undef CURRENT_INSN_opt_minus
2136
+ #undef INSN_IS_SC
2137
+ #undef INSN_LABEL
2138
+ #undef LABEL_IS_SC
2139
+ END_INSN(opt_minus);}}}
2140
+ INSN_ENTRY(opt_mult){
2141
+ {
2142
+ VALUE val;
2143
+ CALL_CACHE cc = (CALL_CACHE)GET_OPERAND(2);
2144
+ CALL_INFO ci = (CALL_INFO)GET_OPERAND(1);
2145
+ VALUE recv = TOPN(1);
2146
+ VALUE obj = TOPN(0);
2147
+ DEBUG_ENTER_INSN("opt_mult");
2148
+ ADD_PC(1+2);
2149
+ PREFETCH(GET_PC());
2150
+ POPN(2);
2151
+ #define CURRENT_INSN_opt_mult 1
2152
+ #define INSN_IS_SC() 0
2153
+ #define INSN_LABEL(lab) LABEL_opt_mult_##lab
2154
+ #define LABEL_IS_SC(lab) LABEL_##lab##_##t
2155
+ COLLECT_USAGE_INSN(BIN(opt_mult));
2156
+ COLLECT_USAGE_OPERAND(BIN(opt_mult), 0, ci);
2157
+ COLLECT_USAGE_OPERAND(BIN(opt_mult), 1, cc);
2158
+ {
2159
+ #line 1474 "insns.def"
2160
+ if (FIXNUM_2_P(recv, obj) &&
2161
+ BASIC_OP_UNREDEFINED_P(BOP_MULT, INTEGER_REDEFINED_OP_FLAG)) {
2162
+ val = rb_fix_mul_fix(recv, obj);
2163
+ }
2164
+ else if (FLONUM_2_P(recv, obj) &&
2165
+ BASIC_OP_UNREDEFINED_P(BOP_MULT, FLOAT_REDEFINED_OP_FLAG)) {
2166
+ val = DBL2NUM(RFLOAT_VALUE(recv) * RFLOAT_VALUE(obj));
2167
+ }
2168
+ else if (!SPECIAL_CONST_P(recv) && !SPECIAL_CONST_P(obj)) {
2169
+ if (RBASIC_CLASS(recv) == rb_cFloat && RBASIC_CLASS(obj) == rb_cFloat &&
2170
+ BASIC_OP_UNREDEFINED_P(BOP_MULT, FLOAT_REDEFINED_OP_FLAG)) {
2171
+ val = DBL2NUM(RFLOAT_VALUE(recv) * RFLOAT_VALUE(obj));
2172
+ }
2173
+ else {
2174
+ goto INSN_LABEL(normal_dispatch);
2175
+ }
2176
+ }
2177
+ else {
2178
+ INSN_LABEL(normal_dispatch):
2179
+ PUSH(recv);
2180
+ PUSH(obj);
2181
+ CALL_SIMPLE_METHOD(recv);
2182
+ }
2183
+
2184
+ #line 2185 "vm.inc"
2185
+ CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1);
2186
+ PUSH(val);
2187
+ #undef CURRENT_INSN_opt_mult
2188
+ #undef INSN_IS_SC
2189
+ #undef INSN_LABEL
2190
+ #undef LABEL_IS_SC
2191
+ END_INSN(opt_mult);}}}
2192
+ INSN_ENTRY(opt_div){
2193
+ {
2194
+ VALUE val;
2195
+ CALL_CACHE cc = (CALL_CACHE)GET_OPERAND(2);
2196
+ CALL_INFO ci = (CALL_INFO)GET_OPERAND(1);
2197
+ VALUE recv = TOPN(1);
2198
+ VALUE obj = TOPN(0);
2199
+ DEBUG_ENTER_INSN("opt_div");
2200
+ ADD_PC(1+2);
2201
+ PREFETCH(GET_PC());
2202
+ POPN(2);
2203
+ #define CURRENT_INSN_opt_div 1
2204
+ #define INSN_IS_SC() 0
2205
+ #define INSN_LABEL(lab) LABEL_opt_div_##lab
2206
+ #define LABEL_IS_SC(lab) LABEL_##lab##_##t
2207
+ COLLECT_USAGE_INSN(BIN(opt_div));
2208
+ COLLECT_USAGE_OPERAND(BIN(opt_div), 0, ci);
2209
+ COLLECT_USAGE_OPERAND(BIN(opt_div), 1, cc);
2210
+ {
2211
+ #line 1510 "insns.def"
2212
+ if (FIXNUM_2_P(recv, obj) &&
2213
+ BASIC_OP_UNREDEFINED_P(BOP_DIV, INTEGER_REDEFINED_OP_FLAG)) {
2214
+ if (FIX2LONG(obj) == 0) goto INSN_LABEL(normal_dispatch);
2215
+ val = rb_fix_div_fix(recv, obj);
2216
+ }
2217
+ else if (FLONUM_2_P(recv, obj) &&
2218
+ BASIC_OP_UNREDEFINED_P(BOP_DIV, FLOAT_REDEFINED_OP_FLAG)) {
2219
+ val = DBL2NUM(RFLOAT_VALUE(recv) / RFLOAT_VALUE(obj));
2220
+ }
2221
+ else if (!SPECIAL_CONST_P(recv) && !SPECIAL_CONST_P(obj)) {
2222
+ if (RBASIC_CLASS(recv) == rb_cFloat && RBASIC_CLASS(obj) == rb_cFloat &&
2223
+ BASIC_OP_UNREDEFINED_P(BOP_DIV, FLOAT_REDEFINED_OP_FLAG)) {
2224
+ val = DBL2NUM(RFLOAT_VALUE(recv) / RFLOAT_VALUE(obj));
2225
+ }
2226
+ else {
2227
+ goto INSN_LABEL(normal_dispatch);
2228
+ }
2229
+ }
2230
+ else {
2231
+ INSN_LABEL(normal_dispatch):
2232
+ PUSH(recv);
2233
+ PUSH(obj);
2234
+ CALL_SIMPLE_METHOD(recv);
2235
+ }
2236
+
2237
+ #line 2238 "vm.inc"
2238
+ CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1);
2239
+ PUSH(val);
2240
+ #undef CURRENT_INSN_opt_div
2241
+ #undef INSN_IS_SC
2242
+ #undef INSN_LABEL
2243
+ #undef LABEL_IS_SC
2244
+ END_INSN(opt_div);}}}
2245
+ INSN_ENTRY(opt_mod){
2246
+ {
2247
+ VALUE val;
2248
+ CALL_CACHE cc = (CALL_CACHE)GET_OPERAND(2);
2249
+ CALL_INFO ci = (CALL_INFO)GET_OPERAND(1);
2250
+ VALUE recv = TOPN(1);
2251
+ VALUE obj = TOPN(0);
2252
+ DEBUG_ENTER_INSN("opt_mod");
2253
+ ADD_PC(1+2);
2254
+ PREFETCH(GET_PC());
2255
+ POPN(2);
2256
+ #define CURRENT_INSN_opt_mod 1
2257
+ #define INSN_IS_SC() 0
2258
+ #define INSN_LABEL(lab) LABEL_opt_mod_##lab
2259
+ #define LABEL_IS_SC(lab) LABEL_##lab##_##t
2260
+ COLLECT_USAGE_INSN(BIN(opt_mod));
2261
+ COLLECT_USAGE_OPERAND(BIN(opt_mod), 0, ci);
2262
+ COLLECT_USAGE_OPERAND(BIN(opt_mod), 1, cc);
2263
+ {
2264
+ #line 1547 "insns.def"
2265
+ if (FIXNUM_2_P(recv, obj) &&
2266
+ BASIC_OP_UNREDEFINED_P(BOP_MOD, INTEGER_REDEFINED_OP_FLAG )) {
2267
+ if (FIX2LONG(obj) == 0) goto INSN_LABEL(normal_dispatch);
2268
+ val = rb_fix_mod_fix(recv, obj);
2269
+ }
2270
+ else if (FLONUM_2_P(recv, obj) &&
2271
+ BASIC_OP_UNREDEFINED_P(BOP_MOD, FLOAT_REDEFINED_OP_FLAG)) {
2272
+ val = DBL2NUM(ruby_float_mod(RFLOAT_VALUE(recv), RFLOAT_VALUE(obj)));
2273
+ }
2274
+ else if (!SPECIAL_CONST_P(recv) && !SPECIAL_CONST_P(obj)) {
2275
+ if (RBASIC_CLASS(recv) == rb_cFloat && RBASIC_CLASS(obj) == rb_cFloat &&
2276
+ BASIC_OP_UNREDEFINED_P(BOP_MOD, FLOAT_REDEFINED_OP_FLAG)) {
2277
+ val = DBL2NUM(ruby_float_mod(RFLOAT_VALUE(recv), RFLOAT_VALUE(obj)));
2278
+ }
2279
+ else {
2280
+ goto INSN_LABEL(normal_dispatch);
2281
+ }
2282
+ }
2283
+ else {
2284
+ INSN_LABEL(normal_dispatch):
2285
+ PUSH(recv);
2286
+ PUSH(obj);
2287
+ CALL_SIMPLE_METHOD(recv);
2288
+ }
2289
+
2290
+ #line 2291 "vm.inc"
2291
+ CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1);
2292
+ PUSH(val);
2293
+ #undef CURRENT_INSN_opt_mod
2294
+ #undef INSN_IS_SC
2295
+ #undef INSN_LABEL
2296
+ #undef LABEL_IS_SC
2297
+ END_INSN(opt_mod);}}}
2298
+ INSN_ENTRY(opt_eq){
2299
+ {
2300
+ VALUE val;
2301
+ CALL_CACHE cc = (CALL_CACHE)GET_OPERAND(2);
2302
+ CALL_INFO ci = (CALL_INFO)GET_OPERAND(1);
2303
+ VALUE recv = TOPN(1);
2304
+ VALUE obj = TOPN(0);
2305
+ DEBUG_ENTER_INSN("opt_eq");
2306
+ ADD_PC(1+2);
2307
+ PREFETCH(GET_PC());
2308
+ POPN(2);
2309
+ #define CURRENT_INSN_opt_eq 1
2310
+ #define INSN_IS_SC() 0
2311
+ #define INSN_LABEL(lab) LABEL_opt_eq_##lab
2312
+ #define LABEL_IS_SC(lab) LABEL_##lab##_##t
2313
+ COLLECT_USAGE_INSN(BIN(opt_eq));
2314
+ COLLECT_USAGE_OPERAND(BIN(opt_eq), 0, ci);
2315
+ COLLECT_USAGE_OPERAND(BIN(opt_eq), 1, cc);
2316
+ {
2317
+ #line 1584 "insns.def"
2318
+ val = opt_eq_func(recv, obj, ci, cc);
2319
+
2320
+ if (val == Qundef) {
2321
+ /* other */
2322
+ PUSH(recv);
2323
+ PUSH(obj);
2324
+ CALL_SIMPLE_METHOD(recv);
2325
+ }
2326
+
2327
+ #line 2328 "vm.inc"
2328
+ CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1);
2329
+ PUSH(val);
2330
+ #undef CURRENT_INSN_opt_eq
2331
+ #undef INSN_IS_SC
2332
+ #undef INSN_LABEL
2333
+ #undef LABEL_IS_SC
2334
+ END_INSN(opt_eq);}}}
2335
+ INSN_ENTRY(opt_neq){
2336
+ {
2337
+ VALUE val;
2338
+ CALL_CACHE cc_eq = (CALL_CACHE)GET_OPERAND(4);
2339
+ CALL_INFO ci_eq = (CALL_INFO)GET_OPERAND(3);
2340
+ CALL_CACHE cc = (CALL_CACHE)GET_OPERAND(2);
2341
+ CALL_INFO ci = (CALL_INFO)GET_OPERAND(1);
2342
+ VALUE recv = TOPN(1);
2343
+ VALUE obj = TOPN(0);
2344
+ DEBUG_ENTER_INSN("opt_neq");
2345
+ ADD_PC(1+4);
2346
+ PREFETCH(GET_PC());
2347
+ POPN(2);
2348
+ #define CURRENT_INSN_opt_neq 1
2349
+ #define INSN_IS_SC() 0
2350
+ #define INSN_LABEL(lab) LABEL_opt_neq_##lab
2351
+ #define LABEL_IS_SC(lab) LABEL_##lab##_##t
2352
+ COLLECT_USAGE_INSN(BIN(opt_neq));
2353
+ COLLECT_USAGE_OPERAND(BIN(opt_neq), 0, ci);
2354
+ COLLECT_USAGE_OPERAND(BIN(opt_neq), 1, cc);
2355
+ COLLECT_USAGE_OPERAND(BIN(opt_neq), 2, ci_eq);
2356
+ COLLECT_USAGE_OPERAND(BIN(opt_neq), 3, cc_eq);
2357
+ {
2358
+ #line 1605 "insns.def"
2359
+ extern VALUE rb_obj_not_equal(VALUE obj1, VALUE obj2);
2360
+ vm_search_method(ci, cc, recv);
2361
+
2362
+ val = Qundef;
2363
+
2364
+ if (check_cfunc(cc->me, rb_obj_not_equal)) {
2365
+ val = opt_eq_func(recv, obj, ci_eq, cc_eq);
2366
+
2367
+ if (val != Qundef) {
2368
+ val = RTEST(val) ? Qfalse : Qtrue;
2369
+ }
2370
+ }
2371
+
2372
+ if (val == Qundef) {
2373
+ /* other */
2374
+ PUSH(recv);
2375
+ PUSH(obj);
2376
+ CALL_SIMPLE_METHOD(recv);
2377
+ }
2378
+
2379
+ #line 2380 "vm.inc"
2380
+ CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1);
2381
+ PUSH(val);
2382
+ #undef CURRENT_INSN_opt_neq
2383
+ #undef INSN_IS_SC
2384
+ #undef INSN_LABEL
2385
+ #undef LABEL_IS_SC
2386
+ END_INSN(opt_neq);}}}
2387
+ INSN_ENTRY(opt_lt){
2388
+ {
2389
+ VALUE val;
2390
+ CALL_CACHE cc = (CALL_CACHE)GET_OPERAND(2);
2391
+ CALL_INFO ci = (CALL_INFO)GET_OPERAND(1);
2392
+ VALUE recv = TOPN(1);
2393
+ VALUE obj = TOPN(0);
2394
+ DEBUG_ENTER_INSN("opt_lt");
2395
+ ADD_PC(1+2);
2396
+ PREFETCH(GET_PC());
2397
+ POPN(2);
2398
+ #define CURRENT_INSN_opt_lt 1
2399
+ #define INSN_IS_SC() 0
2400
+ #define INSN_LABEL(lab) LABEL_opt_lt_##lab
2401
+ #define LABEL_IS_SC(lab) LABEL_##lab##_##t
2402
+ COLLECT_USAGE_INSN(BIN(opt_lt));
2403
+ COLLECT_USAGE_OPERAND(BIN(opt_lt), 0, ci);
2404
+ COLLECT_USAGE_OPERAND(BIN(opt_lt), 1, cc);
2405
+ {
2406
+ #line 1637 "insns.def"
2407
+ if (FIXNUM_2_P(recv, obj) &&
2408
+ BASIC_OP_UNREDEFINED_P(BOP_LT, INTEGER_REDEFINED_OP_FLAG)) {
2409
+ SIGNED_VALUE a = recv, b = obj;
2410
+
2411
+ if (a < b) {
2412
+ val = Qtrue;
2413
+ }
2414
+ else {
2415
+ val = Qfalse;
2416
+ }
2417
+ }
2418
+ else if (FLONUM_2_P(recv, obj) &&
2419
+ BASIC_OP_UNREDEFINED_P(BOP_LT, FLOAT_REDEFINED_OP_FLAG)) {
2420
+ /* flonum is not NaN */
2421
+ val = RFLOAT_VALUE(recv) < RFLOAT_VALUE(obj) ? Qtrue : Qfalse;
2422
+ }
2423
+ else if (!SPECIAL_CONST_P(recv) && !SPECIAL_CONST_P(obj)) {
2424
+ if (RBASIC_CLASS(recv) == rb_cFloat && RBASIC_CLASS(obj) == rb_cFloat &&
2425
+ BASIC_OP_UNREDEFINED_P(BOP_LT, FLOAT_REDEFINED_OP_FLAG)) {
2426
+ val = double_cmp_lt(RFLOAT_VALUE(recv), RFLOAT_VALUE(obj));
2427
+ }
2428
+ else {
2429
+ goto INSN_LABEL(normal_dispatch);
2430
+ }
2431
+ }
2432
+ else {
2433
+ INSN_LABEL(normal_dispatch):
2434
+ PUSH(recv);
2435
+ PUSH(obj);
2436
+ CALL_SIMPLE_METHOD(recv);
2437
+ }
2438
+
2439
+ #line 2440 "vm.inc"
2440
+ CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1);
2441
+ PUSH(val);
2442
+ #undef CURRENT_INSN_opt_lt
2443
+ #undef INSN_IS_SC
2444
+ #undef INSN_LABEL
2445
+ #undef LABEL_IS_SC
2446
+ END_INSN(opt_lt);}}}
2447
+ INSN_ENTRY(opt_le){
2448
+ {
2449
+ VALUE val;
2450
+ CALL_CACHE cc = (CALL_CACHE)GET_OPERAND(2);
2451
+ CALL_INFO ci = (CALL_INFO)GET_OPERAND(1);
2452
+ VALUE recv = TOPN(1);
2453
+ VALUE obj = TOPN(0);
2454
+ DEBUG_ENTER_INSN("opt_le");
2455
+ ADD_PC(1+2);
2456
+ PREFETCH(GET_PC());
2457
+ POPN(2);
2458
+ #define CURRENT_INSN_opt_le 1
2459
+ #define INSN_IS_SC() 0
2460
+ #define INSN_LABEL(lab) LABEL_opt_le_##lab
2461
+ #define LABEL_IS_SC(lab) LABEL_##lab##_##t
2462
+ COLLECT_USAGE_INSN(BIN(opt_le));
2463
+ COLLECT_USAGE_OPERAND(BIN(opt_le), 0, ci);
2464
+ COLLECT_USAGE_OPERAND(BIN(opt_le), 1, cc);
2465
+ {
2466
+ #line 1681 "insns.def"
2467
+ if (FIXNUM_2_P(recv, obj) &&
2468
+ BASIC_OP_UNREDEFINED_P(BOP_LE, INTEGER_REDEFINED_OP_FLAG)) {
2469
+ SIGNED_VALUE a = recv, b = obj;
2470
+
2471
+ if (a <= b) {
2472
+ val = Qtrue;
2473
+ }
2474
+ else {
2475
+ val = Qfalse;
2476
+ }
2477
+ }
2478
+ else if (FLONUM_2_P(recv, obj) &&
2479
+ BASIC_OP_UNREDEFINED_P(BOP_LE, FLOAT_REDEFINED_OP_FLAG)) {
2480
+ /* flonum is not NaN */
2481
+ val = RFLOAT_VALUE(recv) <= RFLOAT_VALUE(obj) ? Qtrue : Qfalse;
2482
+ }
2483
+ else {
2484
+ /* other */
2485
+ PUSH(recv);
2486
+ PUSH(obj);
2487
+ CALL_SIMPLE_METHOD(recv);
2488
+ }
2489
+
2490
+ #line 2491 "vm.inc"
2491
+ CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1);
2492
+ PUSH(val);
2493
+ #undef CURRENT_INSN_opt_le
2494
+ #undef INSN_IS_SC
2495
+ #undef INSN_LABEL
2496
+ #undef LABEL_IS_SC
2497
+ END_INSN(opt_le);}}}
2498
+ INSN_ENTRY(opt_gt){
2499
+ {
2500
+ VALUE val;
2501
+ CALL_CACHE cc = (CALL_CACHE)GET_OPERAND(2);
2502
+ CALL_INFO ci = (CALL_INFO)GET_OPERAND(1);
2503
+ VALUE recv = TOPN(1);
2504
+ VALUE obj = TOPN(0);
2505
+ DEBUG_ENTER_INSN("opt_gt");
2506
+ ADD_PC(1+2);
2507
+ PREFETCH(GET_PC());
2508
+ POPN(2);
2509
+ #define CURRENT_INSN_opt_gt 1
2510
+ #define INSN_IS_SC() 0
2511
+ #define INSN_LABEL(lab) LABEL_opt_gt_##lab
2512
+ #define LABEL_IS_SC(lab) LABEL_##lab##_##t
2513
+ COLLECT_USAGE_INSN(BIN(opt_gt));
2514
+ COLLECT_USAGE_OPERAND(BIN(opt_gt), 0, ci);
2515
+ COLLECT_USAGE_OPERAND(BIN(opt_gt), 1, cc);
2516
+ {
2517
+ #line 1716 "insns.def"
2518
+ if (FIXNUM_2_P(recv, obj) &&
2519
+ BASIC_OP_UNREDEFINED_P(BOP_GT, INTEGER_REDEFINED_OP_FLAG)) {
2520
+ SIGNED_VALUE a = recv, b = obj;
2521
+
2522
+ if (a > b) {
2523
+ val = Qtrue;
2524
+ }
2525
+ else {
2526
+ val = Qfalse;
2527
+ }
2528
+ }
2529
+ else if (FLONUM_2_P(recv, obj) &&
2530
+ BASIC_OP_UNREDEFINED_P(BOP_GT, FLOAT_REDEFINED_OP_FLAG)) {
2531
+ /* flonum is not NaN */
2532
+ val = RFLOAT_VALUE(recv) > RFLOAT_VALUE(obj) ? Qtrue : Qfalse;
2533
+ }
2534
+ else if (!SPECIAL_CONST_P(recv) && !SPECIAL_CONST_P(obj)) {
2535
+ if (RBASIC_CLASS(recv) == rb_cFloat && RBASIC_CLASS(obj) == rb_cFloat &&
2536
+ BASIC_OP_UNREDEFINED_P(BOP_GT, FLOAT_REDEFINED_OP_FLAG)) {
2537
+ val = double_cmp_gt(RFLOAT_VALUE(recv), RFLOAT_VALUE(obj));
2538
+ }
2539
+ else {
2540
+ goto INSN_LABEL(normal_dispatch);
2541
+ }
2542
+ }
2543
+ else {
2544
+ INSN_LABEL(normal_dispatch):
2545
+ PUSH(recv);
2546
+ PUSH(obj);
2547
+ CALL_SIMPLE_METHOD(recv);
2548
+ }
2549
+
2550
+ #line 2551 "vm.inc"
2551
+ CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1);
2552
+ PUSH(val);
2553
+ #undef CURRENT_INSN_opt_gt
2554
+ #undef INSN_IS_SC
2555
+ #undef INSN_LABEL
2556
+ #undef LABEL_IS_SC
2557
+ END_INSN(opt_gt);}}}
2558
+ INSN_ENTRY(opt_ge){
2559
+ {
2560
+ VALUE val;
2561
+ CALL_CACHE cc = (CALL_CACHE)GET_OPERAND(2);
2562
+ CALL_INFO ci = (CALL_INFO)GET_OPERAND(1);
2563
+ VALUE recv = TOPN(1);
2564
+ VALUE obj = TOPN(0);
2565
+ DEBUG_ENTER_INSN("opt_ge");
2566
+ ADD_PC(1+2);
2567
+ PREFETCH(GET_PC());
2568
+ POPN(2);
2569
+ #define CURRENT_INSN_opt_ge 1
2570
+ #define INSN_IS_SC() 0
2571
+ #define INSN_LABEL(lab) LABEL_opt_ge_##lab
2572
+ #define LABEL_IS_SC(lab) LABEL_##lab##_##t
2573
+ COLLECT_USAGE_INSN(BIN(opt_ge));
2574
+ COLLECT_USAGE_OPERAND(BIN(opt_ge), 0, ci);
2575
+ COLLECT_USAGE_OPERAND(BIN(opt_ge), 1, cc);
2576
+ {
2577
+ #line 1760 "insns.def"
2578
+ if (FIXNUM_2_P(recv, obj) &&
2579
+ BASIC_OP_UNREDEFINED_P(BOP_GE, INTEGER_REDEFINED_OP_FLAG)) {
2580
+ SIGNED_VALUE a = recv, b = obj;
2581
+
2582
+ if (a >= b) {
2583
+ val = Qtrue;
2584
+ }
2585
+ else {
2586
+ val = Qfalse;
2587
+ }
2588
+ }
2589
+ else if (FLONUM_2_P(recv, obj) &&
2590
+ BASIC_OP_UNREDEFINED_P(BOP_GE, FLOAT_REDEFINED_OP_FLAG)) {
2591
+ /* flonum is not NaN */
2592
+ val = RFLOAT_VALUE(recv) >= RFLOAT_VALUE(obj) ? Qtrue : Qfalse;
2593
+ }
2594
+ else {
2595
+ PUSH(recv);
2596
+ PUSH(obj);
2597
+ CALL_SIMPLE_METHOD(recv);
2598
+ }
2599
+
2600
+ #line 2601 "vm.inc"
2601
+ CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1);
2602
+ PUSH(val);
2603
+ #undef CURRENT_INSN_opt_ge
2604
+ #undef INSN_IS_SC
2605
+ #undef INSN_LABEL
2606
+ #undef LABEL_IS_SC
2607
+ END_INSN(opt_ge);}}}
2608
+ INSN_ENTRY(opt_ltlt){
2609
+ {
2610
+ VALUE val;
2611
+ CALL_CACHE cc = (CALL_CACHE)GET_OPERAND(2);
2612
+ CALL_INFO ci = (CALL_INFO)GET_OPERAND(1);
2613
+ VALUE recv = TOPN(1);
2614
+ VALUE obj = TOPN(0);
2615
+ DEBUG_ENTER_INSN("opt_ltlt");
2616
+ ADD_PC(1+2);
2617
+ PREFETCH(GET_PC());
2618
+ POPN(2);
2619
+ #define CURRENT_INSN_opt_ltlt 1
2620
+ #define INSN_IS_SC() 0
2621
+ #define INSN_LABEL(lab) LABEL_opt_ltlt_##lab
2622
+ #define LABEL_IS_SC(lab) LABEL_##lab##_##t
2623
+ COLLECT_USAGE_INSN(BIN(opt_ltlt));
2624
+ COLLECT_USAGE_OPERAND(BIN(opt_ltlt), 0, ci);
2625
+ COLLECT_USAGE_OPERAND(BIN(opt_ltlt), 1, cc);
2626
+ {
2627
+ #line 1794 "insns.def"
2628
+ if (!SPECIAL_CONST_P(recv)) {
2629
+ if (RBASIC_CLASS(recv) == rb_cString &&
2630
+ BASIC_OP_UNREDEFINED_P(BOP_LTLT, STRING_REDEFINED_OP_FLAG)) {
2631
+ val = rb_str_concat(recv, obj);
2632
+ }
2633
+ else if (RBASIC_CLASS(recv) == rb_cArray &&
2634
+ BASIC_OP_UNREDEFINED_P(BOP_LTLT, ARRAY_REDEFINED_OP_FLAG)) {
2635
+ val = rb_ary_push(recv, obj);
2636
+ }
2637
+ else {
2638
+ goto INSN_LABEL(normal_dispatch);
2639
+ }
2640
+ }
2641
+ else {
2642
+ INSN_LABEL(normal_dispatch):
2643
+ PUSH(recv);
2644
+ PUSH(obj);
2645
+ CALL_SIMPLE_METHOD(recv);
2646
+ }
2647
+
2648
+ #line 2649 "vm.inc"
2649
+ CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1);
2650
+ PUSH(val);
2651
+ #undef CURRENT_INSN_opt_ltlt
2652
+ #undef INSN_IS_SC
2653
+ #undef INSN_LABEL
2654
+ #undef LABEL_IS_SC
2655
+ END_INSN(opt_ltlt);}}}
2656
+ INSN_ENTRY(opt_aref){
2657
+ {
2658
+ VALUE val;
2659
+ CALL_CACHE cc = (CALL_CACHE)GET_OPERAND(2);
2660
+ CALL_INFO ci = (CALL_INFO)GET_OPERAND(1);
2661
+ VALUE recv = TOPN(1);
2662
+ VALUE obj = TOPN(0);
2663
+ DEBUG_ENTER_INSN("opt_aref");
2664
+ ADD_PC(1+2);
2665
+ PREFETCH(GET_PC());
2666
+ POPN(2);
2667
+ #define CURRENT_INSN_opt_aref 1
2668
+ #define INSN_IS_SC() 0
2669
+ #define INSN_LABEL(lab) LABEL_opt_aref_##lab
2670
+ #define LABEL_IS_SC(lab) LABEL_##lab##_##t
2671
+ COLLECT_USAGE_INSN(BIN(opt_aref));
2672
+ COLLECT_USAGE_OPERAND(BIN(opt_aref), 0, ci);
2673
+ COLLECT_USAGE_OPERAND(BIN(opt_aref), 1, cc);
2674
+ {
2675
+ #line 1826 "insns.def"
2676
+ if (!SPECIAL_CONST_P(recv)) {
2677
+ if (RBASIC_CLASS(recv) == rb_cArray && BASIC_OP_UNREDEFINED_P(BOP_AREF, ARRAY_REDEFINED_OP_FLAG) && FIXNUM_P(obj)) {
2678
+ val = rb_ary_entry(recv, FIX2LONG(obj));
2679
+ }
2680
+ else if (RBASIC_CLASS(recv) == rb_cHash && BASIC_OP_UNREDEFINED_P(BOP_AREF, HASH_REDEFINED_OP_FLAG)) {
2681
+ val = rb_hash_aref(recv, obj);
2682
+ }
2683
+ else {
2684
+ goto INSN_LABEL(normal_dispatch);
2685
+ }
2686
+ }
2687
+ else {
2688
+ INSN_LABEL(normal_dispatch):
2689
+ PUSH(recv);
2690
+ PUSH(obj);
2691
+ CALL_SIMPLE_METHOD(recv);
2692
+ }
2693
+
2694
+ #line 2695 "vm.inc"
2695
+ CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1);
2696
+ PUSH(val);
2697
+ #undef CURRENT_INSN_opt_aref
2698
+ #undef INSN_IS_SC
2699
+ #undef INSN_LABEL
2700
+ #undef LABEL_IS_SC
2701
+ END_INSN(opt_aref);}}}
2702
+ INSN_ENTRY(opt_aset){
2703
+ {
2704
+ VALUE val;
2705
+ CALL_CACHE cc = (CALL_CACHE)GET_OPERAND(2);
2706
+ CALL_INFO ci = (CALL_INFO)GET_OPERAND(1);
2707
+ VALUE recv = TOPN(2);
2708
+ VALUE obj = TOPN(1);
2709
+ VALUE set = TOPN(0);
2710
+ DEBUG_ENTER_INSN("opt_aset");
2711
+ ADD_PC(1+2);
2712
+ PREFETCH(GET_PC());
2713
+ POPN(3);
2714
+ #define CURRENT_INSN_opt_aset 1
2715
+ #define INSN_IS_SC() 0
2716
+ #define INSN_LABEL(lab) LABEL_opt_aset_##lab
2717
+ #define LABEL_IS_SC(lab) LABEL_##lab##_##t
2718
+ COLLECT_USAGE_INSN(BIN(opt_aset));
2719
+ COLLECT_USAGE_OPERAND(BIN(opt_aset), 0, ci);
2720
+ COLLECT_USAGE_OPERAND(BIN(opt_aset), 1, cc);
2721
+ {
2722
+ #line 1856 "insns.def"
2723
+ if (!SPECIAL_CONST_P(recv)) {
2724
+ if (RBASIC_CLASS(recv) == rb_cArray && BASIC_OP_UNREDEFINED_P(BOP_ASET, ARRAY_REDEFINED_OP_FLAG) && FIXNUM_P(obj)) {
2725
+ rb_ary_store(recv, FIX2LONG(obj), set);
2726
+ val = set;
2727
+ }
2728
+ else if (RBASIC_CLASS(recv) == rb_cHash && BASIC_OP_UNREDEFINED_P(BOP_ASET, HASH_REDEFINED_OP_FLAG)) {
2729
+ rb_hash_aset(recv, obj, set);
2730
+ val = set;
2731
+ }
2732
+ else {
2733
+ goto INSN_LABEL(normal_dispatch);
2734
+ }
2735
+ }
2736
+ else {
2737
+ INSN_LABEL(normal_dispatch):
2738
+ PUSH(recv);
2739
+ PUSH(obj);
2740
+ PUSH(set);
2741
+ CALL_SIMPLE_METHOD(recv);
2742
+ }
2743
+
2744
+ #line 2745 "vm.inc"
2745
+ CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1);
2746
+ PUSH(val);
2747
+ #undef CURRENT_INSN_opt_aset
2748
+ #undef INSN_IS_SC
2749
+ #undef INSN_LABEL
2750
+ #undef LABEL_IS_SC
2751
+ END_INSN(opt_aset);}}}
2752
+ INSN_ENTRY(opt_aset_with){
2753
+ {
2754
+ VALUE key = (VALUE)GET_OPERAND(3);
2755
+ CALL_CACHE cc = (CALL_CACHE)GET_OPERAND(2);
2756
+ CALL_INFO ci = (CALL_INFO)GET_OPERAND(1);
2757
+ VALUE recv = TOPN(1);
2758
+ VALUE val = TOPN(0);
2759
+ DEBUG_ENTER_INSN("opt_aset_with");
2760
+ ADD_PC(1+3);
2761
+ PREFETCH(GET_PC());
2762
+ POPN(2);
2763
+ #define CURRENT_INSN_opt_aset_with 1
2764
+ #define INSN_IS_SC() 0
2765
+ #define INSN_LABEL(lab) LABEL_opt_aset_with_##lab
2766
+ #define LABEL_IS_SC(lab) LABEL_##lab##_##t
2767
+ COLLECT_USAGE_INSN(BIN(opt_aset_with));
2768
+ COLLECT_USAGE_OPERAND(BIN(opt_aset_with), 0, ci);
2769
+ COLLECT_USAGE_OPERAND(BIN(opt_aset_with), 1, cc);
2770
+ COLLECT_USAGE_OPERAND(BIN(opt_aset_with), 2, key);
2771
+ {
2772
+ #line 1889 "insns.def"
2773
+ if (!SPECIAL_CONST_P(recv) && RBASIC_CLASS(recv) == rb_cHash && BASIC_OP_UNREDEFINED_P(BOP_ASET, HASH_REDEFINED_OP_FLAG)) {
2774
+ rb_hash_aset(recv, key, val);
2775
+ }
2776
+ else {
2777
+ PUSH(recv);
2778
+ PUSH(rb_str_resurrect(key));
2779
+ PUSH(val);
2780
+ CALL_SIMPLE_METHOD(recv);
2781
+ }
2782
+
2783
+ #line 2784 "vm.inc"
2784
+ CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1);
2785
+ PUSH(val);
2786
+ #undef CURRENT_INSN_opt_aset_with
2787
+ #undef INSN_IS_SC
2788
+ #undef INSN_LABEL
2789
+ #undef LABEL_IS_SC
2790
+ END_INSN(opt_aset_with);}}}
2791
+ INSN_ENTRY(opt_aref_with){
2792
+ {
2793
+ VALUE val;
2794
+ VALUE key = (VALUE)GET_OPERAND(3);
2795
+ CALL_CACHE cc = (CALL_CACHE)GET_OPERAND(2);
2796
+ CALL_INFO ci = (CALL_INFO)GET_OPERAND(1);
2797
+ VALUE recv = TOPN(0);
2798
+ DEBUG_ENTER_INSN("opt_aref_with");
2799
+ ADD_PC(1+3);
2800
+ PREFETCH(GET_PC());
2801
+ POPN(1);
2802
+ #define CURRENT_INSN_opt_aref_with 1
2803
+ #define INSN_IS_SC() 0
2804
+ #define INSN_LABEL(lab) LABEL_opt_aref_with_##lab
2805
+ #define LABEL_IS_SC(lab) LABEL_##lab##_##t
2806
+ COLLECT_USAGE_INSN(BIN(opt_aref_with));
2807
+ COLLECT_USAGE_OPERAND(BIN(opt_aref_with), 0, ci);
2808
+ COLLECT_USAGE_OPERAND(BIN(opt_aref_with), 1, cc);
2809
+ COLLECT_USAGE_OPERAND(BIN(opt_aref_with), 2, key);
2810
+ {
2811
+ #line 1911 "insns.def"
2812
+ if (!SPECIAL_CONST_P(recv) && RBASIC_CLASS(recv) == rb_cHash && BASIC_OP_UNREDEFINED_P(BOP_AREF, HASH_REDEFINED_OP_FLAG)) {
2813
+ val = rb_hash_aref(recv, key);
2814
+ }
2815
+ else {
2816
+ PUSH(recv);
2817
+ PUSH(rb_str_resurrect(key));
2818
+ CALL_SIMPLE_METHOD(recv);
2819
+ }
2820
+
2821
+ #line 2822 "vm.inc"
2822
+ CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1);
2823
+ PUSH(val);
2824
+ #undef CURRENT_INSN_opt_aref_with
2825
+ #undef INSN_IS_SC
2826
+ #undef INSN_LABEL
2827
+ #undef LABEL_IS_SC
2828
+ END_INSN(opt_aref_with);}}}
2829
+ INSN_ENTRY(opt_length){
2830
+ {
2831
+ VALUE val;
2832
+ CALL_CACHE cc = (CALL_CACHE)GET_OPERAND(2);
2833
+ CALL_INFO ci = (CALL_INFO)GET_OPERAND(1);
2834
+ VALUE recv = TOPN(0);
2835
+ DEBUG_ENTER_INSN("opt_length");
2836
+ ADD_PC(1+2);
2837
+ PREFETCH(GET_PC());
2838
+ POPN(1);
2839
+ #define CURRENT_INSN_opt_length 1
2840
+ #define INSN_IS_SC() 0
2841
+ #define INSN_LABEL(lab) LABEL_opt_length_##lab
2842
+ #define LABEL_IS_SC(lab) LABEL_##lab##_##t
2843
+ COLLECT_USAGE_INSN(BIN(opt_length));
2844
+ COLLECT_USAGE_OPERAND(BIN(opt_length), 0, ci);
2845
+ COLLECT_USAGE_OPERAND(BIN(opt_length), 1, cc);
2846
+ {
2847
+ #line 1932 "insns.def"
2848
+ if (!SPECIAL_CONST_P(recv)) {
2849
+ if (RBASIC_CLASS(recv) == rb_cString &&
2850
+ BASIC_OP_UNREDEFINED_P(BOP_LENGTH, STRING_REDEFINED_OP_FLAG)) {
2851
+ val = rb_str_length(recv);
2852
+ }
2853
+ else if (RBASIC_CLASS(recv) == rb_cArray &&
2854
+ BASIC_OP_UNREDEFINED_P(BOP_LENGTH, ARRAY_REDEFINED_OP_FLAG)) {
2855
+ val = LONG2NUM(RARRAY_LEN(recv));
2856
+ }
2857
+ else if (RBASIC_CLASS(recv) == rb_cHash &&
2858
+ BASIC_OP_UNREDEFINED_P(BOP_LENGTH, HASH_REDEFINED_OP_FLAG)) {
2859
+ val = INT2FIX(RHASH_SIZE(recv));
2860
+ }
2861
+ else {
2862
+ goto INSN_LABEL(normal_dispatch);
2863
+ }
2864
+ }
2865
+ else {
2866
+ INSN_LABEL(normal_dispatch):
2867
+ PUSH(recv);
2868
+ CALL_SIMPLE_METHOD(recv);
2869
+ }
2870
+
2871
+ #line 2872 "vm.inc"
2872
+ CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1);
2873
+ PUSH(val);
2874
+ #undef CURRENT_INSN_opt_length
2875
+ #undef INSN_IS_SC
2876
+ #undef INSN_LABEL
2877
+ #undef LABEL_IS_SC
2878
+ END_INSN(opt_length);}}}
2879
+ INSN_ENTRY(opt_size){
2880
+ {
2881
+ VALUE val;
2882
+ CALL_CACHE cc = (CALL_CACHE)GET_OPERAND(2);
2883
+ CALL_INFO ci = (CALL_INFO)GET_OPERAND(1);
2884
+ VALUE recv = TOPN(0);
2885
+ DEBUG_ENTER_INSN("opt_size");
2886
+ ADD_PC(1+2);
2887
+ PREFETCH(GET_PC());
2888
+ POPN(1);
2889
+ #define CURRENT_INSN_opt_size 1
2890
+ #define INSN_IS_SC() 0
2891
+ #define INSN_LABEL(lab) LABEL_opt_size_##lab
2892
+ #define LABEL_IS_SC(lab) LABEL_##lab##_##t
2893
+ COLLECT_USAGE_INSN(BIN(opt_size));
2894
+ COLLECT_USAGE_OPERAND(BIN(opt_size), 0, ci);
2895
+ COLLECT_USAGE_OPERAND(BIN(opt_size), 1, cc);
2896
+ {
2897
+ #line 1967 "insns.def"
2898
+ if (!SPECIAL_CONST_P(recv)) {
2899
+ if (RBASIC_CLASS(recv) == rb_cString &&
2900
+ BASIC_OP_UNREDEFINED_P(BOP_SIZE, STRING_REDEFINED_OP_FLAG)) {
2901
+ val = rb_str_length(recv);
2902
+ }
2903
+ else if (RBASIC_CLASS(recv) == rb_cArray &&
2904
+ BASIC_OP_UNREDEFINED_P(BOP_SIZE, ARRAY_REDEFINED_OP_FLAG)) {
2905
+ val = LONG2NUM(RARRAY_LEN(recv));
2906
+ }
2907
+ else if (RBASIC_CLASS(recv) == rb_cHash &&
2908
+ BASIC_OP_UNREDEFINED_P(BOP_SIZE, HASH_REDEFINED_OP_FLAG)) {
2909
+ val = INT2FIX(RHASH_SIZE(recv));
2910
+ }
2911
+ else {
2912
+ goto INSN_LABEL(normal_dispatch);
2913
+ }
2914
+ }
2915
+ else {
2916
+ INSN_LABEL(normal_dispatch):
2917
+ PUSH(recv);
2918
+ CALL_SIMPLE_METHOD(recv);
2919
+ }
2920
+
2921
+ #line 2922 "vm.inc"
2922
+ CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1);
2923
+ PUSH(val);
2924
+ #undef CURRENT_INSN_opt_size
2925
+ #undef INSN_IS_SC
2926
+ #undef INSN_LABEL
2927
+ #undef LABEL_IS_SC
2928
+ END_INSN(opt_size);}}}
2929
+ INSN_ENTRY(opt_empty_p){
2930
+ {
2931
+ VALUE val;
2932
+ CALL_CACHE cc = (CALL_CACHE)GET_OPERAND(2);
2933
+ CALL_INFO ci = (CALL_INFO)GET_OPERAND(1);
2934
+ VALUE recv = TOPN(0);
2935
+ DEBUG_ENTER_INSN("opt_empty_p");
2936
+ ADD_PC(1+2);
2937
+ PREFETCH(GET_PC());
2938
+ POPN(1);
2939
+ #define CURRENT_INSN_opt_empty_p 1
2940
+ #define INSN_IS_SC() 0
2941
+ #define INSN_LABEL(lab) LABEL_opt_empty_p_##lab
2942
+ #define LABEL_IS_SC(lab) LABEL_##lab##_##t
2943
+ COLLECT_USAGE_INSN(BIN(opt_empty_p));
2944
+ COLLECT_USAGE_OPERAND(BIN(opt_empty_p), 0, ci);
2945
+ COLLECT_USAGE_OPERAND(BIN(opt_empty_p), 1, cc);
2946
+ {
2947
+ #line 2002 "insns.def"
2948
+ if (!SPECIAL_CONST_P(recv)) {
2949
+ if (RBASIC_CLASS(recv) == rb_cString &&
2950
+ BASIC_OP_UNREDEFINED_P(BOP_EMPTY_P, STRING_REDEFINED_OP_FLAG)) {
2951
+ if (RSTRING_LEN(recv) == 0) val = Qtrue;
2952
+ else val = Qfalse;
2953
+ }
2954
+ else if (RBASIC_CLASS(recv) == rb_cArray &&
2955
+ BASIC_OP_UNREDEFINED_P(BOP_EMPTY_P, ARRAY_REDEFINED_OP_FLAG)) {
2956
+ if (RARRAY_LEN(recv) == 0) val = Qtrue;
2957
+ else val = Qfalse;
2958
+ }
2959
+ else if (RBASIC_CLASS(recv) == rb_cHash &&
2960
+ BASIC_OP_UNREDEFINED_P(BOP_EMPTY_P, HASH_REDEFINED_OP_FLAG)) {
2961
+ if (RHASH_EMPTY_P(recv)) val = Qtrue;
2962
+ else val = Qfalse;
2963
+ }
2964
+ else {
2965
+ goto INSN_LABEL(normal_dispatch);
2966
+ }
2967
+ }
2968
+ else {
2969
+ INSN_LABEL(normal_dispatch):
2970
+ PUSH(recv);
2971
+ CALL_SIMPLE_METHOD(recv);
2972
+ }
2973
+
2974
+ #line 2975 "vm.inc"
2975
+ CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1);
2976
+ PUSH(val);
2977
+ #undef CURRENT_INSN_opt_empty_p
2978
+ #undef INSN_IS_SC
2979
+ #undef INSN_LABEL
2980
+ #undef LABEL_IS_SC
2981
+ END_INSN(opt_empty_p);}}}
2982
+ INSN_ENTRY(opt_succ){
2983
+ {
2984
+ VALUE val;
2985
+ CALL_CACHE cc = (CALL_CACHE)GET_OPERAND(2);
2986
+ CALL_INFO ci = (CALL_INFO)GET_OPERAND(1);
2987
+ VALUE recv = TOPN(0);
2988
+ DEBUG_ENTER_INSN("opt_succ");
2989
+ ADD_PC(1+2);
2990
+ PREFETCH(GET_PC());
2991
+ POPN(1);
2992
+ #define CURRENT_INSN_opt_succ 1
2993
+ #define INSN_IS_SC() 0
2994
+ #define INSN_LABEL(lab) LABEL_opt_succ_##lab
2995
+ #define LABEL_IS_SC(lab) LABEL_##lab##_##t
2996
+ COLLECT_USAGE_INSN(BIN(opt_succ));
2997
+ COLLECT_USAGE_OPERAND(BIN(opt_succ), 0, ci);
2998
+ COLLECT_USAGE_OPERAND(BIN(opt_succ), 1, cc);
2999
+ {
3000
+ #line 2040 "insns.def"
3001
+ if (SPECIAL_CONST_P(recv)) {
3002
+ if (FIXNUM_P(recv) &&
3003
+ BASIC_OP_UNREDEFINED_P(BOP_SUCC, INTEGER_REDEFINED_OP_FLAG)) {
3004
+ /* fixnum + INT2FIX(1) */
3005
+ if (recv != LONG2FIX(FIXNUM_MAX)) {
3006
+ val = recv - 1 + INT2FIX(1);
3007
+ }
3008
+ else {
3009
+ val = LONG2NUM(FIXNUM_MAX + 1);
3010
+ }
3011
+ }
3012
+ else {
3013
+ goto INSN_LABEL(normal_dispatch);
3014
+ }
3015
+ }
3016
+ else {
3017
+ if (RBASIC_CLASS(recv) == rb_cString &&
3018
+ BASIC_OP_UNREDEFINED_P(BOP_SUCC, STRING_REDEFINED_OP_FLAG)) {
3019
+ val = rb_str_succ(recv);
3020
+ }
3021
+ else
3022
+ {
3023
+ goto INSN_LABEL(normal_dispatch);
3024
+ }
3025
+ }
3026
+ if (0) {
3027
+ INSN_LABEL(normal_dispatch):
3028
+ PUSH(recv);
3029
+ CALL_SIMPLE_METHOD(recv);
3030
+ }
3031
+
3032
+ #line 3033 "vm.inc"
3033
+ CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1);
3034
+ PUSH(val);
3035
+ #undef CURRENT_INSN_opt_succ
3036
+ #undef INSN_IS_SC
3037
+ #undef INSN_LABEL
3038
+ #undef LABEL_IS_SC
3039
+ END_INSN(opt_succ);}}}
3040
+ INSN_ENTRY(opt_not){
3041
+ {
3042
+ VALUE val;
3043
+ CALL_CACHE cc = (CALL_CACHE)GET_OPERAND(2);
3044
+ CALL_INFO ci = (CALL_INFO)GET_OPERAND(1);
3045
+ VALUE recv = TOPN(0);
3046
+ DEBUG_ENTER_INSN("opt_not");
3047
+ ADD_PC(1+2);
3048
+ PREFETCH(GET_PC());
3049
+ POPN(1);
3050
+ #define CURRENT_INSN_opt_not 1
3051
+ #define INSN_IS_SC() 0
3052
+ #define INSN_LABEL(lab) LABEL_opt_not_##lab
3053
+ #define LABEL_IS_SC(lab) LABEL_##lab##_##t
3054
+ COLLECT_USAGE_INSN(BIN(opt_not));
3055
+ COLLECT_USAGE_OPERAND(BIN(opt_not), 0, ci);
3056
+ COLLECT_USAGE_OPERAND(BIN(opt_not), 1, cc);
3057
+ {
3058
+ #line 2083 "insns.def"
3059
+ vm_search_method(ci, cc, recv);
3060
+
3061
+ if (check_cfunc(cc->me, rb_obj_not)) {
3062
+ val = RTEST(recv) ? Qfalse : Qtrue;
3063
+ }
3064
+ else {
3065
+ PUSH(recv);
3066
+ CALL_SIMPLE_METHOD(recv);
3067
+ }
3068
+
3069
+ #line 3070 "vm.inc"
3070
+ CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1);
3071
+ PUSH(val);
3072
+ #undef CURRENT_INSN_opt_not
3073
+ #undef INSN_IS_SC
3074
+ #undef INSN_LABEL
3075
+ #undef LABEL_IS_SC
3076
+ END_INSN(opt_not);}}}
3077
+ INSN_ENTRY(opt_regexpmatch1){
3078
+ {
3079
+ VALUE val;
3080
+ VALUE r = (VALUE)GET_OPERAND(1);
3081
+ VALUE obj = TOPN(0);
3082
+ DEBUG_ENTER_INSN("opt_regexpmatch1");
3083
+ ADD_PC(1+1);
3084
+ PREFETCH(GET_PC());
3085
+ POPN(1);
3086
+ #define CURRENT_INSN_opt_regexpmatch1 1
3087
+ #define INSN_IS_SC() 0
3088
+ #define INSN_LABEL(lab) LABEL_opt_regexpmatch1_##lab
3089
+ #define LABEL_IS_SC(lab) LABEL_##lab##_##t
3090
+ COLLECT_USAGE_INSN(BIN(opt_regexpmatch1));
3091
+ COLLECT_USAGE_OPERAND(BIN(opt_regexpmatch1), 0, r);
3092
+ {
3093
+ #line 2106 "insns.def"
3094
+ if (BASIC_OP_UNREDEFINED_P(BOP_MATCH, REGEXP_REDEFINED_OP_FLAG)) {
3095
+ val = rb_reg_match(r, obj);
3096
+ }
3097
+ else {
3098
+ val = rb_funcall(r, idEqTilde, 1, obj);
3099
+ }
3100
+
3101
+ #line 3102 "vm.inc"
3102
+ CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1);
3103
+ PUSH(val);
3104
+ #undef CURRENT_INSN_opt_regexpmatch1
3105
+ #undef INSN_IS_SC
3106
+ #undef INSN_LABEL
3107
+ #undef LABEL_IS_SC
3108
+ END_INSN(opt_regexpmatch1);}}}
3109
+ INSN_ENTRY(opt_regexpmatch2){
3110
+ {
3111
+ VALUE val;
3112
+ CALL_CACHE cc = (CALL_CACHE)GET_OPERAND(2);
3113
+ CALL_INFO ci = (CALL_INFO)GET_OPERAND(1);
3114
+ VALUE obj2 = TOPN(1);
3115
+ VALUE obj1 = TOPN(0);
3116
+ DEBUG_ENTER_INSN("opt_regexpmatch2");
3117
+ ADD_PC(1+2);
3118
+ PREFETCH(GET_PC());
3119
+ POPN(2);
3120
+ #define CURRENT_INSN_opt_regexpmatch2 1
3121
+ #define INSN_IS_SC() 0
3122
+ #define INSN_LABEL(lab) LABEL_opt_regexpmatch2_##lab
3123
+ #define LABEL_IS_SC(lab) LABEL_##lab##_##t
3124
+ COLLECT_USAGE_INSN(BIN(opt_regexpmatch2));
3125
+ COLLECT_USAGE_OPERAND(BIN(opt_regexpmatch2), 0, ci);
3126
+ COLLECT_USAGE_OPERAND(BIN(opt_regexpmatch2), 1, cc);
3127
+ {
3128
+ #line 2125 "insns.def"
3129
+ if (CLASS_OF(obj2) == rb_cString &&
3130
+ BASIC_OP_UNREDEFINED_P(BOP_MATCH, STRING_REDEFINED_OP_FLAG)) {
3131
+ val = rb_reg_match(obj1, obj2);
3132
+ }
3133
+ else {
3134
+ PUSH(obj2);
3135
+ PUSH(obj1);
3136
+ CALL_SIMPLE_METHOD(obj2);
3137
+ }
3138
+
3139
+ #line 3140 "vm.inc"
3140
+ CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1);
3141
+ PUSH(val);
3142
+ #undef CURRENT_INSN_opt_regexpmatch2
3143
+ #undef INSN_IS_SC
3144
+ #undef INSN_LABEL
3145
+ #undef LABEL_IS_SC
3146
+ END_INSN(opt_regexpmatch2);}}}
3147
+ INSN_ENTRY(opt_call_c_function){
3148
+ {
3149
+ rb_insn_func_t funcptr = (rb_insn_func_t)GET_OPERAND(1);
3150
+
3151
+ DEBUG_ENTER_INSN("opt_call_c_function");
3152
+ ADD_PC(1+1);
3153
+ PREFETCH(GET_PC());
3154
+ #define CURRENT_INSN_opt_call_c_function 1
3155
+ #define INSN_IS_SC() 0
3156
+ #define INSN_LABEL(lab) LABEL_opt_call_c_function_##lab
3157
+ #define LABEL_IS_SC(lab) LABEL_##lab##_##t
3158
+ COLLECT_USAGE_INSN(BIN(opt_call_c_function));
3159
+ COLLECT_USAGE_OPERAND(BIN(opt_call_c_function), 0, funcptr);
3160
+ {
3161
+ #line 2147 "insns.def"
3162
+ reg_cfp = (funcptr)(th, reg_cfp);
3163
+
3164
+ if (reg_cfp == 0) {
3165
+ VALUE err = th->errinfo;
3166
+ th->errinfo = Qnil;
3167
+ THROW_EXCEPTION(err);
3168
+ }
3169
+
3170
+ RESTORE_REGS();
3171
+ NEXT_INSN();
3172
+
3173
+ #line 3174 "vm.inc"
3174
+ #undef CURRENT_INSN_opt_call_c_function
3175
+ #undef INSN_IS_SC
3176
+ #undef INSN_LABEL
3177
+ #undef LABEL_IS_SC
3178
+ END_INSN(opt_call_c_function);}}}
3179
+ INSN_ENTRY(bitblt){
3180
+ {
3181
+ VALUE ret;
3182
+
3183
+
3184
+ DEBUG_ENTER_INSN("bitblt");
3185
+ ADD_PC(1+0);
3186
+ PREFETCH(GET_PC());
3187
+ #define CURRENT_INSN_bitblt 1
3188
+ #define INSN_IS_SC() 0
3189
+ #define INSN_LABEL(lab) LABEL_bitblt_##lab
3190
+ #define LABEL_IS_SC(lab) LABEL_##lab##_##t
3191
+ COLLECT_USAGE_INSN(BIN(bitblt));
3192
+ {
3193
+ #line 2170 "insns.def"
3194
+ ret = rb_str_new2("a bit of bacon, lettuce and tomato");
3195
+
3196
+ #line 3197 "vm.inc"
3197
+ CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1);
3198
+ PUSH(ret);
3199
+ #undef CURRENT_INSN_bitblt
3200
+ #undef INSN_IS_SC
3201
+ #undef INSN_LABEL
3202
+ #undef LABEL_IS_SC
3203
+ END_INSN(bitblt);}}}
3204
+ INSN_ENTRY(answer){
3205
+ {
3206
+ VALUE ret;
3207
+
3208
+
3209
+ DEBUG_ENTER_INSN("answer");
3210
+ ADD_PC(1+0);
3211
+ PREFETCH(GET_PC());
3212
+ #define CURRENT_INSN_answer 1
3213
+ #define INSN_IS_SC() 0
3214
+ #define INSN_LABEL(lab) LABEL_answer_##lab
3215
+ #define LABEL_IS_SC(lab) LABEL_##lab##_##t
3216
+ COLLECT_USAGE_INSN(BIN(answer));
3217
+ {
3218
+ #line 2184 "insns.def"
3219
+ ret = INT2FIX(42);
3220
+
3221
+ #line 3222 "vm.inc"
3222
+ CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1);
3223
+ PUSH(ret);
3224
+ #undef CURRENT_INSN_answer
3225
+ #undef INSN_IS_SC
3226
+ #undef INSN_LABEL
3227
+ #undef LABEL_IS_SC
3228
+ END_INSN(answer);}}}
3229
+ INSN_ENTRY(getlocal_OP__WC__0){
3230
+ {
3231
+ VALUE val;
3232
+ #define level 0
3233
+ lindex_t idx = (lindex_t)GET_OPERAND(1);
3234
+
3235
+ DEBUG_ENTER_INSN("getlocal_OP__WC__0");
3236
+ ADD_PC(1+1);
3237
+ PREFETCH(GET_PC());
3238
+ #define CURRENT_INSN_getlocal_OP__WC__0 1
3239
+ #define INSN_IS_SC() 0
3240
+ #define INSN_LABEL(lab) LABEL_getlocal_OP__WC__0_##lab
3241
+ #define LABEL_IS_SC(lab) LABEL_##lab##_##t
3242
+ COLLECT_USAGE_INSN(BIN(getlocal_OP__WC__0));
3243
+ COLLECT_USAGE_OPERAND(BIN(getlocal_OP__WC__0), 0, idx);
3244
+ {
3245
+ #line 60 "insns.def"
3246
+ int i, lev = (int)level;
3247
+ const VALUE *ep = GET_EP();
3248
+
3249
+ /* optimized insns generated for level == (0|1) in defs/opt_operand.def */
3250
+ for (i = 0; i < lev; i++) {
3251
+ ep = GET_PREV_EP(ep);
3252
+ }
3253
+ val = *(ep - idx);
3254
+
3255
+ #line 3256 "vm.inc"
3256
+ CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1);
3257
+ PUSH(val);
3258
+ #undef level
3259
+ #undef CURRENT_INSN_getlocal_OP__WC__0
3260
+ #undef INSN_IS_SC
3261
+ #undef INSN_LABEL
3262
+ #undef LABEL_IS_SC
3263
+ END_INSN(getlocal_OP__WC__0);}}}
3264
+ INSN_ENTRY(getlocal_OP__WC__1){
3265
+ {
3266
+ VALUE val;
3267
+ #define level 1
3268
+ lindex_t idx = (lindex_t)GET_OPERAND(1);
3269
+
3270
+ DEBUG_ENTER_INSN("getlocal_OP__WC__1");
3271
+ ADD_PC(1+1);
3272
+ PREFETCH(GET_PC());
3273
+ #define CURRENT_INSN_getlocal_OP__WC__1 1
3274
+ #define INSN_IS_SC() 0
3275
+ #define INSN_LABEL(lab) LABEL_getlocal_OP__WC__1_##lab
3276
+ #define LABEL_IS_SC(lab) LABEL_##lab##_##t
3277
+ COLLECT_USAGE_INSN(BIN(getlocal_OP__WC__1));
3278
+ COLLECT_USAGE_OPERAND(BIN(getlocal_OP__WC__1), 0, idx);
3279
+ {
3280
+ #line 60 "insns.def"
3281
+ int i, lev = (int)level;
3282
+ const VALUE *ep = GET_EP();
3283
+
3284
+ /* optimized insns generated for level == (0|1) in defs/opt_operand.def */
3285
+ for (i = 0; i < lev; i++) {
3286
+ ep = GET_PREV_EP(ep);
3287
+ }
3288
+ val = *(ep - idx);
3289
+
3290
+ #line 3291 "vm.inc"
3291
+ CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1);
3292
+ PUSH(val);
3293
+ #undef level
3294
+ #undef CURRENT_INSN_getlocal_OP__WC__1
3295
+ #undef INSN_IS_SC
3296
+ #undef INSN_LABEL
3297
+ #undef LABEL_IS_SC
3298
+ END_INSN(getlocal_OP__WC__1);}}}
3299
+ INSN_ENTRY(setlocal_OP__WC__0){
3300
+ {
3301
+ #define level 0
3302
+ lindex_t idx = (lindex_t)GET_OPERAND(1);
3303
+ VALUE val = TOPN(0);
3304
+ DEBUG_ENTER_INSN("setlocal_OP__WC__0");
3305
+ ADD_PC(1+1);
3306
+ PREFETCH(GET_PC());
3307
+ POPN(1);
3308
+ #define CURRENT_INSN_setlocal_OP__WC__0 1
3309
+ #define INSN_IS_SC() 0
3310
+ #define INSN_LABEL(lab) LABEL_setlocal_OP__WC__0_##lab
3311
+ #define LABEL_IS_SC(lab) LABEL_##lab##_##t
3312
+ COLLECT_USAGE_INSN(BIN(setlocal_OP__WC__0));
3313
+ COLLECT_USAGE_OPERAND(BIN(setlocal_OP__WC__0), 0, idx);
3314
+ {
3315
+ #line 83 "insns.def"
3316
+ int i, lev = (int)level;
3317
+ const VALUE *ep = GET_EP();
3318
+
3319
+ /* optimized insns generated for level == (0|1) in defs/opt_operand.def */
3320
+ for (i = 0; i < lev; i++) {
3321
+ ep = GET_PREV_EP(ep);
3322
+ }
3323
+ vm_env_write(ep, -(int)idx, val);
3324
+
3325
+ #line 3326 "vm.inc"
3326
+ #undef level
3327
+ #undef CURRENT_INSN_setlocal_OP__WC__0
3328
+ #undef INSN_IS_SC
3329
+ #undef INSN_LABEL
3330
+ #undef LABEL_IS_SC
3331
+ END_INSN(setlocal_OP__WC__0);}}}
3332
+ INSN_ENTRY(setlocal_OP__WC__1){
3333
+ {
3334
+ #define level 1
3335
+ lindex_t idx = (lindex_t)GET_OPERAND(1);
3336
+ VALUE val = TOPN(0);
3337
+ DEBUG_ENTER_INSN("setlocal_OP__WC__1");
3338
+ ADD_PC(1+1);
3339
+ PREFETCH(GET_PC());
3340
+ POPN(1);
3341
+ #define CURRENT_INSN_setlocal_OP__WC__1 1
3342
+ #define INSN_IS_SC() 0
3343
+ #define INSN_LABEL(lab) LABEL_setlocal_OP__WC__1_##lab
3344
+ #define LABEL_IS_SC(lab) LABEL_##lab##_##t
3345
+ COLLECT_USAGE_INSN(BIN(setlocal_OP__WC__1));
3346
+ COLLECT_USAGE_OPERAND(BIN(setlocal_OP__WC__1), 0, idx);
3347
+ {
3348
+ #line 83 "insns.def"
3349
+ int i, lev = (int)level;
3350
+ const VALUE *ep = GET_EP();
3351
+
3352
+ /* optimized insns generated for level == (0|1) in defs/opt_operand.def */
3353
+ for (i = 0; i < lev; i++) {
3354
+ ep = GET_PREV_EP(ep);
3355
+ }
3356
+ vm_env_write(ep, -(int)idx, val);
3357
+
3358
+ #line 3359 "vm.inc"
3359
+ #undef level
3360
+ #undef CURRENT_INSN_setlocal_OP__WC__1
3361
+ #undef INSN_IS_SC
3362
+ #undef INSN_LABEL
3363
+ #undef LABEL_IS_SC
3364
+ END_INSN(setlocal_OP__WC__1);}}}
3365
+ INSN_ENTRY(putobject_OP_INT2FIX_O_0_C_){
3366
+ {
3367
+ #define val INT2FIX(0)
3368
+
3369
+
3370
+ DEBUG_ENTER_INSN("putobject_OP_INT2FIX_O_0_C_");
3371
+ ADD_PC(1+0);
3372
+ PREFETCH(GET_PC());
3373
+ #define CURRENT_INSN_putobject_OP_INT2FIX_O_0_C_ 1
3374
+ #define INSN_IS_SC() 0
3375
+ #define INSN_LABEL(lab) LABEL_putobject_OP_INT2FIX_O_0_C__##lab
3376
+ #define LABEL_IS_SC(lab) LABEL_##lab##_##t
3377
+ COLLECT_USAGE_INSN(BIN(putobject_OP_INT2FIX_O_0_C_));
3378
+ {
3379
+ #line 299 "insns.def"
3380
+ /* */
3381
+
3382
+ #line 3383 "vm.inc"
3383
+ CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1);
3384
+ PUSH(val);
3385
+ #undef val
3386
+ #undef CURRENT_INSN_putobject_OP_INT2FIX_O_0_C_
3387
+ #undef INSN_IS_SC
3388
+ #undef INSN_LABEL
3389
+ #undef LABEL_IS_SC
3390
+ END_INSN(putobject_OP_INT2FIX_O_0_C_);}}}
3391
+ INSN_ENTRY(putobject_OP_INT2FIX_O_1_C_){
3392
+ {
3393
+ #define val INT2FIX(1)
3394
+
3395
+
3396
+ DEBUG_ENTER_INSN("putobject_OP_INT2FIX_O_1_C_");
3397
+ ADD_PC(1+0);
3398
+ PREFETCH(GET_PC());
3399
+ #define CURRENT_INSN_putobject_OP_INT2FIX_O_1_C_ 1
3400
+ #define INSN_IS_SC() 0
3401
+ #define INSN_LABEL(lab) LABEL_putobject_OP_INT2FIX_O_1_C__##lab
3402
+ #define LABEL_IS_SC(lab) LABEL_##lab##_##t
3403
+ COLLECT_USAGE_INSN(BIN(putobject_OP_INT2FIX_O_1_C_));
3404
+ {
3405
+ #line 299 "insns.def"
3406
+ /* */
3407
+
3408
+ #line 3409 "vm.inc"
3409
+ CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1);
3410
+ PUSH(val);
3411
+ #undef val
3412
+ #undef CURRENT_INSN_putobject_OP_INT2FIX_O_1_C_
3413
+ #undef INSN_IS_SC
3414
+ #undef INSN_LABEL
3415
+ #undef LABEL_IS_SC
3416
+ END_INSN(putobject_OP_INT2FIX_O_1_C_);}}}
3417
+