debase-ruby_core_source 0.9.7 → 0.9.8

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