debugger-ruby_core_source 1.1.9 → 1.2.0

Sign up to get free protection for your applications and to get access to all the features.
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
+