debugger-ruby_core_source 1.3.7 → 1.3.8

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