debase-ruby_core_source 0.8.5 → 0.8.6

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