debugger-ruby_core_source 1.1.9 → 1.2.0

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