debase-ruby_core_source 0.8.0 → 0.8.1

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