/* -*- mode:c; style:ruby; coding: utf-8; indent-tabs-mode: nil -*- */
/* This is an auto-generated file and is a part of the programming language
* Ruby. The person who created a program to generate this file (``I''
* hereafter) would like to refrain from defining licensing of this generated
* source code.
*
* This file consist of many small parts of codes copyrighted by each authors,
* not only the ``I'' person. Those original authors agree with some
* open-source license. I believe that the license we agree is the condition
* mentioned in the file COPYING. It states "4. You may modify and include
* the part of the software into any other software ...". But the problem is,
* the license never makes it clear if such modified parts still remain in the
* same license, or not. The fact that we agree with the source code's
* licensing terms do not automatically define that of generated ones. This is
* the reason why this file is under unclear situation. All that I know is
* that above provision guarantees this file to exist.
*
* Please let me hesitate to declare something about this nuanced contract. I
* am not in the position to take over other authors' license to merge into my
* one. Changing them to (say) GPLv3 is not doable by myself. Perhaps someday
* it might turn out to be okay to say this file is under a license. I wish the
* situation would become more clear in the future. */
/*******************************************************************/
/*******************************************************************/
/*******************************************************************/
/**
This file contains instruction information for yarv instruction sequence..
----
This file is auto generated by insns2vm.rb
DO NOT TOUCH!
If you want to fix something, you must edit "tool/ruby_vm/views/insns_info.inc.erb"
or tool/insns2vm.rb
*/
enum ruby_insn_type_chars {
TS_VARIABLE = '.',
TS_CALLCACHE = 'E',
TS_CALLINFO = 'C',
TS_CDHASH = 'H',
TS_GENTRY = 'G',
TS_IC = 'K',
TS_ID = 'I',
TS_ISE = 'T',
TS_ISEQ = 'S',
TS_OFFSET = 'O',
TS_VALUE = 'V',
TS_LINDEX = 'L',
TS_FUNCPTR = 'F',
TS_NUM = 'N'
};
CONSTFUNC(MAYBE_UNUSED(static const char *insn_name(VALUE insn)));
extern const char *rb_vm_insn_name_info;
MJIT_SYMBOL_EXPORT_BEGIN
extern const unsigned short rb_vm_insn_name_offset[];
MJIT_SYMBOL_EXPORT_END
#ifdef RUBY_VM_INSNS_INFO
const unsigned short rb_vm_insn_name_offset[] = {
0, 4, 13, 22, 36, 50, 69, 80, 91, 111, 131, 148,
165, 177, 189, 199, 209, 216, 224, 234, 251, 259, 269, 283,
292, 305, 314, 321, 330, 339, 347, 359, 371, 382, 390, 399,
403, 407, 412, 417, 425, 431, 436, 441, 453, 461, 472, 485,
495, 507, 512, 535, 550, 565, 582, 599, 611, 623, 629, 635,
640, 649, 662, 672, 691, 710, 715, 733, 742, 752, 761, 769,
777, 784, 792, 799, 806, 813, 820, 829, 837, 844, 853, 862,
876, 890, 901, 910, 922, 931, 939, 956, 973, 993, 1000, 1007,
1021, 1035, 1049, 1063, 1084, 1105, 1115, 1130, 1145, 1165, 1185, 1210,
1227, 1244, 1270, 1296, 1319, 1342, 1360, 1378, 1394, 1410, 1423, 1437,
1453, 1476, 1490, 1506, 1526, 1541, 1560, 1575, 1588, 1603, 1618, 1632,
1650, 1668, 1685, 1699, 1714, 1724, 1734, 1745, 1756, 1770, 1782, 1793,
1804, 1822, 1836, 1853, 1872, 1888, 1906, 1917, 1946, 1967, 1988, 2011,
2034, 2052, 2070, 2082, 2094, 2105, 2120, 2139, 2155, 2180, 2205, 2216,
2240, 2255, 2271, 2286, 2300, 2314, 2327, 2341, 2354, 2367, 2380, 2393,
2408, 2422, 2435, 2450, 2465, 2485, 2505, 2522, 2537, 2555, 2570, 2584,
2607, 2630, 2656, 2669, 2682, 2702, 2722, 2742, 2762, 2789,
};
const int rb_vm_max_insn_name_size = 28;
ASSERT_VM_INSTRUCTION_SIZE(rb_vm_insn_name_offset);
PACKED_STRUCT(struct rb_vm_insn_name_info_tag {
const char L000[ 4]; const char L001[ 9]; const char L002[ 9];
const char L003[14]; const char L004[14]; const char L005[19];
const char L006[11]; const char L007[11]; const char L008[20];
const char L009[20]; const char L010[17]; const char L011[17];
const char L012[12]; const char L013[12]; const char L014[10];
const char L015[10]; const char L016[ 7]; const char L017[ 8];
const char L018[10]; const char L019[17]; const char L020[ 8];
const char L021[10]; const char L022[14]; const char L023[ 9];
const char L024[13]; const char L025[ 9]; const char L026[ 7];
const char L027[ 9]; const char L028[ 9]; const char L029[ 8];
const char L030[12]; const char L031[12]; const char L032[11];
const char L033[ 8]; const char L034[ 9]; const char L035[ 4];
const char L036[ 4]; const char L037[ 5]; const char L038[ 5];
const char L039[ 8]; const char L040[ 6]; const char L041[ 5];
const char L042[ 5]; const char L043[12]; const char L044[ 8];
const char L045[11]; const char L046[13]; const char L047[10];
const char L048[12]; const char L049[ 5]; const char L050[23];
const char L051[15]; const char L052[15]; const char L053[17];
const char L054[17]; const char L055[12]; const char L056[12];
const char L057[ 6]; const char L058[ 6]; const char L059[ 5];
const char L060[ 9]; const char L061[13]; const char L062[10];
const char L063[19]; const char L064[19]; const char L065[ 5];
const char L066[18]; const char L067[ 9]; const char L068[10];
const char L069[ 9]; const char L070[ 8]; const char L071[ 8];
const char L072[ 7]; const char L073[ 8]; const char L074[ 7];
const char L075[ 7]; const char L076[ 7]; const char L077[ 7];
const char L078[ 9]; const char L079[ 8]; const char L080[ 7];
const char L081[ 9]; const char L082[ 9]; const char L083[14];
const char L084[14]; const char L085[11]; const char L086[ 9];
const char L087[12]; const char L088[ 9]; const char L089[ 8];
const char L090[17]; const char L091[17]; const char L092[20];
const char L093[ 7]; const char L094[ 7]; const char L095[14];
const char L096[14]; const char L097[14]; const char L098[14];
const char L099[21]; const char L100[21]; const char L101[10];
const char L102[15]; const char L103[15]; const char L104[20];
const char L105[20]; const char L106[25]; const char L107[17];
const char L108[17]; const char L109[26]; const char L110[26];
const char L111[23]; const char L112[23]; const char L113[18];
const char L114[18]; const char L115[16]; const char L116[16];
const char L117[13]; const char L118[14]; const char L119[16];
const char L120[23]; const char L121[14]; const char L122[16];
const char L123[20]; const char L124[15]; const char L125[19];
const char L126[15]; const char L127[13]; const char L128[15];
const char L129[15]; const char L130[14]; const char L131[18];
const char L132[18]; const char L133[17]; const char L134[14];
const char L135[15]; const char L136[10]; const char L137[10];
const char L138[11]; const char L139[11]; const char L140[14];
const char L141[12]; const char L142[11]; const char L143[11];
const char L144[18]; const char L145[14]; const char L146[17];
const char L147[19]; const char L148[16]; const char L149[18];
const char L150[11]; const char L151[29]; const char L152[21];
const char L153[21]; const char L154[23]; const char L155[23];
const char L156[18]; const char L157[18]; const char L158[12];
const char L159[12]; const char L160[11]; const char L161[15];
const char L162[19]; const char L163[16]; const char L164[25];
const char L165[25]; const char L166[11]; const char L167[24];
const char L168[15]; const char L169[16]; const char L170[15];
const char L171[14]; const char L172[14]; const char L173[13];
const char L174[14]; const char L175[13]; const char L176[13];
const char L177[13]; const char L178[13]; const char L179[15];
const char L180[14]; const char L181[13]; const char L182[15];
const char L183[15]; const char L184[20]; const char L185[20];
const char L186[17]; const char L187[15]; const char L188[18];
const char L189[15]; const char L190[14]; const char L191[23];
const char L192[23]; const char L193[26]; const char L194[13];
const char L195[13]; const char L196[20]; const char L197[20];
const char L198[20]; const char L199[20]; const char L200[27];
const char L201[27];
});
static const struct rb_vm_insn_name_info_tag rb_vm_insn_name_base = {
"nop" , "getlocal" ,
"setlocal" , "getblockparam" ,
"setblockparam" , "getblockparamproxy" ,
"getspecial" , "setspecial" ,
"getinstancevariable" , "setinstancevariable" ,
"getclassvariable" , "setclassvariable" ,
"getconstant" , "setconstant" ,
"getglobal" , "setglobal" ,
"putnil" , "putself" ,
"putobject" , "putspecialobject" ,
"putiseq" , "putstring" ,
"concatstrings" , "tostring" ,
"freezestring" , "toregexp" ,
"intern" , "newarray" ,
"duparray" , "duphash" ,
"expandarray" , "concatarray" ,
"splatarray" , "newhash" ,
"newrange" , "pop" ,
"dup" , "dupn" ,
"swap" , "reverse" ,
"reput" , "topn" ,
"setn" , "adjuststack" ,
"defined" , "checkmatch" ,
"checkkeyword" , "checktype" ,
"defineclass" , "send" ,
"opt_send_without_block" , "opt_str_freeze" ,
"opt_str_uminus" , "opt_newarray_max" ,
"opt_newarray_min" , "invokesuper" ,
"invokeblock" , "leave" ,
"throw" , "jump" ,
"branchif" , "branchunless" ,
"branchnil" , "opt_getinlinecache" ,
"opt_setinlinecache" , "once" ,
"opt_case_dispatch" , "opt_plus" ,
"opt_minus" , "opt_mult" ,
"opt_div" , "opt_mod" ,
"opt_eq" , "opt_neq" ,
"opt_lt" , "opt_le" ,
"opt_gt" , "opt_ge" ,
"opt_ltlt" , "opt_and" ,
"opt_or" , "opt_aref" ,
"opt_aset" , "opt_aset_with" ,
"opt_aref_with" , "opt_length" ,
"opt_size" , "opt_empty_p" ,
"opt_succ" , "opt_not" ,
"opt_regexpmatch1" , "opt_regexpmatch2" ,
"opt_call_c_function" , "bitblt" ,
"answer" , "getlocal_WC_0" ,
"getlocal_WC_1" , "setlocal_WC_0" ,
"setlocal_WC_1" , "putobject_INT2FIX_0_" ,
"putobject_INT2FIX_1_" , "trace_nop" ,
"trace_getlocal" , "trace_setlocal" ,
"trace_getblockparam" , "trace_setblockparam" ,
"trace_getblockparamproxy" , "trace_getspecial" ,
"trace_setspecial" , "trace_getinstancevariable" ,
"trace_setinstancevariable" , "trace_getclassvariable" ,
"trace_setclassvariable" , "trace_getconstant" ,
"trace_setconstant" , "trace_getglobal" ,
"trace_setglobal" , "trace_putnil" ,
"trace_putself" , "trace_putobject" ,
"trace_putspecialobject" , "trace_putiseq" ,
"trace_putstring" , "trace_concatstrings" ,
"trace_tostring" , "trace_freezestring" ,
"trace_toregexp" , "trace_intern" ,
"trace_newarray" , "trace_duparray" ,
"trace_duphash" , "trace_expandarray" ,
"trace_concatarray" , "trace_splatarray" ,
"trace_newhash" , "trace_newrange" ,
"trace_pop" , "trace_dup" ,
"trace_dupn" , "trace_swap" ,
"trace_reverse" , "trace_reput" ,
"trace_topn" , "trace_setn" ,
"trace_adjuststack" , "trace_defined" ,
"trace_checkmatch" , "trace_checkkeyword" ,
"trace_checktype" , "trace_defineclass" ,
"trace_send" , "trace_opt_send_without_block",
"trace_opt_str_freeze" , "trace_opt_str_uminus" ,
"trace_opt_newarray_max" , "trace_opt_newarray_min" ,
"trace_invokesuper" , "trace_invokeblock" ,
"trace_leave" , "trace_throw" ,
"trace_jump" , "trace_branchif" ,
"trace_branchunless" , "trace_branchnil" ,
"trace_opt_getinlinecache" , "trace_opt_setinlinecache" ,
"trace_once" , "trace_opt_case_dispatch" ,
"trace_opt_plus" , "trace_opt_minus" ,
"trace_opt_mult" , "trace_opt_div" ,
"trace_opt_mod" , "trace_opt_eq" ,
"trace_opt_neq" , "trace_opt_lt" ,
"trace_opt_le" , "trace_opt_gt" ,
"trace_opt_ge" , "trace_opt_ltlt" ,
"trace_opt_and" , "trace_opt_or" ,
"trace_opt_aref" , "trace_opt_aset" ,
"trace_opt_aset_with" , "trace_opt_aref_with" ,
"trace_opt_length" , "trace_opt_size" ,
"trace_opt_empty_p" , "trace_opt_succ" ,
"trace_opt_not" , "trace_opt_regexpmatch1" ,
"trace_opt_regexpmatch2" , "trace_opt_call_c_function" ,
"trace_bitblt" , "trace_answer" ,
"trace_getlocal_WC_0" , "trace_getlocal_WC_1" ,
"trace_setlocal_WC_0" , "trace_setlocal_WC_1" ,
"trace_putobject_INT2FIX_0_" , "trace_putobject_INT2FIX_1_" ,
};
const char *rb_vm_insn_name_info = (const char *)&rb_vm_insn_name_base;
#endif
const char *
insn_name(VALUE i)
{
return &rb_vm_insn_name_info[rb_vm_insn_name_offset[i]];
}
CONSTFUNC(MAYBE_UNUSED(static int insn_len(VALUE insn)));
extern const char rb_vm_insn_len_info[];
#ifdef RUBY_VM_INSNS_INFO
const char rb_vm_insn_len_info[] = {
1, 3, 3, 3, 3, 3, 3, 2, 3, 3, 2, 2, 2, 2, 2, 2, 1, 1, 2, 2, 2, 2, 2, 1, 2,
3, 1, 2, 2, 2, 3, 1, 2, 2, 2, 1, 1, 2, 1, 2, 1, 2, 2, 2, 4, 2, 3, 2, 4, 4,
3, 4, 4, 2, 2, 4, 2, 1, 2, 2, 2, 2, 2, 3, 2, 3, 3, 3, 3, 3, 3, 3, 3, 5, 3,
3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 3, 3, 3, 3, 3, 2, 3, 2, 1, 1, 2, 2, 2, 2, 1,
1, 1, 3, 3, 3, 3, 3, 3, 2, 3, 3, 2, 2, 2, 2, 2, 2, 1, 1, 2, 2, 2, 2, 2, 1,
2, 3, 1, 2, 2, 2, 3, 1, 2, 2, 2, 1, 1, 2, 1, 2, 1, 2, 2, 2, 4, 2, 3, 2, 4,
4, 3, 4, 4, 2, 2, 4, 2, 1, 2, 2, 2, 2, 2, 3, 2, 3, 3, 3, 3, 3, 3, 3, 3, 5,
3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 3, 3, 3, 3, 3, 2, 3, 2, 1, 1, 2, 2, 2, 2,
1, 1,
};
#endif
int
insn_len(VALUE i)
{
return rb_vm_insn_len_info[i];
}
CONSTFUNC(MAYBE_UNUSED(static const char *insn_op_types(VALUE insn)));
CONSTFUNC(MAYBE_UNUSED(static int insn_op_type(VALUE insn, long pos)));
extern const char *rb_vm_insn_op_info;
extern const unsigned short rb_vm_insn_op_offset[];
#ifdef RUBY_VM_INSNS_INFO
const unsigned short rb_vm_insn_op_offset[] = {
0, 1, 4, 7, 10, 13, 16, 19, 21, 24, 27, 29, 31, 33,
35, 37, 39, 40, 41, 43, 45, 47, 49, 51, 52, 54, 57, 58,
60, 62, 64, 67, 68, 70, 72, 74, 75, 76, 78, 79, 81, 82,
84, 86, 88, 92, 94, 97, 99, 103, 107, 110, 114, 118, 120, 122,
126, 128, 129, 131, 133, 135, 137, 139, 142, 144, 147, 150, 153, 156,
159, 162, 165, 168, 173, 176, 179, 182, 185, 188, 191, 194, 197, 200,
204, 208, 211, 214, 217, 220, 223, 225, 228, 230, 231, 232, 234, 236,
238, 240, 241, 242, 243, 246, 249, 252, 255, 258, 261, 263, 266, 269,
271, 273, 275, 277, 279, 281, 282, 283, 285, 287, 289, 291, 293, 294,
296, 299, 300, 302, 304, 306, 309, 310, 312, 314, 316, 317, 318, 320,
321, 323, 324, 326, 328, 330, 334, 336, 339, 341, 345, 349, 352, 356,
360, 362, 364, 368, 370, 371, 373, 375, 377, 379, 381, 384, 386, 389,
392, 395, 398, 401, 404, 407, 410, 415, 418, 421, 424, 427, 430, 433,
436, 439, 442, 446, 450, 453, 456, 459, 462, 465, 467, 470, 472, 473,
474, 476, 478, 480, 482, 483,
};
ASSERT_VM_INSTRUCTION_SIZE(rb_vm_insn_op_offset);
PACKED_STRUCT(struct rb_vm_insn_op_info_tag {
const char L000[ 1]; const char L001[ 3]; const char L002[ 3];
const char L003[ 3]; const char L004[ 3]; const char L005[ 3];
const char L006[ 3]; const char L007[ 2]; const char L008[ 3];
const char L009[ 3]; const char L010[ 2]; const char L011[ 2];
const char L012[ 2]; const char L013[ 2]; const char L014[ 2];
const char L015[ 2]; const char L016[ 1]; const char L017[ 1];
const char L018[ 2]; const char L019[ 2]; const char L020[ 2];
const char L021[ 2]; const char L022[ 2]; const char L023[ 1];
const char L024[ 2]; const char L025[ 3]; const char L026[ 1];
const char L027[ 2]; const char L028[ 2]; const char L029[ 2];
const char L030[ 3]; const char L031[ 1]; const char L032[ 2];
const char L033[ 2]; const char L034[ 2]; const char L035[ 1];
const char L036[ 1]; const char L037[ 2]; const char L038[ 1];
const char L039[ 2]; const char L040[ 1]; const char L041[ 2];
const char L042[ 2]; const char L043[ 2]; const char L044[ 4];
const char L045[ 2]; const char L046[ 3]; const char L047[ 2];
const char L048[ 4]; const char L049[ 4]; const char L050[ 3];
const char L051[ 4]; const char L052[ 4]; const char L053[ 2];
const char L054[ 2]; const char L055[ 4]; const char L056[ 2];
const char L057[ 1]; const char L058[ 2]; const char L059[ 2];
const char L060[ 2]; const char L061[ 2]; const char L062[ 2];
const char L063[ 3]; const char L064[ 2]; const char L065[ 3];
const char L066[ 3]; const char L067[ 3]; const char L068[ 3];
const char L069[ 3]; const char L070[ 3]; const char L071[ 3];
const char L072[ 3]; const char L073[ 5]; const char L074[ 3];
const char L075[ 3]; const char L076[ 3]; const char L077[ 3];
const char L078[ 3]; const char L079[ 3]; const char L080[ 3];
const char L081[ 3]; const char L082[ 3]; const char L083[ 4];
const char L084[ 4]; const char L085[ 3]; const char L086[ 3];
const char L087[ 3]; const char L088[ 3]; const char L089[ 3];
const char L090[ 2]; const char L091[ 3]; const char L092[ 2];
const char L093[ 1]; const char L094[ 1]; const char L095[ 2];
const char L096[ 2]; const char L097[ 2]; const char L098[ 2];
const char L099[ 1]; const char L100[ 1]; const char L101[ 1];
const char L102[ 3]; const char L103[ 3]; const char L104[ 3];
const char L105[ 3]; const char L106[ 3]; const char L107[ 3];
const char L108[ 2]; const char L109[ 3]; const char L110[ 3];
const char L111[ 2]; const char L112[ 2]; const char L113[ 2];
const char L114[ 2]; const char L115[ 2]; const char L116[ 2];
const char L117[ 1]; const char L118[ 1]; const char L119[ 2];
const char L120[ 2]; const char L121[ 2]; const char L122[ 2];
const char L123[ 2]; const char L124[ 1]; const char L125[ 2];
const char L126[ 3]; const char L127[ 1]; const char L128[ 2];
const char L129[ 2]; const char L130[ 2]; const char L131[ 3];
const char L132[ 1]; const char L133[ 2]; const char L134[ 2];
const char L135[ 2]; const char L136[ 1]; const char L137[ 1];
const char L138[ 2]; const char L139[ 1]; const char L140[ 2];
const char L141[ 1]; const char L142[ 2]; const char L143[ 2];
const char L144[ 2]; const char L145[ 4]; const char L146[ 2];
const char L147[ 3]; const char L148[ 2]; const char L149[ 4];
const char L150[ 4]; const char L151[ 3]; const char L152[ 4];
const char L153[ 4]; const char L154[ 2]; const char L155[ 2];
const char L156[ 4]; const char L157[ 2]; const char L158[ 1];
const char L159[ 2]; const char L160[ 2]; const char L161[ 2];
const char L162[ 2]; const char L163[ 2]; const char L164[ 3];
const char L165[ 2]; const char L166[ 3]; const char L167[ 3];
const char L168[ 3]; const char L169[ 3]; const char L170[ 3];
const char L171[ 3]; const char L172[ 3]; const char L173[ 3];
const char L174[ 5]; const char L175[ 3]; const char L176[ 3];
const char L177[ 3]; const char L178[ 3]; const char L179[ 3];
const char L180[ 3]; const char L181[ 3]; const char L182[ 3];
const char L183[ 3]; const char L184[ 4]; const char L185[ 4];
const char L186[ 3]; const char L187[ 3]; const char L188[ 3];
const char L189[ 3]; const char L190[ 3]; const char L191[ 2];
const char L192[ 3]; const char L193[ 2]; const char L194[ 1];
const char L195[ 1]; const char L196[ 2]; const char L197[ 2];
const char L198[ 2]; const char L199[ 2]; const char L200[ 1];
const char L201[ 1];
});
static const struct rb_vm_insn_op_info_tag rb_vm_insn_op_base = {
"" , "LN" , "LN" , "LN" , "LN" , "LN" , "NN" , "N" ,
"IK" , "IK" , "I" , "I" , "I" , "I" , "G" , "G" ,
"" , "" , "V" , "N" , "S" , "V" , "N" , "" ,
"V" , "NN" , "" , "N" , "V" , "V" , "NN" , "" ,
"V" , "N" , "N" , "" , "" , "N" , "" , "N" ,
"" , "N" , "N" , "N" , "NVV" , "N" , "LL" , "N" ,
"ISN" , "CES" , "CE" , "VCE" , "VCE" , "N" , "N" , "CES" ,
"C" , "" , "N" , "O" , "O" , "O" , "O" , "OK" ,
"K" , "ST" , "HO" , "CE" , "CE" , "CE" , "CE" , "CE" ,
"CE" , "CECE", "CE" , "CE" , "CE" , "CE" , "CE" , "CE" ,
"CE" , "CE" , "CE" , "VCE" , "VCE" , "CE" , "CE" , "CE" ,
"CE" , "CE" , "V" , "CE" , "F" , "" , "" , "L" ,
"L" , "L" , "L" , "" , "" , "" , "LN" , "LN" ,
"LN" , "LN" , "LN" , "NN" , "N" , "IK" , "IK" , "I" ,
"I" , "I" , "I" , "G" , "G" , "" , "" , "V" ,
"N" , "S" , "V" , "N" , "" , "V" , "NN" , "" ,
"N" , "V" , "V" , "NN" , "" , "V" , "N" , "N" ,
"" , "" , "N" , "" , "N" , "" , "N" , "N" ,
"N" , "NVV" , "N" , "LL" , "N" , "ISN" , "CES" , "CE" ,
"VCE" , "VCE" , "N" , "N" , "CES" , "C" , "" , "N" ,
"O" , "O" , "O" , "O" , "OK" , "K" , "ST" , "HO" ,
"CE" , "CE" , "CE" , "CE" , "CE" , "CE" , "CECE", "CE" ,
"CE" , "CE" , "CE" , "CE" , "CE" , "CE" , "CE" , "CE" ,
"VCE" , "VCE" , "CE" , "CE" , "CE" , "CE" , "CE" , "V" ,
"CE" , "F" , "" , "" , "L" , "L" , "L" , "L" ,
"" , "" ,
};
const char *rb_vm_insn_op_info = (const char *)&rb_vm_insn_op_base;
#endif
const char *
insn_op_types(VALUE i)
{
return &rb_vm_insn_op_info[rb_vm_insn_op_offset[i]];
}
int
insn_op_type(VALUE i, long j)
{
if (j >= insn_len(i)) {
return 0;
}
else {
return insn_op_types(i)[j];
}
}
static bool
leafness_of_getglobal(VALUE gentry)
{
const struct rb_global_entry *e = (void *)gentry;
if (UNLIKELY(rb_gvar_is_traced(e))) {
return false;
}
else {
/* We cannot write this function using a switch() because a
* case label cannot be a function pointer. */
static rb_gvar_getter_t *const allowlist[] = {
rb_gvar_val_getter,
rb_gvar_var_getter,
rb_gvar_undef_getter,
};
rb_gvar_getter_t *f = rb_gvar_getter_function_of(e);
int i;
for (i = 0; i < numberof(allowlist); i++) {
if (f == allowlist[i]) {
return true;
}
}
return false;
}
}
static bool
leafness_of_setglobal(VALUE gentry)
{
const struct rb_global_entry *e = (void *)gentry;
if (UNLIKELY(rb_gvar_is_traced(e))) {
return false;
}
else {
/* We cannot write this function using a switch() because a
* case label cannot be a function pointer. */
static rb_gvar_setter_t *const allowlist[] = {
rb_gvar_val_setter,
rb_gvar_readonly_setter,
rb_gvar_var_setter,
rb_gvar_undef_setter,
};
rb_gvar_setter_t *f = rb_gvar_setter_function_of(e);
int i;
for (i = 0; i < numberof(allowlist); i++) {
if (f == allowlist[i]) {
return true;
}
}
return false;
}
}
#include "iseq.h"
static bool
leafness_of_defined(rb_num_t op_type)
{
/* see also: vm_insnhelper.c:vm_defined() */
switch (op_type) {
case DEFINED_IVAR:
case DEFINED_IVAR2:
case DEFINED_GVAR:
case DEFINED_CVAR:
case DEFINED_YIELD:
case DEFINED_REF:
case DEFINED_ZSUPER:
return false;
case DEFINED_CONST:
/* has rb_autoload_load(); */
return false;
case DEFINED_FUNC:
case DEFINED_METHOD:
/* calls #respond_to_missing? */
return false;
default:
rb_bug("unknown operand %ld: blame @shyouhei.", op_type);
}
}
static bool
leafness_of_checkmatch(rb_num_t flag)
{
/* see also: vm_insnhelper.c:check_match() */
if (flag == VM_CHECKMATCH_TYPE_WHEN) {
return true;
}
else {
/* has rb_funcallv() */
return false;
}
}
#ifndef RUBY_VM_EXEC_H
/* can't #include "vm_exec.h" here... */
typedef long OFFSET;
typedef unsigned long lindex_t;
typedef VALUE GENTRY;
typedef rb_iseq_t *ISEQ;
#endif
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_nop(void)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_nop(void)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_nop(void)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_nop(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_nop(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_nop(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_nop(void)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_nop(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_nop(void)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_getlocal(lindex_t idx, rb_num_t level)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_getlocal(lindex_t idx, rb_num_t level)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_getlocal(lindex_t idx, rb_num_t level)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_getlocal(lindex_t idx, rb_num_t level)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_getlocal(lindex_t idx, rb_num_t level)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_getlocal(lindex_t idx, rb_num_t level)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_getlocal(lindex_t idx, rb_num_t level)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_getlocal(lindex_t idx, rb_num_t level)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_getlocal(lindex_t idx, rb_num_t level)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_setlocal(lindex_t idx, rb_num_t level)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_setlocal(lindex_t idx, rb_num_t level)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_setlocal(lindex_t idx, rb_num_t level)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_setlocal(lindex_t idx, rb_num_t level)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_setlocal(lindex_t idx, rb_num_t level)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_setlocal(lindex_t idx, rb_num_t level)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_setlocal(lindex_t idx, rb_num_t level)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_setlocal(lindex_t idx, rb_num_t level)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_setlocal(lindex_t idx, rb_num_t level)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_getblockparam(lindex_t idx, rb_num_t level)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_getblockparam(lindex_t idx, rb_num_t level)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_getblockparam(lindex_t idx, rb_num_t level)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_getblockparam(lindex_t idx, rb_num_t level)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_getblockparam(lindex_t idx, rb_num_t level)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_getblockparam(lindex_t idx, rb_num_t level)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_getblockparam(lindex_t idx, rb_num_t level)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_getblockparam(lindex_t idx, rb_num_t level)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_getblockparam(lindex_t idx, rb_num_t level)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_setblockparam(lindex_t idx, rb_num_t level)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_setblockparam(lindex_t idx, rb_num_t level)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_setblockparam(lindex_t idx, rb_num_t level)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_setblockparam(lindex_t idx, rb_num_t level)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_setblockparam(lindex_t idx, rb_num_t level)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_setblockparam(lindex_t idx, rb_num_t level)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_setblockparam(lindex_t idx, rb_num_t level)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_setblockparam(lindex_t idx, rb_num_t level)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_setblockparam(lindex_t idx, rb_num_t level)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_getblockparamproxy(lindex_t idx, rb_num_t level)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_getblockparamproxy(lindex_t idx, rb_num_t level)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_getblockparamproxy(lindex_t idx, rb_num_t level)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_getblockparamproxy(lindex_t idx, rb_num_t level)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_getblockparamproxy(lindex_t idx, rb_num_t level)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_getblockparamproxy(lindex_t idx, rb_num_t level)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_getblockparamproxy(lindex_t idx, rb_num_t level)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_getblockparamproxy(lindex_t idx, rb_num_t level)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_getblockparamproxy(lindex_t idx, rb_num_t level)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_getspecial(rb_num_t key, rb_num_t type)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_getspecial(rb_num_t key, rb_num_t type)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_getspecial(rb_num_t key, rb_num_t type)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_getspecial(rb_num_t key, rb_num_t type)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_getspecial(rb_num_t key, rb_num_t type)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_getspecial(rb_num_t key, rb_num_t type)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_getspecial(rb_num_t key, rb_num_t type)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_getspecial(rb_num_t key, rb_num_t type)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_getspecial(rb_num_t key, rb_num_t type)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_setspecial(rb_num_t key)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_setspecial(rb_num_t key)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_setspecial(rb_num_t key)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_setspecial(rb_num_t key)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_setspecial(rb_num_t key)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_setspecial(rb_num_t key)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_setspecial(rb_num_t key)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_setspecial(rb_num_t key)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_setspecial(rb_num_t key)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_getinstancevariable(ID id, IC ic)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_getinstancevariable(ID id, IC ic)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_getinstancevariable(ID id, IC ic)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_getinstancevariable(ID id, IC ic)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_getinstancevariable(ID id, IC ic)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_getinstancevariable(ID id, IC ic)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_getinstancevariable(ID id, IC ic)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_getinstancevariable(ID id, IC ic)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_getinstancevariable(ID id, IC ic)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_setinstancevariable(ID id, IC ic)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_setinstancevariable(ID id, IC ic)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_setinstancevariable(ID id, IC ic)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_setinstancevariable(ID id, IC ic)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_setinstancevariable(ID id, IC ic)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_setinstancevariable(ID id, IC ic)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_setinstancevariable(ID id, IC ic)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_setinstancevariable(ID id, IC ic)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_setinstancevariable(ID id, IC ic)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_getclassvariable(ID id)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_getclassvariable(ID id)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_getclassvariable(ID id)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_getclassvariable(ID id)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_getclassvariable(ID id)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_getclassvariable(ID id)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_getclassvariable(ID id)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_getclassvariable(ID id)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_getclassvariable(ID id)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_setclassvariable(ID id)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_setclassvariable(ID id)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_setclassvariable(ID id)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_setclassvariable(ID id)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_setclassvariable(ID id)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_setclassvariable(ID id)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_setclassvariable(ID id)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_setclassvariable(ID id)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_setclassvariable(ID id)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_getconstant(ID id)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_getconstant(ID id)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_getconstant(ID id)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_getconstant(ID id)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_getconstant(ID id)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_getconstant(ID id)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_getconstant(ID id)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_getconstant(ID id)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_getconstant(ID id)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_setconstant(ID id)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_setconstant(ID id)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_setconstant(ID id)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_setconstant(ID id)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_setconstant(ID id)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_setconstant(ID id)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_setconstant(ID id)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_setconstant(ID id)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_setconstant(ID id)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_getglobal(GENTRY entry)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_getglobal(GENTRY entry)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_getglobal(GENTRY entry)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_getglobal(GENTRY entry)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_getglobal(GENTRY entry)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_getglobal(GENTRY entry)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_getglobal(GENTRY entry)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_getglobal(GENTRY entry)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_getglobal(GENTRY entry)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_setglobal(GENTRY entry)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_setglobal(GENTRY entry)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_setglobal(GENTRY entry)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_setglobal(GENTRY entry)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_setglobal(GENTRY entry)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_setglobal(GENTRY entry)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_setglobal(GENTRY entry)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_setglobal(GENTRY entry)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_setglobal(GENTRY entry)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_putnil(void)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_putnil(void)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_putnil(void)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_putnil(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_putnil(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_putnil(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_putnil(void)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_putnil(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_putnil(void)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_putself(void)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_putself(void)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_putself(void)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_putself(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_putself(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_putself(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_putself(void)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_putself(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_putself(void)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_putobject(VALUE val)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_putobject(VALUE val)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_putobject(VALUE val)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_putobject(VALUE val)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_putobject(VALUE val)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_putobject(VALUE val)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_putobject(VALUE val)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_putobject(VALUE val)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_putobject(VALUE val)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_putspecialobject(rb_num_t value_type)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_putspecialobject(rb_num_t value_type)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_putspecialobject(rb_num_t value_type)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_putspecialobject(rb_num_t value_type)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_putspecialobject(rb_num_t value_type)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_putspecialobject(rb_num_t value_type)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_putspecialobject(rb_num_t value_type)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_putspecialobject(rb_num_t value_type)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_putspecialobject(rb_num_t value_type)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_putiseq(ISEQ iseq)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_putiseq(ISEQ iseq)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_putiseq(ISEQ iseq)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_putiseq(ISEQ iseq)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_putiseq(ISEQ iseq)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_putiseq(ISEQ iseq)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_putiseq(ISEQ iseq)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_putiseq(ISEQ iseq)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_putiseq(ISEQ iseq)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_putstring(VALUE str)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_putstring(VALUE str)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_putstring(VALUE str)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_putstring(VALUE str)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_putstring(VALUE str)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_putstring(VALUE str)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_putstring(VALUE str)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_putstring(VALUE str)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_putstring(VALUE str)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_concatstrings(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_concatstrings(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_concatstrings(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_concatstrings(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_concatstrings(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_concatstrings(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_concatstrings(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_concatstrings(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_concatstrings(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_tostring(void)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_tostring(void)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_tostring(void)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_tostring(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_tostring(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_tostring(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_tostring(void)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_tostring(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_tostring(void)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_freezestring(VALUE debug_info)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_freezestring(VALUE debug_info)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_freezestring(VALUE debug_info)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_freezestring(VALUE debug_info)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_freezestring(VALUE debug_info)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_freezestring(VALUE debug_info)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_freezestring(VALUE debug_info)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_freezestring(VALUE debug_info)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_freezestring(VALUE debug_info)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_toregexp(rb_num_t opt, rb_num_t cnt)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_toregexp(rb_num_t opt, rb_num_t cnt)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_toregexp(rb_num_t opt, rb_num_t cnt)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_toregexp(rb_num_t opt, rb_num_t cnt)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_toregexp(rb_num_t opt, rb_num_t cnt)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_toregexp(rb_num_t opt, rb_num_t cnt)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_toregexp(rb_num_t opt, rb_num_t cnt)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_toregexp(rb_num_t opt, rb_num_t cnt)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_toregexp(rb_num_t opt, rb_num_t cnt)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_intern(void)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_intern(void)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_intern(void)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_intern(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_intern(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_intern(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_intern(void)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_intern(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_intern(void)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_newarray(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_newarray(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_newarray(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_newarray(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_newarray(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_newarray(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_newarray(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_newarray(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_newarray(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_duparray(VALUE ary)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_duparray(VALUE ary)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_duparray(VALUE ary)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_duparray(VALUE ary)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_duparray(VALUE ary)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_duparray(VALUE ary)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_duparray(VALUE ary)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_duparray(VALUE ary)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_duparray(VALUE ary)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_duphash(VALUE hash)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_duphash(VALUE hash)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_duphash(VALUE hash)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_duphash(VALUE hash)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_duphash(VALUE hash)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_duphash(VALUE hash)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_duphash(VALUE hash)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_duphash(VALUE hash)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_duphash(VALUE hash)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_expandarray(rb_num_t num, rb_num_t flag)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_expandarray(rb_num_t num, rb_num_t flag)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_expandarray(rb_num_t num, rb_num_t flag)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_expandarray(rb_num_t num, rb_num_t flag)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_expandarray(rb_num_t num, rb_num_t flag)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_expandarray(rb_num_t num, rb_num_t flag)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_expandarray(rb_num_t num, rb_num_t flag)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_expandarray(rb_num_t num, rb_num_t flag)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_expandarray(rb_num_t num, rb_num_t flag)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_concatarray(void)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_concatarray(void)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_concatarray(void)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_concatarray(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_concatarray(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_concatarray(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_concatarray(void)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_concatarray(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_concatarray(void)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_splatarray(VALUE flag)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_splatarray(VALUE flag)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_splatarray(VALUE flag)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_splatarray(VALUE flag)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_splatarray(VALUE flag)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_splatarray(VALUE flag)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_splatarray(VALUE flag)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_splatarray(VALUE flag)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_splatarray(VALUE flag)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_newhash(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_newhash(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_newhash(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_newhash(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_newhash(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_newhash(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_newhash(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_newhash(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_newhash(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_newrange(rb_num_t flag)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_newrange(rb_num_t flag)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_newrange(rb_num_t flag)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_newrange(rb_num_t flag)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_newrange(rb_num_t flag)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_newrange(rb_num_t flag)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_newrange(rb_num_t flag)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_newrange(rb_num_t flag)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_newrange(rb_num_t flag)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_pop(void)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_pop(void)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_pop(void)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_pop(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_pop(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_pop(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_pop(void)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_pop(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_pop(void)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_dup(void)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_dup(void)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_dup(void)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_dup(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_dup(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_dup(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_dup(void)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_dup(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_dup(void)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_dupn(rb_num_t n)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_dupn(rb_num_t n)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_dupn(rb_num_t n)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_dupn(rb_num_t n)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_dupn(rb_num_t n)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_dupn(rb_num_t n)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_dupn(rb_num_t n)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_dupn(rb_num_t n)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_dupn(rb_num_t n)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_swap(void)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_swap(void)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_swap(void)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_swap(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_swap(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_swap(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_swap(void)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_swap(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_swap(void)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_reverse(rb_num_t n)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_reverse(rb_num_t n)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_reverse(rb_num_t n)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_reverse(rb_num_t n)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_reverse(rb_num_t n)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_reverse(rb_num_t n)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_reverse(rb_num_t n)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_reverse(rb_num_t n)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_reverse(rb_num_t n)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_reput(void)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_reput(void)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_reput(void)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_reput(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_reput(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_reput(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_reput(void)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_reput(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_reput(void)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_topn(rb_num_t n)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_topn(rb_num_t n)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_topn(rb_num_t n)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_topn(rb_num_t n)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_topn(rb_num_t n)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_topn(rb_num_t n)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_topn(rb_num_t n)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_topn(rb_num_t n)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_topn(rb_num_t n)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_setn(rb_num_t n)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_setn(rb_num_t n)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_setn(rb_num_t n)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_setn(rb_num_t n)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_setn(rb_num_t n)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_setn(rb_num_t n)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_setn(rb_num_t n)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_setn(rb_num_t n)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_setn(rb_num_t n)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_adjuststack(rb_num_t n)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_adjuststack(rb_num_t n)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_adjuststack(rb_num_t n)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_adjuststack(rb_num_t n)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_adjuststack(rb_num_t n)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_adjuststack(rb_num_t n)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_adjuststack(rb_num_t n)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_adjuststack(rb_num_t n)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_adjuststack(rb_num_t n)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_defined(rb_num_t op_type, VALUE obj, VALUE needstr)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_defined(rb_num_t op_type, VALUE obj, VALUE needstr)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_defined(rb_num_t op_type, VALUE obj, VALUE needstr)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_defined(rb_num_t op_type, VALUE obj, VALUE needstr)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_defined(rb_num_t op_type, VALUE obj, VALUE needstr)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_defined(rb_num_t op_type, VALUE obj, VALUE needstr)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_defined(rb_num_t op_type, VALUE obj, VALUE needstr)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_defined(rb_num_t op_type, VALUE obj, VALUE needstr)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_defined(rb_num_t op_type, VALUE obj, VALUE needstr)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_checkmatch(rb_num_t flag)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_checkmatch(rb_num_t flag)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_checkmatch(rb_num_t flag)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_checkmatch(rb_num_t flag)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_checkmatch(rb_num_t flag)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_checkmatch(rb_num_t flag)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_checkmatch(rb_num_t flag)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_checkmatch(rb_num_t flag)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_checkmatch(rb_num_t flag)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_checkkeyword(lindex_t kw_bits_index, lindex_t keyword_index)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_checkkeyword(lindex_t kw_bits_index, lindex_t keyword_index)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_checkkeyword(lindex_t kw_bits_index, lindex_t keyword_index)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_checkkeyword(lindex_t kw_bits_index, lindex_t keyword_index)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_checkkeyword(lindex_t kw_bits_index, lindex_t keyword_index)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_checkkeyword(lindex_t kw_bits_index, lindex_t keyword_index)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_checkkeyword(lindex_t kw_bits_index, lindex_t keyword_index)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_checkkeyword(lindex_t kw_bits_index, lindex_t keyword_index)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_checkkeyword(lindex_t kw_bits_index, lindex_t keyword_index)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_checktype(rb_num_t type)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_checktype(rb_num_t type)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_checktype(rb_num_t type)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_checktype(rb_num_t type)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_checktype(rb_num_t type)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_checktype(rb_num_t type)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_checktype(rb_num_t type)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_checktype(rb_num_t type)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_checktype(rb_num_t type)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_defineclass(ID id, ISEQ class_iseq, rb_num_t flags)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_defineclass(ID id, ISEQ class_iseq, rb_num_t flags)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_defineclass(ID id, ISEQ class_iseq, rb_num_t flags)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_defineclass(ID id, ISEQ class_iseq, rb_num_t flags)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_defineclass(ID id, ISEQ class_iseq, rb_num_t flags)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_defineclass(ID id, ISEQ class_iseq, rb_num_t flags)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_defineclass(ID id, ISEQ class_iseq, rb_num_t flags)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_defineclass(ID id, ISEQ class_iseq, rb_num_t flags)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_defineclass(ID id, ISEQ class_iseq, rb_num_t flags)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_send(CALL_INFO ci, CALL_CACHE cc, ISEQ blockiseq)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_send(CALL_INFO ci, CALL_CACHE cc, ISEQ blockiseq)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_send(CALL_INFO ci, CALL_CACHE cc, ISEQ blockiseq)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_send(CALL_INFO ci, CALL_CACHE cc, ISEQ blockiseq)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_send(CALL_INFO ci, CALL_CACHE cc, ISEQ blockiseq)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_send(CALL_INFO ci, CALL_CACHE cc, ISEQ blockiseq)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_send(CALL_INFO ci, CALL_CACHE cc, ISEQ blockiseq)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_send(CALL_INFO ci, CALL_CACHE cc, ISEQ blockiseq)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_send(CALL_INFO ci, CALL_CACHE cc, ISEQ blockiseq)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_opt_send_without_block(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_opt_send_without_block(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_opt_send_without_block(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_opt_send_without_block(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_opt_send_without_block(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_opt_send_without_block(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_opt_send_without_block(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_opt_send_without_block(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_opt_send_without_block(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_opt_str_freeze(VALUE str, CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_opt_str_freeze(VALUE str, CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_opt_str_freeze(VALUE str, CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_opt_str_freeze(VALUE str, CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_opt_str_freeze(VALUE str, CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_opt_str_freeze(VALUE str, CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_opt_str_freeze(VALUE str, CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_opt_str_freeze(VALUE str, CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_opt_str_freeze(VALUE str, CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_opt_str_uminus(VALUE str, CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_opt_str_uminus(VALUE str, CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_opt_str_uminus(VALUE str, CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_opt_str_uminus(VALUE str, CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_opt_str_uminus(VALUE str, CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_opt_str_uminus(VALUE str, CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_opt_str_uminus(VALUE str, CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_opt_str_uminus(VALUE str, CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_opt_str_uminus(VALUE str, CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_opt_newarray_max(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_opt_newarray_max(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_opt_newarray_max(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_opt_newarray_max(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_opt_newarray_max(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_opt_newarray_max(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_opt_newarray_max(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_opt_newarray_max(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_opt_newarray_max(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_opt_newarray_min(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_opt_newarray_min(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_opt_newarray_min(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_opt_newarray_min(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_opt_newarray_min(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_opt_newarray_min(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_opt_newarray_min(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_opt_newarray_min(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_opt_newarray_min(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_invokesuper(CALL_INFO ci, CALL_CACHE cc, ISEQ blockiseq)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_invokesuper(CALL_INFO ci, CALL_CACHE cc, ISEQ blockiseq)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_invokesuper(CALL_INFO ci, CALL_CACHE cc, ISEQ blockiseq)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_invokesuper(CALL_INFO ci, CALL_CACHE cc, ISEQ blockiseq)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_invokesuper(CALL_INFO ci, CALL_CACHE cc, ISEQ blockiseq)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_invokesuper(CALL_INFO ci, CALL_CACHE cc, ISEQ blockiseq)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_invokesuper(CALL_INFO ci, CALL_CACHE cc, ISEQ blockiseq)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_invokesuper(CALL_INFO ci, CALL_CACHE cc, ISEQ blockiseq)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_invokesuper(CALL_INFO ci, CALL_CACHE cc, ISEQ blockiseq)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_invokeblock(CALL_INFO ci)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_invokeblock(CALL_INFO ci)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_invokeblock(CALL_INFO ci)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_invokeblock(CALL_INFO ci)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_invokeblock(CALL_INFO ci)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_invokeblock(CALL_INFO ci)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_invokeblock(CALL_INFO ci)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_invokeblock(CALL_INFO ci)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_invokeblock(CALL_INFO ci)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_leave(void)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_leave(void)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_leave(void)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_leave(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_leave(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_leave(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_leave(void)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_leave(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_leave(void)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_throw(rb_num_t throw_state)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_throw(rb_num_t throw_state)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_throw(rb_num_t throw_state)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_throw(rb_num_t throw_state)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_throw(rb_num_t throw_state)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_throw(rb_num_t throw_state)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_throw(rb_num_t throw_state)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_throw(rb_num_t throw_state)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_throw(rb_num_t throw_state)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_jump(OFFSET dst)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_jump(OFFSET dst)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_jump(OFFSET dst)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_jump(OFFSET dst)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_jump(OFFSET dst)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_jump(OFFSET dst)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_jump(OFFSET dst)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_jump(OFFSET dst)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_jump(OFFSET dst)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_branchif(OFFSET dst)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_branchif(OFFSET dst)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_branchif(OFFSET dst)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_branchif(OFFSET dst)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_branchif(OFFSET dst)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_branchif(OFFSET dst)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_branchif(OFFSET dst)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_branchif(OFFSET dst)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_branchif(OFFSET dst)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_branchunless(OFFSET dst)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_branchunless(OFFSET dst)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_branchunless(OFFSET dst)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_branchunless(OFFSET dst)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_branchunless(OFFSET dst)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_branchunless(OFFSET dst)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_branchunless(OFFSET dst)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_branchunless(OFFSET dst)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_branchunless(OFFSET dst)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_branchnil(OFFSET dst)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_branchnil(OFFSET dst)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_branchnil(OFFSET dst)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_branchnil(OFFSET dst)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_branchnil(OFFSET dst)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_branchnil(OFFSET dst)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_branchnil(OFFSET dst)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_branchnil(OFFSET dst)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_branchnil(OFFSET dst)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_opt_getinlinecache(OFFSET dst, IC ic)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_opt_getinlinecache(OFFSET dst, IC ic)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_opt_getinlinecache(OFFSET dst, IC ic)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_opt_getinlinecache(OFFSET dst, IC ic)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_opt_getinlinecache(OFFSET dst, IC ic)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_opt_getinlinecache(OFFSET dst, IC ic)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_opt_getinlinecache(OFFSET dst, IC ic)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_opt_getinlinecache(OFFSET dst, IC ic)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_opt_getinlinecache(OFFSET dst, IC ic)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_opt_setinlinecache(IC ic)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_opt_setinlinecache(IC ic)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_opt_setinlinecache(IC ic)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_opt_setinlinecache(IC ic)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_opt_setinlinecache(IC ic)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_opt_setinlinecache(IC ic)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_opt_setinlinecache(IC ic)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_opt_setinlinecache(IC ic)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_opt_setinlinecache(IC ic)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_once(ISEQ iseq, ISE ise)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_once(ISEQ iseq, ISE ise)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_once(ISEQ iseq, ISE ise)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_once(ISEQ iseq, ISE ise)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_once(ISEQ iseq, ISE ise)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_once(ISEQ iseq, ISE ise)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_once(ISEQ iseq, ISE ise)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_once(ISEQ iseq, ISE ise)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_once(ISEQ iseq, ISE ise)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_opt_case_dispatch(CDHASH hash, OFFSET else_offset)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_opt_case_dispatch(CDHASH hash, OFFSET else_offset)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_opt_case_dispatch(CDHASH hash, OFFSET else_offset)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_opt_case_dispatch(CDHASH hash, OFFSET else_offset)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_opt_case_dispatch(CDHASH hash, OFFSET else_offset)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_opt_case_dispatch(CDHASH hash, OFFSET else_offset)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_opt_case_dispatch(CDHASH hash, OFFSET else_offset)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_opt_case_dispatch(CDHASH hash, OFFSET else_offset)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_opt_case_dispatch(CDHASH hash, OFFSET else_offset)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_opt_plus(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_opt_plus(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_opt_plus(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_opt_plus(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_opt_plus(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_opt_plus(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_opt_plus(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_opt_plus(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_opt_plus(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_opt_minus(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_opt_minus(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_opt_minus(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_opt_minus(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_opt_minus(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_opt_minus(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_opt_minus(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_opt_minus(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_opt_minus(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_opt_mult(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_opt_mult(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_opt_mult(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_opt_mult(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_opt_mult(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_opt_mult(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_opt_mult(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_opt_mult(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_opt_mult(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_opt_div(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_opt_div(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_opt_div(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_opt_div(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_opt_div(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_opt_div(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_opt_div(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_opt_div(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_opt_div(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_opt_mod(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_opt_mod(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_opt_mod(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_opt_mod(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_opt_mod(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_opt_mod(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_opt_mod(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_opt_mod(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_opt_mod(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_opt_eq(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_opt_eq(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_opt_eq(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_opt_eq(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_opt_eq(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_opt_eq(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_opt_eq(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_opt_eq(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_opt_eq(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_opt_neq(CALL_INFO ci_eq, CALL_CACHE cc_eq, CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_opt_neq(CALL_INFO ci_eq, CALL_CACHE cc_eq, CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_opt_neq(CALL_INFO ci_eq, CALL_CACHE cc_eq, CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_opt_neq(CALL_INFO ci_eq, CALL_CACHE cc_eq, CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_opt_neq(CALL_INFO ci_eq, CALL_CACHE cc_eq, CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_opt_neq(CALL_INFO ci_eq, CALL_CACHE cc_eq, CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_opt_neq(CALL_INFO ci_eq, CALL_CACHE cc_eq, CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_opt_neq(CALL_INFO ci_eq, CALL_CACHE cc_eq, CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_opt_neq(CALL_INFO ci_eq, CALL_CACHE cc_eq, CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_opt_lt(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_opt_lt(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_opt_lt(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_opt_lt(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_opt_lt(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_opt_lt(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_opt_lt(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_opt_lt(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_opt_lt(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_opt_le(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_opt_le(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_opt_le(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_opt_le(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_opt_le(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_opt_le(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_opt_le(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_opt_le(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_opt_le(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_opt_gt(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_opt_gt(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_opt_gt(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_opt_gt(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_opt_gt(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_opt_gt(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_opt_gt(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_opt_gt(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_opt_gt(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_opt_ge(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_opt_ge(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_opt_ge(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_opt_ge(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_opt_ge(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_opt_ge(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_opt_ge(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_opt_ge(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_opt_ge(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_opt_ltlt(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_opt_ltlt(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_opt_ltlt(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_opt_ltlt(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_opt_ltlt(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_opt_ltlt(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_opt_ltlt(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_opt_ltlt(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_opt_ltlt(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_opt_and(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_opt_and(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_opt_and(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_opt_and(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_opt_and(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_opt_and(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_opt_and(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_opt_and(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_opt_and(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_opt_or(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_opt_or(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_opt_or(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_opt_or(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_opt_or(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_opt_or(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_opt_or(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_opt_or(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_opt_or(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_opt_aref(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_opt_aref(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_opt_aref(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_opt_aref(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_opt_aref(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_opt_aref(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_opt_aref(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_opt_aref(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_opt_aref(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_opt_aset(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_opt_aset(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_opt_aset(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_opt_aset(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_opt_aset(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_opt_aset(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_opt_aset(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_opt_aset(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_opt_aset(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_opt_aset_with(VALUE key, CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_opt_aset_with(VALUE key, CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_opt_aset_with(VALUE key, CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_opt_aset_with(VALUE key, CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_opt_aset_with(VALUE key, CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_opt_aset_with(VALUE key, CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_opt_aset_with(VALUE key, CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_opt_aset_with(VALUE key, CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_opt_aset_with(VALUE key, CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_opt_aref_with(VALUE key, CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_opt_aref_with(VALUE key, CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_opt_aref_with(VALUE key, CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_opt_aref_with(VALUE key, CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_opt_aref_with(VALUE key, CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_opt_aref_with(VALUE key, CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_opt_aref_with(VALUE key, CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_opt_aref_with(VALUE key, CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_opt_aref_with(VALUE key, CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_opt_length(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_opt_length(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_opt_length(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_opt_length(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_opt_length(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_opt_length(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_opt_length(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_opt_length(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_opt_length(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_opt_size(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_opt_size(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_opt_size(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_opt_size(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_opt_size(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_opt_size(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_opt_size(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_opt_size(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_opt_size(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_opt_empty_p(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_opt_empty_p(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_opt_empty_p(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_opt_empty_p(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_opt_empty_p(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_opt_empty_p(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_opt_empty_p(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_opt_empty_p(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_opt_empty_p(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_opt_succ(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_opt_succ(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_opt_succ(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_opt_succ(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_opt_succ(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_opt_succ(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_opt_succ(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_opt_succ(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_opt_succ(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_opt_not(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_opt_not(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_opt_not(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_opt_not(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_opt_not(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_opt_not(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_opt_not(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_opt_not(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_opt_not(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_opt_regexpmatch1(VALUE recv)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_opt_regexpmatch1(VALUE recv)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_opt_regexpmatch1(VALUE recv)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_opt_regexpmatch1(VALUE recv)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_opt_regexpmatch1(VALUE recv)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_opt_regexpmatch1(VALUE recv)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_opt_regexpmatch1(VALUE recv)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_opt_regexpmatch1(VALUE recv)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_opt_regexpmatch1(VALUE recv)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_opt_regexpmatch2(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_opt_regexpmatch2(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_opt_regexpmatch2(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_opt_regexpmatch2(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_opt_regexpmatch2(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_opt_regexpmatch2(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_opt_regexpmatch2(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_opt_regexpmatch2(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_opt_regexpmatch2(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_opt_call_c_function(rb_insn_func_t funcptr)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_opt_call_c_function(rb_insn_func_t funcptr)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_opt_call_c_function(rb_insn_func_t funcptr)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_opt_call_c_function(rb_insn_func_t funcptr)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_opt_call_c_function(rb_insn_func_t funcptr)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_opt_call_c_function(rb_insn_func_t funcptr)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_opt_call_c_function(rb_insn_func_t funcptr)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_opt_call_c_function(rb_insn_func_t funcptr)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_opt_call_c_function(rb_insn_func_t funcptr)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_bitblt(void)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_bitblt(void)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_bitblt(void)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_bitblt(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_bitblt(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_bitblt(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_bitblt(void)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_bitblt(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_bitblt(void)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_answer(void)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_answer(void)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_answer(void)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_answer(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_answer(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_answer(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_answer(void)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_answer(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_answer(void)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_getlocal_WC_0(lindex_t idx)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_getlocal_WC_0(lindex_t idx)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_getlocal_WC_0(lindex_t idx)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_getlocal_WC_0(lindex_t idx)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_getlocal_WC_0(lindex_t idx)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_getlocal_WC_0(lindex_t idx)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_getlocal_WC_0(lindex_t idx)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_getlocal_WC_0(lindex_t idx)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_getlocal_WC_0(lindex_t idx)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_getlocal_WC_1(lindex_t idx)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_getlocal_WC_1(lindex_t idx)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_getlocal_WC_1(lindex_t idx)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_getlocal_WC_1(lindex_t idx)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_getlocal_WC_1(lindex_t idx)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_getlocal_WC_1(lindex_t idx)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_getlocal_WC_1(lindex_t idx)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_getlocal_WC_1(lindex_t idx)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_getlocal_WC_1(lindex_t idx)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_setlocal_WC_0(lindex_t idx)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_setlocal_WC_0(lindex_t idx)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_setlocal_WC_0(lindex_t idx)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_setlocal_WC_0(lindex_t idx)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_setlocal_WC_0(lindex_t idx)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_setlocal_WC_0(lindex_t idx)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_setlocal_WC_0(lindex_t idx)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_setlocal_WC_0(lindex_t idx)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_setlocal_WC_0(lindex_t idx)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_setlocal_WC_1(lindex_t idx)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_setlocal_WC_1(lindex_t idx)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_setlocal_WC_1(lindex_t idx)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_setlocal_WC_1(lindex_t idx)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_setlocal_WC_1(lindex_t idx)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_setlocal_WC_1(lindex_t idx)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_setlocal_WC_1(lindex_t idx)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_setlocal_WC_1(lindex_t idx)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_setlocal_WC_1(lindex_t idx)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_putobject_INT2FIX_0_(void)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_putobject_INT2FIX_0_(void)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_putobject_INT2FIX_0_(void)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_putobject_INT2FIX_0_(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_putobject_INT2FIX_0_(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_putobject_INT2FIX_0_(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_putobject_INT2FIX_0_(void)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_putobject_INT2FIX_0_(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_putobject_INT2FIX_0_(void)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_putobject_INT2FIX_1_(void)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_putobject_INT2FIX_1_(void)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_putobject_INT2FIX_1_(void)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_putobject_INT2FIX_1_(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_putobject_INT2FIX_1_(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_putobject_INT2FIX_1_(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_putobject_INT2FIX_1_(void)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_putobject_INT2FIX_1_(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_putobject_INT2FIX_1_(void)));
/* attr enum ruby_vminsn_type bin @ nop()()() */
enum ruby_vminsn_type
attr_bin_nop(void)
{
return BIN(nop);
}
/* attr bool handles_sp @ nop()()() */
bool
attr_handles_sp_nop(void)
{
return false;
}
/* attr bool leaf @ nop()()() */
bool
attr_leaf_nop(void)
{
return true;
}
/* attr const char* name @ nop()()() */
const char*
attr_name_nop(void)
{
return insn_name(BIN(nop));
}
/* attr rb_num_t open @ nop()()() */
rb_num_t
attr_open_nop(void)
{
return 0;
}
/* attr rb_num_t popn @ nop()()() */
rb_num_t
attr_popn_nop(void)
{
return 0;
}
/* attr rb_num_t retn @ nop()()() */
rb_num_t
attr_retn_nop(void)
{
return 0;
}
/* attr rb_snum_t sp_inc @ nop()()() */
rb_snum_t
attr_sp_inc_nop(void)
{
return 0;
}
/* attr rb_num_t width @ nop()()() */
rb_num_t
attr_width_nop(void)
{
return 1;
}
/* attr enum ruby_vminsn_type bin @ getlocal(idx, level)()(val) */
enum ruby_vminsn_type
attr_bin_getlocal(
MAYBE_UNUSED(lindex_t idx),
MAYBE_UNUSED(rb_num_t level)
)
{
return BIN(getlocal);
}
/* attr bool handles_sp @ getlocal(idx, level)()(val) */
bool
attr_handles_sp_getlocal(
MAYBE_UNUSED(lindex_t idx),
MAYBE_UNUSED(rb_num_t level)
)
{
return false;
}
/* attr bool leaf @ getlocal(idx, level)()(val) */
bool
attr_leaf_getlocal(
MAYBE_UNUSED(lindex_t idx),
MAYBE_UNUSED(rb_num_t level)
)
{
return true;
}
/* attr const char* name @ getlocal(idx, level)()(val) */
const char*
attr_name_getlocal(
MAYBE_UNUSED(lindex_t idx),
MAYBE_UNUSED(rb_num_t level)
)
{
return insn_name(BIN(getlocal));
}
/* attr rb_num_t open @ getlocal(idx, level)()(val) */
rb_num_t
attr_open_getlocal(
MAYBE_UNUSED(lindex_t idx),
MAYBE_UNUSED(rb_num_t level)
)
{
return 2;
}
/* attr rb_num_t popn @ getlocal(idx, level)()(val) */
rb_num_t
attr_popn_getlocal(
MAYBE_UNUSED(lindex_t idx),
MAYBE_UNUSED(rb_num_t level)
)
{
return 0;
}
/* attr rb_num_t retn @ getlocal(idx, level)()(val) */
rb_num_t
attr_retn_getlocal(
MAYBE_UNUSED(lindex_t idx),
MAYBE_UNUSED(rb_num_t level)
)
{
return 1;
}
/* attr rb_snum_t sp_inc @ getlocal(idx, level)()(val) */
rb_snum_t
attr_sp_inc_getlocal(
MAYBE_UNUSED(lindex_t idx),
MAYBE_UNUSED(rb_num_t level)
)
{
return 1;
}
/* attr rb_num_t width @ getlocal(idx, level)()(val) */
rb_num_t
attr_width_getlocal(
MAYBE_UNUSED(lindex_t idx),
MAYBE_UNUSED(rb_num_t level)
)
{
return 3;
}
/* attr enum ruby_vminsn_type bin @ setlocal(idx, level)(val)() */
enum ruby_vminsn_type
attr_bin_setlocal(
MAYBE_UNUSED(lindex_t idx),
MAYBE_UNUSED(rb_num_t level)
)
{
return BIN(setlocal);
}
/* attr bool handles_sp @ setlocal(idx, level)(val)() */
bool
attr_handles_sp_setlocal(
MAYBE_UNUSED(lindex_t idx),
MAYBE_UNUSED(rb_num_t level)
)
{
return false;
}
/* attr bool leaf @ setlocal(idx, level)(val)() */
bool
attr_leaf_setlocal(
MAYBE_UNUSED(lindex_t idx),
MAYBE_UNUSED(rb_num_t level)
)
{
return true;
}
/* attr const char* name @ setlocal(idx, level)(val)() */
const char*
attr_name_setlocal(
MAYBE_UNUSED(lindex_t idx),
MAYBE_UNUSED(rb_num_t level)
)
{
return insn_name(BIN(setlocal));
}
/* attr rb_num_t open @ setlocal(idx, level)(val)() */
rb_num_t
attr_open_setlocal(
MAYBE_UNUSED(lindex_t idx),
MAYBE_UNUSED(rb_num_t level)
)
{
return 2;
}
/* attr rb_num_t popn @ setlocal(idx, level)(val)() */
rb_num_t
attr_popn_setlocal(
MAYBE_UNUSED(lindex_t idx),
MAYBE_UNUSED(rb_num_t level)
)
{
return 1;
}
/* attr rb_num_t retn @ setlocal(idx, level)(val)() */
rb_num_t
attr_retn_setlocal(
MAYBE_UNUSED(lindex_t idx),
MAYBE_UNUSED(rb_num_t level)
)
{
return 0;
}
/* attr rb_snum_t sp_inc @ setlocal(idx, level)(val)() */
rb_snum_t
attr_sp_inc_setlocal(
MAYBE_UNUSED(lindex_t idx),
MAYBE_UNUSED(rb_num_t level)
)
{
return -1;
}
/* attr rb_num_t width @ setlocal(idx, level)(val)() */
rb_num_t
attr_width_setlocal(
MAYBE_UNUSED(lindex_t idx),
MAYBE_UNUSED(rb_num_t level)
)
{
return 3;
}
/* attr enum ruby_vminsn_type bin @ getblockparam(idx, level)()(val) */
enum ruby_vminsn_type
attr_bin_getblockparam(
MAYBE_UNUSED(lindex_t idx),
MAYBE_UNUSED(rb_num_t level)
)
{
return BIN(getblockparam);
}
/* attr bool handles_sp @ getblockparam(idx, level)()(val) */
bool
attr_handles_sp_getblockparam(
MAYBE_UNUSED(lindex_t idx),
MAYBE_UNUSED(rb_num_t level)
)
{
return false;
}
/* attr bool leaf @ getblockparam(idx, level)()(val) */
bool
attr_leaf_getblockparam(
MAYBE_UNUSED(lindex_t idx),
MAYBE_UNUSED(rb_num_t level)
)
{
return true;
}
/* attr const char* name @ getblockparam(idx, level)()(val) */
const char*
attr_name_getblockparam(
MAYBE_UNUSED(lindex_t idx),
MAYBE_UNUSED(rb_num_t level)
)
{
return insn_name(BIN(getblockparam));
}
/* attr rb_num_t open @ getblockparam(idx, level)()(val) */
rb_num_t
attr_open_getblockparam(
MAYBE_UNUSED(lindex_t idx),
MAYBE_UNUSED(rb_num_t level)
)
{
return 2;
}
/* attr rb_num_t popn @ getblockparam(idx, level)()(val) */
rb_num_t
attr_popn_getblockparam(
MAYBE_UNUSED(lindex_t idx),
MAYBE_UNUSED(rb_num_t level)
)
{
return 0;
}
/* attr rb_num_t retn @ getblockparam(idx, level)()(val) */
rb_num_t
attr_retn_getblockparam(
MAYBE_UNUSED(lindex_t idx),
MAYBE_UNUSED(rb_num_t level)
)
{
return 1;
}
/* attr rb_snum_t sp_inc @ getblockparam(idx, level)()(val) */
rb_snum_t
attr_sp_inc_getblockparam(
MAYBE_UNUSED(lindex_t idx),
MAYBE_UNUSED(rb_num_t level)
)
{
return 1;
}
/* attr rb_num_t width @ getblockparam(idx, level)()(val) */
rb_num_t
attr_width_getblockparam(
MAYBE_UNUSED(lindex_t idx),
MAYBE_UNUSED(rb_num_t level)
)
{
return 3;
}
/* attr enum ruby_vminsn_type bin @ setblockparam(idx, level)(val)() */
enum ruby_vminsn_type
attr_bin_setblockparam(
MAYBE_UNUSED(lindex_t idx),
MAYBE_UNUSED(rb_num_t level)
)
{
return BIN(setblockparam);
}
/* attr bool handles_sp @ setblockparam(idx, level)(val)() */
bool
attr_handles_sp_setblockparam(
MAYBE_UNUSED(lindex_t idx),
MAYBE_UNUSED(rb_num_t level)
)
{
return false;
}
/* attr bool leaf @ setblockparam(idx, level)(val)() */
bool
attr_leaf_setblockparam(
MAYBE_UNUSED(lindex_t idx),
MAYBE_UNUSED(rb_num_t level)
)
{
return true;
}
/* attr const char* name @ setblockparam(idx, level)(val)() */
const char*
attr_name_setblockparam(
MAYBE_UNUSED(lindex_t idx),
MAYBE_UNUSED(rb_num_t level)
)
{
return insn_name(BIN(setblockparam));
}
/* attr rb_num_t open @ setblockparam(idx, level)(val)() */
rb_num_t
attr_open_setblockparam(
MAYBE_UNUSED(lindex_t idx),
MAYBE_UNUSED(rb_num_t level)
)
{
return 2;
}
/* attr rb_num_t popn @ setblockparam(idx, level)(val)() */
rb_num_t
attr_popn_setblockparam(
MAYBE_UNUSED(lindex_t idx),
MAYBE_UNUSED(rb_num_t level)
)
{
return 1;
}
/* attr rb_num_t retn @ setblockparam(idx, level)(val)() */
rb_num_t
attr_retn_setblockparam(
MAYBE_UNUSED(lindex_t idx),
MAYBE_UNUSED(rb_num_t level)
)
{
return 0;
}
/* attr rb_snum_t sp_inc @ setblockparam(idx, level)(val)() */
rb_snum_t
attr_sp_inc_setblockparam(
MAYBE_UNUSED(lindex_t idx),
MAYBE_UNUSED(rb_num_t level)
)
{
return -1;
}
/* attr rb_num_t width @ setblockparam(idx, level)(val)() */
rb_num_t
attr_width_setblockparam(
MAYBE_UNUSED(lindex_t idx),
MAYBE_UNUSED(rb_num_t level)
)
{
return 3;
}
/* attr enum ruby_vminsn_type bin @ getblockparamproxy(idx, level)()(val) */
enum ruby_vminsn_type
attr_bin_getblockparamproxy(
MAYBE_UNUSED(lindex_t idx),
MAYBE_UNUSED(rb_num_t level)
)
{
return BIN(getblockparamproxy);
}
/* attr bool handles_sp @ getblockparamproxy(idx, level)()(val) */
bool
attr_handles_sp_getblockparamproxy(
MAYBE_UNUSED(lindex_t idx),
MAYBE_UNUSED(rb_num_t level)
)
{
return false;
}
/* attr bool leaf @ getblockparamproxy(idx, level)()(val) */
bool
attr_leaf_getblockparamproxy(
MAYBE_UNUSED(lindex_t idx),
MAYBE_UNUSED(rb_num_t level)
)
{
return true;
}
/* attr const char* name @ getblockparamproxy(idx, level)()(val) */
const char*
attr_name_getblockparamproxy(
MAYBE_UNUSED(lindex_t idx),
MAYBE_UNUSED(rb_num_t level)
)
{
return insn_name(BIN(getblockparamproxy));
}
/* attr rb_num_t open @ getblockparamproxy(idx, level)()(val) */
rb_num_t
attr_open_getblockparamproxy(
MAYBE_UNUSED(lindex_t idx),
MAYBE_UNUSED(rb_num_t level)
)
{
return 2;
}
/* attr rb_num_t popn @ getblockparamproxy(idx, level)()(val) */
rb_num_t
attr_popn_getblockparamproxy(
MAYBE_UNUSED(lindex_t idx),
MAYBE_UNUSED(rb_num_t level)
)
{
return 0;
}
/* attr rb_num_t retn @ getblockparamproxy(idx, level)()(val) */
rb_num_t
attr_retn_getblockparamproxy(
MAYBE_UNUSED(lindex_t idx),
MAYBE_UNUSED(rb_num_t level)
)
{
return 1;
}
/* attr rb_snum_t sp_inc @ getblockparamproxy(idx, level)()(val) */
rb_snum_t
attr_sp_inc_getblockparamproxy(
MAYBE_UNUSED(lindex_t idx),
MAYBE_UNUSED(rb_num_t level)
)
{
return 1;
}
/* attr rb_num_t width @ getblockparamproxy(idx, level)()(val) */
rb_num_t
attr_width_getblockparamproxy(
MAYBE_UNUSED(lindex_t idx),
MAYBE_UNUSED(rb_num_t level)
)
{
return 3;
}
/* attr enum ruby_vminsn_type bin @ getspecial(key, type)()(val) */
enum ruby_vminsn_type
attr_bin_getspecial(
MAYBE_UNUSED(rb_num_t key),
MAYBE_UNUSED(rb_num_t type)
)
{
return BIN(getspecial);
}
/* attr bool handles_sp @ getspecial(key, type)()(val) */
bool
attr_handles_sp_getspecial(
MAYBE_UNUSED(rb_num_t key),
MAYBE_UNUSED(rb_num_t type)
)
{
return false;
}
/* attr bool leaf @ getspecial(key, type)()(val) */
bool
attr_leaf_getspecial(
MAYBE_UNUSED(rb_num_t key),
MAYBE_UNUSED(rb_num_t type)
)
{
return true;
}
/* attr const char* name @ getspecial(key, type)()(val) */
const char*
attr_name_getspecial(
MAYBE_UNUSED(rb_num_t key),
MAYBE_UNUSED(rb_num_t type)
)
{
return insn_name(BIN(getspecial));
}
/* attr rb_num_t open @ getspecial(key, type)()(val) */
rb_num_t
attr_open_getspecial(
MAYBE_UNUSED(rb_num_t key),
MAYBE_UNUSED(rb_num_t type)
)
{
return 2;
}
/* attr rb_num_t popn @ getspecial(key, type)()(val) */
rb_num_t
attr_popn_getspecial(
MAYBE_UNUSED(rb_num_t key),
MAYBE_UNUSED(rb_num_t type)
)
{
return 0;
}
/* attr rb_num_t retn @ getspecial(key, type)()(val) */
rb_num_t
attr_retn_getspecial(
MAYBE_UNUSED(rb_num_t key),
MAYBE_UNUSED(rb_num_t type)
)
{
return 1;
}
/* attr rb_snum_t sp_inc @ getspecial(key, type)()(val) */
rb_snum_t
attr_sp_inc_getspecial(
MAYBE_UNUSED(rb_num_t key),
MAYBE_UNUSED(rb_num_t type)
)
{
return 1;
}
/* attr rb_num_t width @ getspecial(key, type)()(val) */
rb_num_t
attr_width_getspecial(
MAYBE_UNUSED(rb_num_t key),
MAYBE_UNUSED(rb_num_t type)
)
{
return 3;
}
/* attr enum ruby_vminsn_type bin @ setspecial(key)(obj)() */
enum ruby_vminsn_type
attr_bin_setspecial(MAYBE_UNUSED(rb_num_t key))
{
return BIN(setspecial);
}
/* attr bool handles_sp @ setspecial(key)(obj)() */
bool
attr_handles_sp_setspecial(MAYBE_UNUSED(rb_num_t key))
{
return false;
}
/* attr bool leaf @ setspecial(key)(obj)() */
bool
attr_leaf_setspecial(MAYBE_UNUSED(rb_num_t key))
{
return true;
}
/* attr const char* name @ setspecial(key)(obj)() */
const char*
attr_name_setspecial(MAYBE_UNUSED(rb_num_t key))
{
return insn_name(BIN(setspecial));
}
/* attr rb_num_t open @ setspecial(key)(obj)() */
rb_num_t
attr_open_setspecial(MAYBE_UNUSED(rb_num_t key))
{
return 1;
}
/* attr rb_num_t popn @ setspecial(key)(obj)() */
rb_num_t
attr_popn_setspecial(MAYBE_UNUSED(rb_num_t key))
{
return 1;
}
/* attr rb_num_t retn @ setspecial(key)(obj)() */
rb_num_t
attr_retn_setspecial(MAYBE_UNUSED(rb_num_t key))
{
return 0;
}
/* attr rb_snum_t sp_inc @ setspecial(key)(obj)() */
rb_snum_t
attr_sp_inc_setspecial(MAYBE_UNUSED(rb_num_t key))
{
return -1;
}
/* attr rb_num_t width @ setspecial(key)(obj)() */
rb_num_t
attr_width_setspecial(MAYBE_UNUSED(rb_num_t key))
{
return 2;
}
/* attr enum ruby_vminsn_type bin @ getinstancevariable(id, ic)()(val) */
enum ruby_vminsn_type
attr_bin_getinstancevariable(
MAYBE_UNUSED(ID id),
MAYBE_UNUSED(IC ic)
)
{
return BIN(getinstancevariable);
}
/* attr bool handles_sp @ getinstancevariable(id, ic)()(val) */
bool
attr_handles_sp_getinstancevariable(
MAYBE_UNUSED(ID id),
MAYBE_UNUSED(IC ic)
)
{
return false;
}
/* attr bool leaf @ getinstancevariable(id, ic)()(val) */
bool
attr_leaf_getinstancevariable(
MAYBE_UNUSED(ID id),
MAYBE_UNUSED(IC ic)
)
{
return
#line 212 "insns.def"
false;
#line 2150 "insns_info.inc"
}
/* attr const char* name @ getinstancevariable(id, ic)()(val) */
const char*
attr_name_getinstancevariable(
MAYBE_UNUSED(ID id),
MAYBE_UNUSED(IC ic)
)
{
return insn_name(BIN(getinstancevariable));
}
/* attr rb_num_t open @ getinstancevariable(id, ic)()(val) */
rb_num_t
attr_open_getinstancevariable(
MAYBE_UNUSED(ID id),
MAYBE_UNUSED(IC ic)
)
{
return 2;
}
/* attr rb_num_t popn @ getinstancevariable(id, ic)()(val) */
rb_num_t
attr_popn_getinstancevariable(
MAYBE_UNUSED(ID id),
MAYBE_UNUSED(IC ic)
)
{
return 0;
}
/* attr rb_num_t retn @ getinstancevariable(id, ic)()(val) */
rb_num_t
attr_retn_getinstancevariable(
MAYBE_UNUSED(ID id),
MAYBE_UNUSED(IC ic)
)
{
return 1;
}
/* attr rb_snum_t sp_inc @ getinstancevariable(id, ic)()(val) */
rb_snum_t
attr_sp_inc_getinstancevariable(
MAYBE_UNUSED(ID id),
MAYBE_UNUSED(IC ic)
)
{
return 1;
}
/* attr rb_num_t width @ getinstancevariable(id, ic)()(val) */
rb_num_t
attr_width_getinstancevariable(
MAYBE_UNUSED(ID id),
MAYBE_UNUSED(IC ic)
)
{
return 3;
}
/* attr enum ruby_vminsn_type bin @ setinstancevariable(id, ic)(val)() */
enum ruby_vminsn_type
attr_bin_setinstancevariable(
MAYBE_UNUSED(ID id),
MAYBE_UNUSED(IC ic)
)
{
return BIN(setinstancevariable);
}
/* attr bool handles_sp @ setinstancevariable(id, ic)(val)() */
bool
attr_handles_sp_setinstancevariable(
MAYBE_UNUSED(ID id),
MAYBE_UNUSED(IC ic)
)
{
return false;
}
/* attr bool leaf @ setinstancevariable(id, ic)(val)() */
bool
attr_leaf_setinstancevariable(
MAYBE_UNUSED(ID id),
MAYBE_UNUSED(IC ic)
)
{
return true;
}
/* attr const char* name @ setinstancevariable(id, ic)(val)() */
const char*
attr_name_setinstancevariable(
MAYBE_UNUSED(ID id),
MAYBE_UNUSED(IC ic)
)
{
return insn_name(BIN(setinstancevariable));
}
/* attr rb_num_t open @ setinstancevariable(id, ic)(val)() */
rb_num_t
attr_open_setinstancevariable(
MAYBE_UNUSED(ID id),
MAYBE_UNUSED(IC ic)
)
{
return 2;
}
/* attr rb_num_t popn @ setinstancevariable(id, ic)(val)() */
rb_num_t
attr_popn_setinstancevariable(
MAYBE_UNUSED(ID id),
MAYBE_UNUSED(IC ic)
)
{
return 1;
}
/* attr rb_num_t retn @ setinstancevariable(id, ic)(val)() */
rb_num_t
attr_retn_setinstancevariable(
MAYBE_UNUSED(ID id),
MAYBE_UNUSED(IC ic)
)
{
return 0;
}
/* attr rb_snum_t sp_inc @ setinstancevariable(id, ic)(val)() */
rb_snum_t
attr_sp_inc_setinstancevariable(
MAYBE_UNUSED(ID id),
MAYBE_UNUSED(IC ic)
)
{
return -1;
}
/* attr rb_num_t width @ setinstancevariable(id, ic)(val)() */
rb_num_t
attr_width_setinstancevariable(
MAYBE_UNUSED(ID id),
MAYBE_UNUSED(IC ic)
)
{
return 3;
}
/* attr enum ruby_vminsn_type bin @ getclassvariable(id)()(val) */
enum ruby_vminsn_type
attr_bin_getclassvariable(MAYBE_UNUSED(ID id))
{
return BIN(getclassvariable);
}
/* attr bool handles_sp @ getclassvariable(id)()(val) */
bool
attr_handles_sp_getclassvariable(MAYBE_UNUSED(ID id))
{
return false;
}
/* attr bool leaf @ getclassvariable(id)()(val) */
bool
attr_leaf_getclassvariable(MAYBE_UNUSED(ID id))
{
return
#line 234 "insns.def"
false;
#line 2324 "insns_info.inc"
}
/* attr const char* name @ getclassvariable(id)()(val) */
const char*
attr_name_getclassvariable(MAYBE_UNUSED(ID id))
{
return insn_name(BIN(getclassvariable));
}
/* attr rb_num_t open @ getclassvariable(id)()(val) */
rb_num_t
attr_open_getclassvariable(MAYBE_UNUSED(ID id))
{
return 1;
}
/* attr rb_num_t popn @ getclassvariable(id)()(val) */
rb_num_t
attr_popn_getclassvariable(MAYBE_UNUSED(ID id))
{
return 0;
}
/* attr rb_num_t retn @ getclassvariable(id)()(val) */
rb_num_t
attr_retn_getclassvariable(MAYBE_UNUSED(ID id))
{
return 1;
}
/* attr rb_snum_t sp_inc @ getclassvariable(id)()(val) */
rb_snum_t
attr_sp_inc_getclassvariable(MAYBE_UNUSED(ID id))
{
return 1;
}
/* attr rb_num_t width @ getclassvariable(id)()(val) */
rb_num_t
attr_width_getclassvariable(MAYBE_UNUSED(ID id))
{
return 2;
}
/* attr enum ruby_vminsn_type bin @ setclassvariable(id)(val)() */
enum ruby_vminsn_type
attr_bin_setclassvariable(MAYBE_UNUSED(ID id))
{
return BIN(setclassvariable);
}
/* attr bool handles_sp @ setclassvariable(id)(val)() */
bool
attr_handles_sp_setclassvariable(MAYBE_UNUSED(ID id))
{
return false;
}
/* attr bool leaf @ setclassvariable(id)(val)() */
bool
attr_leaf_setclassvariable(MAYBE_UNUSED(ID id))
{
return
#line 246 "insns.def"
false;
#line 2390 "insns_info.inc"
}
/* attr const char* name @ setclassvariable(id)(val)() */
const char*
attr_name_setclassvariable(MAYBE_UNUSED(ID id))
{
return insn_name(BIN(setclassvariable));
}
/* attr rb_num_t open @ setclassvariable(id)(val)() */
rb_num_t
attr_open_setclassvariable(MAYBE_UNUSED(ID id))
{
return 1;
}
/* attr rb_num_t popn @ setclassvariable(id)(val)() */
rb_num_t
attr_popn_setclassvariable(MAYBE_UNUSED(ID id))
{
return 1;
}
/* attr rb_num_t retn @ setclassvariable(id)(val)() */
rb_num_t
attr_retn_setclassvariable(MAYBE_UNUSED(ID id))
{
return 0;
}
/* attr rb_snum_t sp_inc @ setclassvariable(id)(val)() */
rb_snum_t
attr_sp_inc_setclassvariable(MAYBE_UNUSED(ID id))
{
return -1;
}
/* attr rb_num_t width @ setclassvariable(id)(val)() */
rb_num_t
attr_width_setclassvariable(MAYBE_UNUSED(ID id))
{
return 2;
}
/* attr enum ruby_vminsn_type bin @ getconstant(id)(klass)(val) */
enum ruby_vminsn_type
attr_bin_getconstant(MAYBE_UNUSED(ID id))
{
return BIN(getconstant);
}
/* attr bool handles_sp @ getconstant(id)(klass)(val) */
bool
attr_handles_sp_getconstant(MAYBE_UNUSED(ID id))
{
return false;
}
/* attr bool leaf @ getconstant(id)(klass)(val) */
bool
attr_leaf_getconstant(MAYBE_UNUSED(ID id))
{
return
#line 262 "insns.def"
false;
#line 2456 "insns_info.inc"
}
/* attr const char* name @ getconstant(id)(klass)(val) */
const char*
attr_name_getconstant(MAYBE_UNUSED(ID id))
{
return insn_name(BIN(getconstant));
}
/* attr rb_num_t open @ getconstant(id)(klass)(val) */
rb_num_t
attr_open_getconstant(MAYBE_UNUSED(ID id))
{
return 1;
}
/* attr rb_num_t popn @ getconstant(id)(klass)(val) */
rb_num_t
attr_popn_getconstant(MAYBE_UNUSED(ID id))
{
return 1;
}
/* attr rb_num_t retn @ getconstant(id)(klass)(val) */
rb_num_t
attr_retn_getconstant(MAYBE_UNUSED(ID id))
{
return 1;
}
/* attr rb_snum_t sp_inc @ getconstant(id)(klass)(val) */
rb_snum_t
attr_sp_inc_getconstant(MAYBE_UNUSED(ID id))
{
return 0;
}
/* attr rb_num_t width @ getconstant(id)(klass)(val) */
rb_num_t
attr_width_getconstant(MAYBE_UNUSED(ID id))
{
return 2;
}
/* attr enum ruby_vminsn_type bin @ setconstant(id)(val, cbase)() */
enum ruby_vminsn_type
attr_bin_setconstant(MAYBE_UNUSED(ID id))
{
return BIN(setconstant);
}
/* attr bool handles_sp @ setconstant(id)(val, cbase)() */
bool
attr_handles_sp_setconstant(MAYBE_UNUSED(ID id))
{
return false;
}
/* attr bool leaf @ setconstant(id)(val, cbase)() */
bool
attr_leaf_setconstant(MAYBE_UNUSED(ID id))
{
return
#line 278 "insns.def"
false;
#line 2522 "insns_info.inc"
}
/* attr const char* name @ setconstant(id)(val, cbase)() */
const char*
attr_name_setconstant(MAYBE_UNUSED(ID id))
{
return insn_name(BIN(setconstant));
}
/* attr rb_num_t open @ setconstant(id)(val, cbase)() */
rb_num_t
attr_open_setconstant(MAYBE_UNUSED(ID id))
{
return 1;
}
/* attr rb_num_t popn @ setconstant(id)(val, cbase)() */
rb_num_t
attr_popn_setconstant(MAYBE_UNUSED(ID id))
{
return 2;
}
/* attr rb_num_t retn @ setconstant(id)(val, cbase)() */
rb_num_t
attr_retn_setconstant(MAYBE_UNUSED(ID id))
{
return 0;
}
/* attr rb_snum_t sp_inc @ setconstant(id)(val, cbase)() */
rb_snum_t
attr_sp_inc_setconstant(MAYBE_UNUSED(ID id))
{
return -2;
}
/* attr rb_num_t width @ setconstant(id)(val, cbase)() */
rb_num_t
attr_width_setconstant(MAYBE_UNUSED(ID id))
{
return 2;
}
/* attr enum ruby_vminsn_type bin @ getglobal(entry)()(val) */
enum ruby_vminsn_type
attr_bin_getglobal(MAYBE_UNUSED(GENTRY entry))
{
return BIN(getglobal);
}
/* attr bool handles_sp @ getglobal(entry)()(val) */
bool
attr_handles_sp_getglobal(MAYBE_UNUSED(GENTRY entry))
{
return false;
}
/* attr bool leaf @ getglobal(entry)()(val) */
bool
attr_leaf_getglobal(MAYBE_UNUSED(GENTRY entry))
{
return
#line 291 "insns.def"
leafness_of_getglobal(entry);
#line 2588 "insns_info.inc"
}
/* attr const char* name @ getglobal(entry)()(val) */
const char*
attr_name_getglobal(MAYBE_UNUSED(GENTRY entry))
{
return insn_name(BIN(getglobal));
}
/* attr rb_num_t open @ getglobal(entry)()(val) */
rb_num_t
attr_open_getglobal(MAYBE_UNUSED(GENTRY entry))
{
return 1;
}
/* attr rb_num_t popn @ getglobal(entry)()(val) */
rb_num_t
attr_popn_getglobal(MAYBE_UNUSED(GENTRY entry))
{
return 0;
}
/* attr rb_num_t retn @ getglobal(entry)()(val) */
rb_num_t
attr_retn_getglobal(MAYBE_UNUSED(GENTRY entry))
{
return 1;
}
/* attr rb_snum_t sp_inc @ getglobal(entry)()(val) */
rb_snum_t
attr_sp_inc_getglobal(MAYBE_UNUSED(GENTRY entry))
{
return 1;
}
/* attr rb_num_t width @ getglobal(entry)()(val) */
rb_num_t
attr_width_getglobal(MAYBE_UNUSED(GENTRY entry))
{
return 2;
}
/* attr enum ruby_vminsn_type bin @ setglobal(entry)(val)() */
enum ruby_vminsn_type
attr_bin_setglobal(MAYBE_UNUSED(GENTRY entry))
{
return BIN(setglobal);
}
/* attr bool handles_sp @ setglobal(entry)(val)() */
bool
attr_handles_sp_setglobal(MAYBE_UNUSED(GENTRY entry))
{
return false;
}
/* attr bool leaf @ setglobal(entry)(val)() */
bool
attr_leaf_setglobal(MAYBE_UNUSED(GENTRY entry))
{
return
#line 302 "insns.def"
leafness_of_setglobal(entry);
#line 2654 "insns_info.inc"
}
/* attr const char* name @ setglobal(entry)(val)() */
const char*
attr_name_setglobal(MAYBE_UNUSED(GENTRY entry))
{
return insn_name(BIN(setglobal));
}
/* attr rb_num_t open @ setglobal(entry)(val)() */
rb_num_t
attr_open_setglobal(MAYBE_UNUSED(GENTRY entry))
{
return 1;
}
/* attr rb_num_t popn @ setglobal(entry)(val)() */
rb_num_t
attr_popn_setglobal(MAYBE_UNUSED(GENTRY entry))
{
return 1;
}
/* attr rb_num_t retn @ setglobal(entry)(val)() */
rb_num_t
attr_retn_setglobal(MAYBE_UNUSED(GENTRY entry))
{
return 0;
}
/* attr rb_snum_t sp_inc @ setglobal(entry)(val)() */
rb_snum_t
attr_sp_inc_setglobal(MAYBE_UNUSED(GENTRY entry))
{
return -1;
}
/* attr rb_num_t width @ setglobal(entry)(val)() */
rb_num_t
attr_width_setglobal(MAYBE_UNUSED(GENTRY entry))
{
return 2;
}
/* attr enum ruby_vminsn_type bin @ putnil()()(val) */
enum ruby_vminsn_type
attr_bin_putnil(void)
{
return BIN(putnil);
}
/* attr bool handles_sp @ putnil()()(val) */
bool
attr_handles_sp_putnil(void)
{
return false;
}
/* attr bool leaf @ putnil()()(val) */
bool
attr_leaf_putnil(void)
{
return true;
}
/* attr const char* name @ putnil()()(val) */
const char*
attr_name_putnil(void)
{
return insn_name(BIN(putnil));
}
/* attr rb_num_t open @ putnil()()(val) */
rb_num_t
attr_open_putnil(void)
{
return 0;
}
/* attr rb_num_t popn @ putnil()()(val) */
rb_num_t
attr_popn_putnil(void)
{
return 0;
}
/* attr rb_num_t retn @ putnil()()(val) */
rb_num_t
attr_retn_putnil(void)
{
return 1;
}
/* attr rb_snum_t sp_inc @ putnil()()(val) */
rb_snum_t
attr_sp_inc_putnil(void)
{
return 1;
}
/* attr rb_num_t width @ putnil()()(val) */
rb_num_t
attr_width_putnil(void)
{
return 1;
}
/* attr enum ruby_vminsn_type bin @ putself()()(val) */
enum ruby_vminsn_type
attr_bin_putself(void)
{
return BIN(putself);
}
/* attr bool handles_sp @ putself()()(val) */
bool
attr_handles_sp_putself(void)
{
return false;
}
/* attr bool leaf @ putself()()(val) */
bool
attr_leaf_putself(void)
{
return true;
}
/* attr const char* name @ putself()()(val) */
const char*
attr_name_putself(void)
{
return insn_name(BIN(putself));
}
/* attr rb_num_t open @ putself()()(val) */
rb_num_t
attr_open_putself(void)
{
return 0;
}
/* attr rb_num_t popn @ putself()()(val) */
rb_num_t
attr_popn_putself(void)
{
return 0;
}
/* attr rb_num_t retn @ putself()()(val) */
rb_num_t
attr_retn_putself(void)
{
return 1;
}
/* attr rb_snum_t sp_inc @ putself()()(val) */
rb_snum_t
attr_sp_inc_putself(void)
{
return 1;
}
/* attr rb_num_t width @ putself()()(val) */
rb_num_t
attr_width_putself(void)
{
return 1;
}
/* attr enum ruby_vminsn_type bin @ putobject(val)()(val) */
enum ruby_vminsn_type
attr_bin_putobject(MAYBE_UNUSED(VALUE val))
{
return BIN(putobject);
}
/* attr bool handles_sp @ putobject(val)()(val) */
bool
attr_handles_sp_putobject(MAYBE_UNUSED(VALUE val))
{
return false;
}
/* attr bool leaf @ putobject(val)()(val) */
bool
attr_leaf_putobject(MAYBE_UNUSED(VALUE val))
{
return true;
}
/* attr const char* name @ putobject(val)()(val) */
const char*
attr_name_putobject(MAYBE_UNUSED(VALUE val))
{
return insn_name(BIN(putobject));
}
/* attr rb_num_t open @ putobject(val)()(val) */
rb_num_t
attr_open_putobject(MAYBE_UNUSED(VALUE val))
{
return 1;
}
/* attr rb_num_t popn @ putobject(val)()(val) */
rb_num_t
attr_popn_putobject(MAYBE_UNUSED(VALUE val))
{
return 0;
}
/* attr rb_num_t retn @ putobject(val)()(val) */
rb_num_t
attr_retn_putobject(MAYBE_UNUSED(VALUE val))
{
return 1;
}
/* attr rb_snum_t sp_inc @ putobject(val)()(val) */
rb_snum_t
attr_sp_inc_putobject(MAYBE_UNUSED(VALUE val))
{
return 1;
}
/* attr rb_num_t width @ putobject(val)()(val) */
rb_num_t
attr_width_putobject(MAYBE_UNUSED(VALUE val))
{
return 2;
}
/* attr enum ruby_vminsn_type bin @ putspecialobject(value_type)()(val) */
enum ruby_vminsn_type
attr_bin_putspecialobject(MAYBE_UNUSED(rb_num_t value_type))
{
return BIN(putspecialobject);
}
/* attr bool handles_sp @ putspecialobject(value_type)()(val) */
bool
attr_handles_sp_putspecialobject(MAYBE_UNUSED(rb_num_t value_type))
{
return false;
}
/* attr bool leaf @ putspecialobject(value_type)()(val) */
bool
attr_leaf_putspecialobject(MAYBE_UNUSED(rb_num_t value_type))
{
return true;
}
/* attr const char* name @ putspecialobject(value_type)()(val) */
const char*
attr_name_putspecialobject(MAYBE_UNUSED(rb_num_t value_type))
{
return insn_name(BIN(putspecialobject));
}
/* attr rb_num_t open @ putspecialobject(value_type)()(val) */
rb_num_t
attr_open_putspecialobject(MAYBE_UNUSED(rb_num_t value_type))
{
return 1;
}
/* attr rb_num_t popn @ putspecialobject(value_type)()(val) */
rb_num_t
attr_popn_putspecialobject(MAYBE_UNUSED(rb_num_t value_type))
{
return 0;
}
/* attr rb_num_t retn @ putspecialobject(value_type)()(val) */
rb_num_t
attr_retn_putspecialobject(MAYBE_UNUSED(rb_num_t value_type))
{
return 1;
}
/* attr rb_snum_t sp_inc @ putspecialobject(value_type)()(val) */
rb_snum_t
attr_sp_inc_putspecialobject(MAYBE_UNUSED(rb_num_t value_type))
{
return 1;
}
/* attr rb_num_t width @ putspecialobject(value_type)()(val) */
rb_num_t
attr_width_putspecialobject(MAYBE_UNUSED(rb_num_t value_type))
{
return 2;
}
/* attr enum ruby_vminsn_type bin @ putiseq(iseq)()(ret) */
enum ruby_vminsn_type
attr_bin_putiseq(MAYBE_UNUSED(ISEQ iseq))
{
return BIN(putiseq);
}
/* attr bool handles_sp @ putiseq(iseq)()(ret) */
bool
attr_handles_sp_putiseq(MAYBE_UNUSED(ISEQ iseq))
{
return
#line 362 "insns.def"
false;
#line 2965 "insns_info.inc"
}
/* attr bool leaf @ putiseq(iseq)()(ret) */
bool
attr_leaf_putiseq(MAYBE_UNUSED(ISEQ iseq))
{
return true;
}
/* attr const char* name @ putiseq(iseq)()(ret) */
const char*
attr_name_putiseq(MAYBE_UNUSED(ISEQ iseq))
{
return insn_name(BIN(putiseq));
}
/* attr rb_num_t open @ putiseq(iseq)()(ret) */
rb_num_t
attr_open_putiseq(MAYBE_UNUSED(ISEQ iseq))
{
return 1;
}
/* attr rb_num_t popn @ putiseq(iseq)()(ret) */
rb_num_t
attr_popn_putiseq(MAYBE_UNUSED(ISEQ iseq))
{
return 0;
}
/* attr rb_num_t retn @ putiseq(iseq)()(ret) */
rb_num_t
attr_retn_putiseq(MAYBE_UNUSED(ISEQ iseq))
{
return 1;
}
/* attr rb_snum_t sp_inc @ putiseq(iseq)()(ret) */
rb_snum_t
attr_sp_inc_putiseq(MAYBE_UNUSED(ISEQ iseq))
{
return 1;
}
/* attr rb_num_t width @ putiseq(iseq)()(ret) */
rb_num_t
attr_width_putiseq(MAYBE_UNUSED(ISEQ iseq))
{
return 2;
}
/* attr enum ruby_vminsn_type bin @ putstring(str)()(val) */
enum ruby_vminsn_type
attr_bin_putstring(MAYBE_UNUSED(VALUE str))
{
return BIN(putstring);
}
/* attr bool handles_sp @ putstring(str)()(val) */
bool
attr_handles_sp_putstring(MAYBE_UNUSED(VALUE str))
{
return false;
}
/* attr bool leaf @ putstring(str)()(val) */
bool
attr_leaf_putstring(MAYBE_UNUSED(VALUE str))
{
return true;
}
/* attr const char* name @ putstring(str)()(val) */
const char*
attr_name_putstring(MAYBE_UNUSED(VALUE str))
{
return insn_name(BIN(putstring));
}
/* attr rb_num_t open @ putstring(str)()(val) */
rb_num_t
attr_open_putstring(MAYBE_UNUSED(VALUE str))
{
return 1;
}
/* attr rb_num_t popn @ putstring(str)()(val) */
rb_num_t
attr_popn_putstring(MAYBE_UNUSED(VALUE str))
{
return 0;
}
/* attr rb_num_t retn @ putstring(str)()(val) */
rb_num_t
attr_retn_putstring(MAYBE_UNUSED(VALUE str))
{
return 1;
}
/* attr rb_snum_t sp_inc @ putstring(str)()(val) */
rb_snum_t
attr_sp_inc_putstring(MAYBE_UNUSED(VALUE str))
{
return 1;
}
/* attr rb_num_t width @ putstring(str)()(val) */
rb_num_t
attr_width_putstring(MAYBE_UNUSED(VALUE str))
{
return 2;
}
/* attr enum ruby_vminsn_type bin @ concatstrings(num)(...)(val) */
enum ruby_vminsn_type
attr_bin_concatstrings(MAYBE_UNUSED(rb_num_t num))
{
return BIN(concatstrings);
}
/* attr bool handles_sp @ concatstrings(num)(...)(val) */
bool
attr_handles_sp_concatstrings(MAYBE_UNUSED(rb_num_t num))
{
return false;
}
/* attr bool leaf @ concatstrings(num)(...)(val) */
bool
attr_leaf_concatstrings(MAYBE_UNUSED(rb_num_t num))
{
return true;
}
/* attr const char* name @ concatstrings(num)(...)(val) */
const char*
attr_name_concatstrings(MAYBE_UNUSED(rb_num_t num))
{
return insn_name(BIN(concatstrings));
}
/* attr rb_num_t open @ concatstrings(num)(...)(val) */
rb_num_t
attr_open_concatstrings(MAYBE_UNUSED(rb_num_t num))
{
return 1;
}
/* attr rb_num_t popn @ concatstrings(num)(...)(val) */
rb_num_t
attr_popn_concatstrings(MAYBE_UNUSED(rb_num_t num))
{
return 0;
}
/* attr rb_num_t retn @ concatstrings(num)(...)(val) */
rb_num_t
attr_retn_concatstrings(MAYBE_UNUSED(rb_num_t num))
{
return 1;
}
/* attr rb_snum_t sp_inc @ concatstrings(num)(...)(val) */
rb_snum_t
attr_sp_inc_concatstrings(MAYBE_UNUSED(rb_num_t num))
{
return
#line 383 "insns.def"
1 - (rb_snum_t)num;
#line 3136 "insns_info.inc"
}
/* attr rb_num_t width @ concatstrings(num)(...)(val) */
rb_num_t
attr_width_concatstrings(MAYBE_UNUSED(rb_num_t num))
{
return 2;
}
/* attr enum ruby_vminsn_type bin @ tostring()(val, str)(val) */
enum ruby_vminsn_type
attr_bin_tostring(void)
{
return BIN(tostring);
}
/* attr bool handles_sp @ tostring()(val, str)(val) */
bool
attr_handles_sp_tostring(void)
{
return false;
}
/* attr bool leaf @ tostring()(val, str)(val) */
bool
attr_leaf_tostring(void)
{
return true;
}
/* attr const char* name @ tostring()(val, str)(val) */
const char*
attr_name_tostring(void)
{
return insn_name(BIN(tostring));
}
/* attr rb_num_t open @ tostring()(val, str)(val) */
rb_num_t
attr_open_tostring(void)
{
return 0;
}
/* attr rb_num_t popn @ tostring()(val, str)(val) */
rb_num_t
attr_popn_tostring(void)
{
return 2;
}
/* attr rb_num_t retn @ tostring()(val, str)(val) */
rb_num_t
attr_retn_tostring(void)
{
return 1;
}
/* attr rb_snum_t sp_inc @ tostring()(val, str)(val) */
rb_snum_t
attr_sp_inc_tostring(void)
{
return -1;
}
/* attr rb_num_t width @ tostring()(val, str)(val) */
rb_num_t
attr_width_tostring(void)
{
return 1;
}
/* attr enum ruby_vminsn_type bin @ freezestring(debug_info)(str)(str) */
enum ruby_vminsn_type
attr_bin_freezestring(MAYBE_UNUSED(VALUE debug_info))
{
return BIN(freezestring);
}
/* attr bool handles_sp @ freezestring(debug_info)(str)(str) */
bool
attr_handles_sp_freezestring(MAYBE_UNUSED(VALUE debug_info))
{
return false;
}
/* attr bool leaf @ freezestring(debug_info)(str)(str) */
bool
attr_leaf_freezestring(MAYBE_UNUSED(VALUE debug_info))
{
return true;
}
/* attr const char* name @ freezestring(debug_info)(str)(str) */
const char*
attr_name_freezestring(MAYBE_UNUSED(VALUE debug_info))
{
return insn_name(BIN(freezestring));
}
/* attr rb_num_t open @ freezestring(debug_info)(str)(str) */
rb_num_t
attr_open_freezestring(MAYBE_UNUSED(VALUE debug_info))
{
return 1;
}
/* attr rb_num_t popn @ freezestring(debug_info)(str)(str) */
rb_num_t
attr_popn_freezestring(MAYBE_UNUSED(VALUE debug_info))
{
return 1;
}
/* attr rb_num_t retn @ freezestring(debug_info)(str)(str) */
rb_num_t
attr_retn_freezestring(MAYBE_UNUSED(VALUE debug_info))
{
return 1;
}
/* attr rb_snum_t sp_inc @ freezestring(debug_info)(str)(str) */
rb_snum_t
attr_sp_inc_freezestring(MAYBE_UNUSED(VALUE debug_info))
{
return 0;
}
/* attr rb_num_t width @ freezestring(debug_info)(str)(str) */
rb_num_t
attr_width_freezestring(MAYBE_UNUSED(VALUE debug_info))
{
return 2;
}
/* attr enum ruby_vminsn_type bin @ toregexp(opt, cnt)(...)(val) */
enum ruby_vminsn_type
attr_bin_toregexp(
MAYBE_UNUSED(rb_num_t opt),
MAYBE_UNUSED(rb_num_t cnt)
)
{
return BIN(toregexp);
}
/* attr bool handles_sp @ toregexp(opt, cnt)(...)(val) */
bool
attr_handles_sp_toregexp(
MAYBE_UNUSED(rb_num_t opt),
MAYBE_UNUSED(rb_num_t cnt)
)
{
return false;
}
/* attr bool leaf @ toregexp(opt, cnt)(...)(val) */
bool
attr_leaf_toregexp(
MAYBE_UNUSED(rb_num_t opt),
MAYBE_UNUSED(rb_num_t cnt)
)
{
return
#line 418 "insns.def"
true;
#line 3302 "insns_info.inc"
}
/* attr const char* name @ toregexp(opt, cnt)(...)(val) */
const char*
attr_name_toregexp(
MAYBE_UNUSED(rb_num_t opt),
MAYBE_UNUSED(rb_num_t cnt)
)
{
return insn_name(BIN(toregexp));
}
/* attr rb_num_t open @ toregexp(opt, cnt)(...)(val) */
rb_num_t
attr_open_toregexp(
MAYBE_UNUSED(rb_num_t opt),
MAYBE_UNUSED(rb_num_t cnt)
)
{
return 2;
}
/* attr rb_num_t popn @ toregexp(opt, cnt)(...)(val) */
rb_num_t
attr_popn_toregexp(
MAYBE_UNUSED(rb_num_t opt),
MAYBE_UNUSED(rb_num_t cnt)
)
{
return 0;
}
/* attr rb_num_t retn @ toregexp(opt, cnt)(...)(val) */
rb_num_t
attr_retn_toregexp(
MAYBE_UNUSED(rb_num_t opt),
MAYBE_UNUSED(rb_num_t cnt)
)
{
return 1;
}
/* attr rb_snum_t sp_inc @ toregexp(opt, cnt)(...)(val) */
rb_snum_t
attr_sp_inc_toregexp(
MAYBE_UNUSED(rb_num_t opt),
MAYBE_UNUSED(rb_num_t cnt)
)
{
return
#line 419 "insns.def"
1 - (rb_snum_t)cnt;
#line 3355 "insns_info.inc"
}
/* attr rb_num_t width @ toregexp(opt, cnt)(...)(val) */
rb_num_t
attr_width_toregexp(
MAYBE_UNUSED(rb_num_t opt),
MAYBE_UNUSED(rb_num_t cnt)
)
{
return 3;
}
/* attr enum ruby_vminsn_type bin @ intern()(str)(sym) */
enum ruby_vminsn_type
attr_bin_intern(void)
{
return BIN(intern);
}
/* attr bool handles_sp @ intern()(str)(sym) */
bool
attr_handles_sp_intern(void)
{
return false;
}
/* attr bool leaf @ intern()(str)(sym) */
bool
attr_leaf_intern(void)
{
return true;
}
/* attr const char* name @ intern()(str)(sym) */
const char*
attr_name_intern(void)
{
return insn_name(BIN(intern));
}
/* attr rb_num_t open @ intern()(str)(sym) */
rb_num_t
attr_open_intern(void)
{
return 0;
}
/* attr rb_num_t popn @ intern()(str)(sym) */
rb_num_t
attr_popn_intern(void)
{
return 1;
}
/* attr rb_num_t retn @ intern()(str)(sym) */
rb_num_t
attr_retn_intern(void)
{
return 1;
}
/* attr rb_snum_t sp_inc @ intern()(str)(sym) */
rb_snum_t
attr_sp_inc_intern(void)
{
return 0;
}
/* attr rb_num_t width @ intern()(str)(sym) */
rb_num_t
attr_width_intern(void)
{
return 1;
}
/* attr enum ruby_vminsn_type bin @ newarray(num)(...)(val) */
enum ruby_vminsn_type
attr_bin_newarray(MAYBE_UNUSED(rb_num_t num))
{
return BIN(newarray);
}
/* attr bool handles_sp @ newarray(num)(...)(val) */
bool
attr_handles_sp_newarray(MAYBE_UNUSED(rb_num_t num))
{
return false;
}
/* attr bool leaf @ newarray(num)(...)(val) */
bool
attr_leaf_newarray(MAYBE_UNUSED(rb_num_t num))
{
return true;
}
/* attr const char* name @ newarray(num)(...)(val) */
const char*
attr_name_newarray(MAYBE_UNUSED(rb_num_t num))
{
return insn_name(BIN(newarray));
}
/* attr rb_num_t open @ newarray(num)(...)(val) */
rb_num_t
attr_open_newarray(MAYBE_UNUSED(rb_num_t num))
{
return 1;
}
/* attr rb_num_t popn @ newarray(num)(...)(val) */
rb_num_t
attr_popn_newarray(MAYBE_UNUSED(rb_num_t num))
{
return 0;
}
/* attr rb_num_t retn @ newarray(num)(...)(val) */
rb_num_t
attr_retn_newarray(MAYBE_UNUSED(rb_num_t num))
{
return 1;
}
/* attr rb_snum_t sp_inc @ newarray(num)(...)(val) */
rb_snum_t
attr_sp_inc_newarray(MAYBE_UNUSED(rb_num_t num))
{
return
#line 442 "insns.def"
1 - (rb_snum_t)num;
#line 3487 "insns_info.inc"
}
/* attr rb_num_t width @ newarray(num)(...)(val) */
rb_num_t
attr_width_newarray(MAYBE_UNUSED(rb_num_t num))
{
return 2;
}
/* attr enum ruby_vminsn_type bin @ duparray(ary)()(val) */
enum ruby_vminsn_type
attr_bin_duparray(MAYBE_UNUSED(VALUE ary))
{
return BIN(duparray);
}
/* attr bool handles_sp @ duparray(ary)()(val) */
bool
attr_handles_sp_duparray(MAYBE_UNUSED(VALUE ary))
{
return false;
}
/* attr bool leaf @ duparray(ary)()(val) */
bool
attr_leaf_duparray(MAYBE_UNUSED(VALUE ary))
{
return true;
}
/* attr const char* name @ duparray(ary)()(val) */
const char*
attr_name_duparray(MAYBE_UNUSED(VALUE ary))
{
return insn_name(BIN(duparray));
}
/* attr rb_num_t open @ duparray(ary)()(val) */
rb_num_t
attr_open_duparray(MAYBE_UNUSED(VALUE ary))
{
return 1;
}
/* attr rb_num_t popn @ duparray(ary)()(val) */
rb_num_t
attr_popn_duparray(MAYBE_UNUSED(VALUE ary))
{
return 0;
}
/* attr rb_num_t retn @ duparray(ary)()(val) */
rb_num_t
attr_retn_duparray(MAYBE_UNUSED(VALUE ary))
{
return 1;
}
/* attr rb_snum_t sp_inc @ duparray(ary)()(val) */
rb_snum_t
attr_sp_inc_duparray(MAYBE_UNUSED(VALUE ary))
{
return 1;
}
/* attr rb_num_t width @ duparray(ary)()(val) */
rb_num_t
attr_width_duparray(MAYBE_UNUSED(VALUE ary))
{
return 2;
}
/* attr enum ruby_vminsn_type bin @ duphash(hash)()(val) */
enum ruby_vminsn_type
attr_bin_duphash(MAYBE_UNUSED(VALUE hash))
{
return BIN(duphash);
}
/* attr bool handles_sp @ duphash(hash)()(val) */
bool
attr_handles_sp_duphash(MAYBE_UNUSED(VALUE hash))
{
return false;
}
/* attr bool leaf @ duphash(hash)()(val) */
bool
attr_leaf_duphash(MAYBE_UNUSED(VALUE hash))
{
return true;
}
/* attr const char* name @ duphash(hash)()(val) */
const char*
attr_name_duphash(MAYBE_UNUSED(VALUE hash))
{
return insn_name(BIN(duphash));
}
/* attr rb_num_t open @ duphash(hash)()(val) */
rb_num_t
attr_open_duphash(MAYBE_UNUSED(VALUE hash))
{
return 1;
}
/* attr rb_num_t popn @ duphash(hash)()(val) */
rb_num_t
attr_popn_duphash(MAYBE_UNUSED(VALUE hash))
{
return 0;
}
/* attr rb_num_t retn @ duphash(hash)()(val) */
rb_num_t
attr_retn_duphash(MAYBE_UNUSED(VALUE hash))
{
return 1;
}
/* attr rb_snum_t sp_inc @ duphash(hash)()(val) */
rb_snum_t
attr_sp_inc_duphash(MAYBE_UNUSED(VALUE hash))
{
return 1;
}
/* attr rb_num_t width @ duphash(hash)()(val) */
rb_num_t
attr_width_duphash(MAYBE_UNUSED(VALUE hash))
{
return 2;
}
/* attr enum ruby_vminsn_type bin @ expandarray(num, flag)(..., ary)(...) */
enum ruby_vminsn_type
attr_bin_expandarray(
MAYBE_UNUSED(rb_num_t num),
MAYBE_UNUSED(rb_num_t flag)
)
{
return BIN(expandarray);
}
/* attr bool handles_sp @ expandarray(num, flag)(..., ary)(...) */
bool
attr_handles_sp_expandarray(
MAYBE_UNUSED(rb_num_t num),
MAYBE_UNUSED(rb_num_t flag)
)
{
return false;
}
/* attr bool leaf @ expandarray(num, flag)(..., ary)(...) */
bool
attr_leaf_expandarray(
MAYBE_UNUSED(rb_num_t num),
MAYBE_UNUSED(rb_num_t flag)
)
{
return
#line 483 "insns.def"
false;
#line 3653 "insns_info.inc"
}
/* attr const char* name @ expandarray(num, flag)(..., ary)(...) */
const char*
attr_name_expandarray(
MAYBE_UNUSED(rb_num_t num),
MAYBE_UNUSED(rb_num_t flag)
)
{
return insn_name(BIN(expandarray));
}
/* attr rb_num_t open @ expandarray(num, flag)(..., ary)(...) */
rb_num_t
attr_open_expandarray(
MAYBE_UNUSED(rb_num_t num),
MAYBE_UNUSED(rb_num_t flag)
)
{
return 2;
}
/* attr rb_num_t popn @ expandarray(num, flag)(..., ary)(...) */
rb_num_t
attr_popn_expandarray(
MAYBE_UNUSED(rb_num_t num),
MAYBE_UNUSED(rb_num_t flag)
)
{
return 1;
}
/* attr rb_num_t retn @ expandarray(num, flag)(..., ary)(...) */
rb_num_t
attr_retn_expandarray(
MAYBE_UNUSED(rb_num_t num),
MAYBE_UNUSED(rb_num_t flag)
)
{
return 0;
}
/* attr rb_snum_t sp_inc @ expandarray(num, flag)(..., ary)(...) */
rb_snum_t
attr_sp_inc_expandarray(
MAYBE_UNUSED(rb_num_t num),
MAYBE_UNUSED(rb_num_t flag)
)
{
return
#line 484 "insns.def"
(rb_snum_t)num - 1 + (flag & 1 ? 1 : 0);
#line 3706 "insns_info.inc"
}
/* attr rb_num_t width @ expandarray(num, flag)(..., ary)(...) */
rb_num_t
attr_width_expandarray(
MAYBE_UNUSED(rb_num_t num),
MAYBE_UNUSED(rb_num_t flag)
)
{
return 3;
}
/* attr enum ruby_vminsn_type bin @ concatarray()(ary1, ary2)(ary) */
enum ruby_vminsn_type
attr_bin_concatarray(void)
{
return BIN(concatarray);
}
/* attr bool handles_sp @ concatarray()(ary1, ary2)(ary) */
bool
attr_handles_sp_concatarray(void)
{
return false;
}
/* attr bool leaf @ concatarray()(ary1, ary2)(ary) */
bool
attr_leaf_concatarray(void)
{
return
#line 495 "insns.def"
false;
#line 3740 "insns_info.inc"
}
/* attr const char* name @ concatarray()(ary1, ary2)(ary) */
const char*
attr_name_concatarray(void)
{
return insn_name(BIN(concatarray));
}
/* attr rb_num_t open @ concatarray()(ary1, ary2)(ary) */
rb_num_t
attr_open_concatarray(void)
{
return 0;
}
/* attr rb_num_t popn @ concatarray()(ary1, ary2)(ary) */
rb_num_t
attr_popn_concatarray(void)
{
return 2;
}
/* attr rb_num_t retn @ concatarray()(ary1, ary2)(ary) */
rb_num_t
attr_retn_concatarray(void)
{
return 1;
}
/* attr rb_snum_t sp_inc @ concatarray()(ary1, ary2)(ary) */
rb_snum_t
attr_sp_inc_concatarray(void)
{
return -1;
}
/* attr rb_num_t width @ concatarray()(ary1, ary2)(ary) */
rb_num_t
attr_width_concatarray(void)
{
return 1;
}
/* attr enum ruby_vminsn_type bin @ splatarray(flag)(ary)(obj) */
enum ruby_vminsn_type
attr_bin_splatarray(MAYBE_UNUSED(VALUE flag))
{
return BIN(splatarray);
}
/* attr bool handles_sp @ splatarray(flag)(ary)(obj) */
bool
attr_handles_sp_splatarray(MAYBE_UNUSED(VALUE flag))
{
return false;
}
/* attr bool leaf @ splatarray(flag)(ary)(obj) */
bool
attr_leaf_splatarray(MAYBE_UNUSED(VALUE flag))
{
return
#line 506 "insns.def"
false;
#line 3806 "insns_info.inc"
}
/* attr const char* name @ splatarray(flag)(ary)(obj) */
const char*
attr_name_splatarray(MAYBE_UNUSED(VALUE flag))
{
return insn_name(BIN(splatarray));
}
/* attr rb_num_t open @ splatarray(flag)(ary)(obj) */
rb_num_t
attr_open_splatarray(MAYBE_UNUSED(VALUE flag))
{
return 1;
}
/* attr rb_num_t popn @ splatarray(flag)(ary)(obj) */
rb_num_t
attr_popn_splatarray(MAYBE_UNUSED(VALUE flag))
{
return 1;
}
/* attr rb_num_t retn @ splatarray(flag)(ary)(obj) */
rb_num_t
attr_retn_splatarray(MAYBE_UNUSED(VALUE flag))
{
return 1;
}
/* attr rb_snum_t sp_inc @ splatarray(flag)(ary)(obj) */
rb_snum_t
attr_sp_inc_splatarray(MAYBE_UNUSED(VALUE flag))
{
return 0;
}
/* attr rb_num_t width @ splatarray(flag)(ary)(obj) */
rb_num_t
attr_width_splatarray(MAYBE_UNUSED(VALUE flag))
{
return 2;
}
/* attr enum ruby_vminsn_type bin @ newhash(num)(...)(val) */
enum ruby_vminsn_type
attr_bin_newhash(MAYBE_UNUSED(rb_num_t num))
{
return BIN(newhash);
}
/* attr bool handles_sp @ newhash(num)(...)(val) */
bool
attr_handles_sp_newhash(MAYBE_UNUSED(rb_num_t num))
{
return false;
}
/* attr bool leaf @ newhash(num)(...)(val) */
bool
attr_leaf_newhash(MAYBE_UNUSED(rb_num_t num))
{
return
#line 517 "insns.def"
false;
#line 3872 "insns_info.inc"
}
/* attr const char* name @ newhash(num)(...)(val) */
const char*
attr_name_newhash(MAYBE_UNUSED(rb_num_t num))
{
return insn_name(BIN(newhash));
}
/* attr rb_num_t open @ newhash(num)(...)(val) */
rb_num_t
attr_open_newhash(MAYBE_UNUSED(rb_num_t num))
{
return 1;
}
/* attr rb_num_t popn @ newhash(num)(...)(val) */
rb_num_t
attr_popn_newhash(MAYBE_UNUSED(rb_num_t num))
{
return 0;
}
/* attr rb_num_t retn @ newhash(num)(...)(val) */
rb_num_t
attr_retn_newhash(MAYBE_UNUSED(rb_num_t num))
{
return 1;
}
/* attr rb_snum_t sp_inc @ newhash(num)(...)(val) */
rb_snum_t
attr_sp_inc_newhash(MAYBE_UNUSED(rb_num_t num))
{
return
#line 518 "insns.def"
1 - (rb_snum_t)num;
#line 3910 "insns_info.inc"
}
/* attr rb_num_t width @ newhash(num)(...)(val) */
rb_num_t
attr_width_newhash(MAYBE_UNUSED(rb_num_t num))
{
return 2;
}
/* attr enum ruby_vminsn_type bin @ newrange(flag)(low, high)(val) */
enum ruby_vminsn_type
attr_bin_newrange(MAYBE_UNUSED(rb_num_t flag))
{
return BIN(newrange);
}
/* attr bool handles_sp @ newrange(flag)(low, high)(val) */
bool
attr_handles_sp_newrange(MAYBE_UNUSED(rb_num_t flag))
{
return false;
}
/* attr bool leaf @ newrange(flag)(low, high)(val) */
bool
attr_leaf_newrange(MAYBE_UNUSED(rb_num_t flag))
{
return
#line 536 "insns.def"
false;
#line 3941 "insns_info.inc"
}
/* attr const char* name @ newrange(flag)(low, high)(val) */
const char*
attr_name_newrange(MAYBE_UNUSED(rb_num_t flag))
{
return insn_name(BIN(newrange));
}
/* attr rb_num_t open @ newrange(flag)(low, high)(val) */
rb_num_t
attr_open_newrange(MAYBE_UNUSED(rb_num_t flag))
{
return 1;
}
/* attr rb_num_t popn @ newrange(flag)(low, high)(val) */
rb_num_t
attr_popn_newrange(MAYBE_UNUSED(rb_num_t flag))
{
return 2;
}
/* attr rb_num_t retn @ newrange(flag)(low, high)(val) */
rb_num_t
attr_retn_newrange(MAYBE_UNUSED(rb_num_t flag))
{
return 1;
}
/* attr rb_snum_t sp_inc @ newrange(flag)(low, high)(val) */
rb_snum_t
attr_sp_inc_newrange(MAYBE_UNUSED(rb_num_t flag))
{
return -1;
}
/* attr rb_num_t width @ newrange(flag)(low, high)(val) */
rb_num_t
attr_width_newrange(MAYBE_UNUSED(rb_num_t flag))
{
return 2;
}
/* attr enum ruby_vminsn_type bin @ pop()(val)() */
enum ruby_vminsn_type
attr_bin_pop(void)
{
return BIN(pop);
}
/* attr bool handles_sp @ pop()(val)() */
bool
attr_handles_sp_pop(void)
{
return false;
}
/* attr bool leaf @ pop()(val)() */
bool
attr_leaf_pop(void)
{
return true;
}
/* attr const char* name @ pop()(val)() */
const char*
attr_name_pop(void)
{
return insn_name(BIN(pop));
}
/* attr rb_num_t open @ pop()(val)() */
rb_num_t
attr_open_pop(void)
{
return 0;
}
/* attr rb_num_t popn @ pop()(val)() */
rb_num_t
attr_popn_pop(void)
{
return 1;
}
/* attr rb_num_t retn @ pop()(val)() */
rb_num_t
attr_retn_pop(void)
{
return 0;
}
/* attr rb_snum_t sp_inc @ pop()(val)() */
rb_snum_t
attr_sp_inc_pop(void)
{
return -1;
}
/* attr rb_num_t width @ pop()(val)() */
rb_num_t
attr_width_pop(void)
{
return 1;
}
/* attr enum ruby_vminsn_type bin @ dup()(val)(val1, val2) */
enum ruby_vminsn_type
attr_bin_dup(void)
{
return BIN(dup);
}
/* attr bool handles_sp @ dup()(val)(val1, val2) */
bool
attr_handles_sp_dup(void)
{
return false;
}
/* attr bool leaf @ dup()(val)(val1, val2) */
bool
attr_leaf_dup(void)
{
return true;
}
/* attr const char* name @ dup()(val)(val1, val2) */
const char*
attr_name_dup(void)
{
return insn_name(BIN(dup));
}
/* attr rb_num_t open @ dup()(val)(val1, val2) */
rb_num_t
attr_open_dup(void)
{
return 0;
}
/* attr rb_num_t popn @ dup()(val)(val1, val2) */
rb_num_t
attr_popn_dup(void)
{
return 1;
}
/* attr rb_num_t retn @ dup()(val)(val1, val2) */
rb_num_t
attr_retn_dup(void)
{
return 2;
}
/* attr rb_snum_t sp_inc @ dup()(val)(val1, val2) */
rb_snum_t
attr_sp_inc_dup(void)
{
return 1;
}
/* attr rb_num_t width @ dup()(val)(val1, val2) */
rb_num_t
attr_width_dup(void)
{
return 1;
}
/* attr enum ruby_vminsn_type bin @ dupn(n)(...)(...) */
enum ruby_vminsn_type
attr_bin_dupn(MAYBE_UNUSED(rb_num_t n))
{
return BIN(dupn);
}
/* attr bool handles_sp @ dupn(n)(...)(...) */
bool
attr_handles_sp_dupn(MAYBE_UNUSED(rb_num_t n))
{
return false;
}
/* attr bool leaf @ dupn(n)(...)(...) */
bool
attr_leaf_dupn(MAYBE_UNUSED(rb_num_t n))
{
return true;
}
/* attr const char* name @ dupn(n)(...)(...) */
const char*
attr_name_dupn(MAYBE_UNUSED(rb_num_t n))
{
return insn_name(BIN(dupn));
}
/* attr rb_num_t open @ dupn(n)(...)(...) */
rb_num_t
attr_open_dupn(MAYBE_UNUSED(rb_num_t n))
{
return 1;
}
/* attr rb_num_t popn @ dupn(n)(...)(...) */
rb_num_t
attr_popn_dupn(MAYBE_UNUSED(rb_num_t n))
{
return 0;
}
/* attr rb_num_t retn @ dupn(n)(...)(...) */
rb_num_t
attr_retn_dupn(MAYBE_UNUSED(rb_num_t n))
{
return 0;
}
/* attr rb_snum_t sp_inc @ dupn(n)(...)(...) */
rb_snum_t
attr_sp_inc_dupn(MAYBE_UNUSED(rb_num_t n))
{
return
#line 572 "insns.def"
n;
#line 4168 "insns_info.inc"
}
/* attr rb_num_t width @ dupn(n)(...)(...) */
rb_num_t
attr_width_dupn(MAYBE_UNUSED(rb_num_t n))
{
return 2;
}
/* attr enum ruby_vminsn_type bin @ swap()(val, obj)(obj, val) */
enum ruby_vminsn_type
attr_bin_swap(void)
{
return BIN(swap);
}
/* attr bool handles_sp @ swap()(val, obj)(obj, val) */
bool
attr_handles_sp_swap(void)
{
return false;
}
/* attr bool leaf @ swap()(val, obj)(obj, val) */
bool
attr_leaf_swap(void)
{
return true;
}
/* attr const char* name @ swap()(val, obj)(obj, val) */
const char*
attr_name_swap(void)
{
return insn_name(BIN(swap));
}
/* attr rb_num_t open @ swap()(val, obj)(obj, val) */
rb_num_t
attr_open_swap(void)
{
return 0;
}
/* attr rb_num_t popn @ swap()(val, obj)(obj, val) */
rb_num_t
attr_popn_swap(void)
{
return 2;
}
/* attr rb_num_t retn @ swap()(val, obj)(obj, val) */
rb_num_t
attr_retn_swap(void)
{
return 2;
}
/* attr rb_snum_t sp_inc @ swap()(val, obj)(obj, val) */
rb_snum_t
attr_sp_inc_swap(void)
{
return 0;
}
/* attr rb_num_t width @ swap()(val, obj)(obj, val) */
rb_num_t
attr_width_swap(void)
{
return 1;
}
/* attr enum ruby_vminsn_type bin @ reverse(n)(...)(...) */
enum ruby_vminsn_type
attr_bin_reverse(MAYBE_UNUSED(rb_num_t n))
{
return BIN(reverse);
}
/* attr bool handles_sp @ reverse(n)(...)(...) */
bool
attr_handles_sp_reverse(MAYBE_UNUSED(rb_num_t n))
{
return false;
}
/* attr bool leaf @ reverse(n)(...)(...) */
bool
attr_leaf_reverse(MAYBE_UNUSED(rb_num_t n))
{
return true;
}
/* attr const char* name @ reverse(n)(...)(...) */
const char*
attr_name_reverse(MAYBE_UNUSED(rb_num_t n))
{
return insn_name(BIN(reverse));
}
/* attr rb_num_t open @ reverse(n)(...)(...) */
rb_num_t
attr_open_reverse(MAYBE_UNUSED(rb_num_t n))
{
return 1;
}
/* attr rb_num_t popn @ reverse(n)(...)(...) */
rb_num_t
attr_popn_reverse(MAYBE_UNUSED(rb_num_t n))
{
return 0;
}
/* attr rb_num_t retn @ reverse(n)(...)(...) */
rb_num_t
attr_retn_reverse(MAYBE_UNUSED(rb_num_t n))
{
return 0;
}
/* attr rb_snum_t sp_inc @ reverse(n)(...)(...) */
rb_snum_t
attr_sp_inc_reverse(MAYBE_UNUSED(rb_num_t n))
{
return
#line 596 "insns.def"
0;
#line 4297 "insns_info.inc"
}
/* attr rb_num_t width @ reverse(n)(...)(...) */
rb_num_t
attr_width_reverse(MAYBE_UNUSED(rb_num_t n))
{
return 2;
}
/* attr enum ruby_vminsn_type bin @ reput()(..., val)(val) */
enum ruby_vminsn_type
attr_bin_reput(void)
{
return BIN(reput);
}
/* attr bool handles_sp @ reput()(..., val)(val) */
bool
attr_handles_sp_reput(void)
{
return false;
}
/* attr bool leaf @ reput()(..., val)(val) */
bool
attr_leaf_reput(void)
{
return true;
}
/* attr const char* name @ reput()(..., val)(val) */
const char*
attr_name_reput(void)
{
return insn_name(BIN(reput));
}
/* attr rb_num_t open @ reput()(..., val)(val) */
rb_num_t
attr_open_reput(void)
{
return 0;
}
/* attr rb_num_t popn @ reput()(..., val)(val) */
rb_num_t
attr_popn_reput(void)
{
return 1;
}
/* attr rb_num_t retn @ reput()(..., val)(val) */
rb_num_t
attr_retn_reput(void)
{
return 1;
}
/* attr rb_snum_t sp_inc @ reput()(..., val)(val) */
rb_snum_t
attr_sp_inc_reput(void)
{
return
#line 615 "insns.def"
0;
#line 4363 "insns_info.inc"
}
/* attr rb_num_t width @ reput()(..., val)(val) */
rb_num_t
attr_width_reput(void)
{
return 1;
}
/* attr enum ruby_vminsn_type bin @ topn(n)(...)(val) */
enum ruby_vminsn_type
attr_bin_topn(MAYBE_UNUSED(rb_num_t n))
{
return BIN(topn);
}
/* attr bool handles_sp @ topn(n)(...)(val) */
bool
attr_handles_sp_topn(MAYBE_UNUSED(rb_num_t n))
{
return false;
}
/* attr bool leaf @ topn(n)(...)(val) */
bool
attr_leaf_topn(MAYBE_UNUSED(rb_num_t n))
{
return true;
}
/* attr const char* name @ topn(n)(...)(val) */
const char*
attr_name_topn(MAYBE_UNUSED(rb_num_t n))
{
return insn_name(BIN(topn));
}
/* attr rb_num_t open @ topn(n)(...)(val) */
rb_num_t
attr_open_topn(MAYBE_UNUSED(rb_num_t n))
{
return 1;
}
/* attr rb_num_t popn @ topn(n)(...)(val) */
rb_num_t
attr_popn_topn(MAYBE_UNUSED(rb_num_t n))
{
return 0;
}
/* attr rb_num_t retn @ topn(n)(...)(val) */
rb_num_t
attr_retn_topn(MAYBE_UNUSED(rb_num_t n))
{
return 1;
}
/* attr rb_snum_t sp_inc @ topn(n)(...)(val) */
rb_snum_t
attr_sp_inc_topn(MAYBE_UNUSED(rb_num_t n))
{
return
#line 626 "insns.def"
1;
#line 4429 "insns_info.inc"
}
/* attr rb_num_t width @ topn(n)(...)(val) */
rb_num_t
attr_width_topn(MAYBE_UNUSED(rb_num_t n))
{
return 2;
}
/* attr enum ruby_vminsn_type bin @ setn(n)(..., val)(val) */
enum ruby_vminsn_type
attr_bin_setn(MAYBE_UNUSED(rb_num_t n))
{
return BIN(setn);
}
/* attr bool handles_sp @ setn(n)(..., val)(val) */
bool
attr_handles_sp_setn(MAYBE_UNUSED(rb_num_t n))
{
return false;
}
/* attr bool leaf @ setn(n)(..., val)(val) */
bool
attr_leaf_setn(MAYBE_UNUSED(rb_num_t n))
{
return true;
}
/* attr const char* name @ setn(n)(..., val)(val) */
const char*
attr_name_setn(MAYBE_UNUSED(rb_num_t n))
{
return insn_name(BIN(setn));
}
/* attr rb_num_t open @ setn(n)(..., val)(val) */
rb_num_t
attr_open_setn(MAYBE_UNUSED(rb_num_t n))
{
return 1;
}
/* attr rb_num_t popn @ setn(n)(..., val)(val) */
rb_num_t
attr_popn_setn(MAYBE_UNUSED(rb_num_t n))
{
return 1;
}
/* attr rb_num_t retn @ setn(n)(..., val)(val) */
rb_num_t
attr_retn_setn(MAYBE_UNUSED(rb_num_t n))
{
return 1;
}
/* attr rb_snum_t sp_inc @ setn(n)(..., val)(val) */
rb_snum_t
attr_sp_inc_setn(MAYBE_UNUSED(rb_num_t n))
{
return
#line 637 "insns.def"
0;
#line 4495 "insns_info.inc"
}
/* attr rb_num_t width @ setn(n)(..., val)(val) */
rb_num_t
attr_width_setn(MAYBE_UNUSED(rb_num_t n))
{
return 2;
}
/* attr enum ruby_vminsn_type bin @ adjuststack(n)(...)(...) */
enum ruby_vminsn_type
attr_bin_adjuststack(MAYBE_UNUSED(rb_num_t n))
{
return BIN(adjuststack);
}
/* attr bool handles_sp @ adjuststack(n)(...)(...) */
bool
attr_handles_sp_adjuststack(MAYBE_UNUSED(rb_num_t n))
{
return false;
}
/* attr bool leaf @ adjuststack(n)(...)(...) */
bool
attr_leaf_adjuststack(MAYBE_UNUSED(rb_num_t n))
{
return true;
}
/* attr const char* name @ adjuststack(n)(...)(...) */
const char*
attr_name_adjuststack(MAYBE_UNUSED(rb_num_t n))
{
return insn_name(BIN(adjuststack));
}
/* attr rb_num_t open @ adjuststack(n)(...)(...) */
rb_num_t
attr_open_adjuststack(MAYBE_UNUSED(rb_num_t n))
{
return 1;
}
/* attr rb_num_t popn @ adjuststack(n)(...)(...) */
rb_num_t
attr_popn_adjuststack(MAYBE_UNUSED(rb_num_t n))
{
return 0;
}
/* attr rb_num_t retn @ adjuststack(n)(...)(...) */
rb_num_t
attr_retn_adjuststack(MAYBE_UNUSED(rb_num_t n))
{
return 0;
}
/* attr rb_snum_t sp_inc @ adjuststack(n)(...)(...) */
rb_snum_t
attr_sp_inc_adjuststack(MAYBE_UNUSED(rb_num_t n))
{
return
#line 648 "insns.def"
-(rb_snum_t)n;
#line 4561 "insns_info.inc"
}
/* attr rb_num_t width @ adjuststack(n)(...)(...) */
rb_num_t
attr_width_adjuststack(MAYBE_UNUSED(rb_num_t n))
{
return 2;
}
/* attr enum ruby_vminsn_type bin @ defined(op_type, obj, needstr)(v)(val) */
enum ruby_vminsn_type
attr_bin_defined(
MAYBE_UNUSED(rb_num_t op_type),
MAYBE_UNUSED(VALUE obj),
MAYBE_UNUSED(VALUE needstr)
)
{
return BIN(defined);
}
/* attr bool handles_sp @ defined(op_type, obj, needstr)(v)(val) */
bool
attr_handles_sp_defined(
MAYBE_UNUSED(rb_num_t op_type),
MAYBE_UNUSED(VALUE obj),
MAYBE_UNUSED(VALUE needstr)
)
{
return false;
}
/* attr bool leaf @ defined(op_type, obj, needstr)(v)(val) */
bool
attr_leaf_defined(
MAYBE_UNUSED(rb_num_t op_type),
MAYBE_UNUSED(VALUE obj),
MAYBE_UNUSED(VALUE needstr)
)
{
return
#line 663 "insns.def"
leafness_of_defined(op_type);
#line 4604 "insns_info.inc"
}
/* attr const char* name @ defined(op_type, obj, needstr)(v)(val) */
const char*
attr_name_defined(
MAYBE_UNUSED(rb_num_t op_type),
MAYBE_UNUSED(VALUE obj),
MAYBE_UNUSED(VALUE needstr)
)
{
return insn_name(BIN(defined));
}
/* attr rb_num_t open @ defined(op_type, obj, needstr)(v)(val) */
rb_num_t
attr_open_defined(
MAYBE_UNUSED(rb_num_t op_type),
MAYBE_UNUSED(VALUE obj),
MAYBE_UNUSED(VALUE needstr)
)
{
return 3;
}
/* attr rb_num_t popn @ defined(op_type, obj, needstr)(v)(val) */
rb_num_t
attr_popn_defined(
MAYBE_UNUSED(rb_num_t op_type),
MAYBE_UNUSED(VALUE obj),
MAYBE_UNUSED(VALUE needstr)
)
{
return 1;
}
/* attr rb_num_t retn @ defined(op_type, obj, needstr)(v)(val) */
rb_num_t
attr_retn_defined(
MAYBE_UNUSED(rb_num_t op_type),
MAYBE_UNUSED(VALUE obj),
MAYBE_UNUSED(VALUE needstr)
)
{
return 1;
}
/* attr rb_snum_t sp_inc @ defined(op_type, obj, needstr)(v)(val) */
rb_snum_t
attr_sp_inc_defined(
MAYBE_UNUSED(rb_num_t op_type),
MAYBE_UNUSED(VALUE obj),
MAYBE_UNUSED(VALUE needstr)
)
{
return 0;
}
/* attr rb_num_t width @ defined(op_type, obj, needstr)(v)(val) */
rb_num_t
attr_width_defined(
MAYBE_UNUSED(rb_num_t op_type),
MAYBE_UNUSED(VALUE obj),
MAYBE_UNUSED(VALUE needstr)
)
{
return 4;
}
/* attr enum ruby_vminsn_type bin @ checkmatch(flag)(target, pattern)(result) */
enum ruby_vminsn_type
attr_bin_checkmatch(MAYBE_UNUSED(rb_num_t flag))
{
return BIN(checkmatch);
}
/* attr bool handles_sp @ checkmatch(flag)(target, pattern)(result) */
bool
attr_handles_sp_checkmatch(MAYBE_UNUSED(rb_num_t flag))
{
return false;
}
/* attr bool leaf @ checkmatch(flag)(target, pattern)(result) */
bool
attr_leaf_checkmatch(MAYBE_UNUSED(rb_num_t flag))
{
return
#line 680 "insns.def"
leafness_of_checkmatch(flag);
#line 4694 "insns_info.inc"
}
/* attr const char* name @ checkmatch(flag)(target, pattern)(result) */
const char*
attr_name_checkmatch(MAYBE_UNUSED(rb_num_t flag))
{
return insn_name(BIN(checkmatch));
}
/* attr rb_num_t open @ checkmatch(flag)(target, pattern)(result) */
rb_num_t
attr_open_checkmatch(MAYBE_UNUSED(rb_num_t flag))
{
return 1;
}
/* attr rb_num_t popn @ checkmatch(flag)(target, pattern)(result) */
rb_num_t
attr_popn_checkmatch(MAYBE_UNUSED(rb_num_t flag))
{
return 2;
}
/* attr rb_num_t retn @ checkmatch(flag)(target, pattern)(result) */
rb_num_t
attr_retn_checkmatch(MAYBE_UNUSED(rb_num_t flag))
{
return 1;
}
/* attr rb_snum_t sp_inc @ checkmatch(flag)(target, pattern)(result) */
rb_snum_t
attr_sp_inc_checkmatch(MAYBE_UNUSED(rb_num_t flag))
{
return -1;
}
/* attr rb_num_t width @ checkmatch(flag)(target, pattern)(result) */
rb_num_t
attr_width_checkmatch(MAYBE_UNUSED(rb_num_t flag))
{
return 2;
}
/* attr enum ruby_vminsn_type bin @ checkkeyword(kw_bits_index, keyword_index)()(ret) */
enum ruby_vminsn_type
attr_bin_checkkeyword(
MAYBE_UNUSED(lindex_t kw_bits_index),
MAYBE_UNUSED(lindex_t keyword_index)
)
{
return BIN(checkkeyword);
}
/* attr bool handles_sp @ checkkeyword(kw_bits_index, keyword_index)()(ret) */
bool
attr_handles_sp_checkkeyword(
MAYBE_UNUSED(lindex_t kw_bits_index),
MAYBE_UNUSED(lindex_t keyword_index)
)
{
return false;
}
/* attr bool leaf @ checkkeyword(kw_bits_index, keyword_index)()(ret) */
bool
attr_leaf_checkkeyword(
MAYBE_UNUSED(lindex_t kw_bits_index),
MAYBE_UNUSED(lindex_t keyword_index)
)
{
return true;
}
/* attr const char* name @ checkkeyword(kw_bits_index, keyword_index)()(ret) */
const char*
attr_name_checkkeyword(
MAYBE_UNUSED(lindex_t kw_bits_index),
MAYBE_UNUSED(lindex_t keyword_index)
)
{
return insn_name(BIN(checkkeyword));
}
/* attr rb_num_t open @ checkkeyword(kw_bits_index, keyword_index)()(ret) */
rb_num_t
attr_open_checkkeyword(
MAYBE_UNUSED(lindex_t kw_bits_index),
MAYBE_UNUSED(lindex_t keyword_index)
)
{
return 2;
}
/* attr rb_num_t popn @ checkkeyword(kw_bits_index, keyword_index)()(ret) */
rb_num_t
attr_popn_checkkeyword(
MAYBE_UNUSED(lindex_t kw_bits_index),
MAYBE_UNUSED(lindex_t keyword_index)
)
{
return 0;
}
/* attr rb_num_t retn @ checkkeyword(kw_bits_index, keyword_index)()(ret) */
rb_num_t
attr_retn_checkkeyword(
MAYBE_UNUSED(lindex_t kw_bits_index),
MAYBE_UNUSED(lindex_t keyword_index)
)
{
return 1;
}
/* attr rb_snum_t sp_inc @ checkkeyword(kw_bits_index, keyword_index)()(ret) */
rb_snum_t
attr_sp_inc_checkkeyword(
MAYBE_UNUSED(lindex_t kw_bits_index),
MAYBE_UNUSED(lindex_t keyword_index)
)
{
return 1;
}
/* attr rb_num_t width @ checkkeyword(kw_bits_index, keyword_index)()(ret) */
rb_num_t
attr_width_checkkeyword(
MAYBE_UNUSED(lindex_t kw_bits_index),
MAYBE_UNUSED(lindex_t keyword_index)
)
{
return 3;
}
/* attr enum ruby_vminsn_type bin @ checktype(type)(val)(ret) */
enum ruby_vminsn_type
attr_bin_checktype(MAYBE_UNUSED(rb_num_t type))
{
return BIN(checktype);
}
/* attr bool handles_sp @ checktype(type)(val)(ret) */
bool
attr_handles_sp_checktype(MAYBE_UNUSED(rb_num_t type))
{
return false;
}
/* attr bool leaf @ checktype(type)(val)(ret) */
bool
attr_leaf_checktype(MAYBE_UNUSED(rb_num_t type))
{
return true;
}
/* attr const char* name @ checktype(type)(val)(ret) */
const char*
attr_name_checktype(MAYBE_UNUSED(rb_num_t type))
{
return insn_name(BIN(checktype));
}
/* attr rb_num_t open @ checktype(type)(val)(ret) */
rb_num_t
attr_open_checktype(MAYBE_UNUSED(rb_num_t type))
{
return 1;
}
/* attr rb_num_t popn @ checktype(type)(val)(ret) */
rb_num_t
attr_popn_checktype(MAYBE_UNUSED(rb_num_t type))
{
return 1;
}
/* attr rb_num_t retn @ checktype(type)(val)(ret) */
rb_num_t
attr_retn_checktype(MAYBE_UNUSED(rb_num_t type))
{
return 1;
}
/* attr rb_snum_t sp_inc @ checktype(type)(val)(ret) */
rb_snum_t
attr_sp_inc_checktype(MAYBE_UNUSED(rb_num_t type))
{
return 0;
}
/* attr rb_num_t width @ checktype(type)(val)(ret) */
rb_num_t
attr_width_checktype(MAYBE_UNUSED(rb_num_t type))
{
return 2;
}
/* attr enum ruby_vminsn_type bin @ defineclass(id, class_iseq, flags)(cbase, super)(val) */
enum ruby_vminsn_type
attr_bin_defineclass(
MAYBE_UNUSED(ID id),
MAYBE_UNUSED(ISEQ class_iseq),
MAYBE_UNUSED(rb_num_t flags)
)
{
return BIN(defineclass);
}
/* attr bool handles_sp @ defineclass(id, class_iseq, flags)(cbase, super)(val) */
bool
attr_handles_sp_defineclass(
MAYBE_UNUSED(ID id),
MAYBE_UNUSED(ISEQ class_iseq),
MAYBE_UNUSED(rb_num_t flags)
)
{
return true;
}
/* attr bool leaf @ defineclass(id, class_iseq, flags)(cbase, super)(val) */
bool
attr_leaf_defineclass(
MAYBE_UNUSED(ID id),
MAYBE_UNUSED(ISEQ class_iseq),
MAYBE_UNUSED(rb_num_t flags)
)
{
return false;
}
/* attr const char* name @ defineclass(id, class_iseq, flags)(cbase, super)(val) */
const char*
attr_name_defineclass(
MAYBE_UNUSED(ID id),
MAYBE_UNUSED(ISEQ class_iseq),
MAYBE_UNUSED(rb_num_t flags)
)
{
return insn_name(BIN(defineclass));
}
/* attr rb_num_t open @ defineclass(id, class_iseq, flags)(cbase, super)(val) */
rb_num_t
attr_open_defineclass(
MAYBE_UNUSED(ID id),
MAYBE_UNUSED(ISEQ class_iseq),
MAYBE_UNUSED(rb_num_t flags)
)
{
return 3;
}
/* attr rb_num_t popn @ defineclass(id, class_iseq, flags)(cbase, super)(val) */
rb_num_t
attr_popn_defineclass(
MAYBE_UNUSED(ID id),
MAYBE_UNUSED(ISEQ class_iseq),
MAYBE_UNUSED(rb_num_t flags)
)
{
return 2;
}
/* attr rb_num_t retn @ defineclass(id, class_iseq, flags)(cbase, super)(val) */
rb_num_t
attr_retn_defineclass(
MAYBE_UNUSED(ID id),
MAYBE_UNUSED(ISEQ class_iseq),
MAYBE_UNUSED(rb_num_t flags)
)
{
return 1;
}
/* attr rb_snum_t sp_inc @ defineclass(id, class_iseq, flags)(cbase, super)(val) */
rb_snum_t
attr_sp_inc_defineclass(
MAYBE_UNUSED(ID id),
MAYBE_UNUSED(ISEQ class_iseq),
MAYBE_UNUSED(rb_num_t flags)
)
{
return -1;
}
/* attr rb_num_t width @ defineclass(id, class_iseq, flags)(cbase, super)(val) */
rb_num_t
attr_width_defineclass(
MAYBE_UNUSED(ID id),
MAYBE_UNUSED(ISEQ class_iseq),
MAYBE_UNUSED(rb_num_t flags)
)
{
return 4;
}
/* attr enum ruby_vminsn_type bin @ send(ci, cc, blockiseq)(...)(val) */
enum ruby_vminsn_type
attr_bin_send(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc),
MAYBE_UNUSED(ISEQ blockiseq)
)
{
return BIN(send);
}
/* attr bool handles_sp @ send(ci, cc, blockiseq)(...)(val) */
bool
attr_handles_sp_send(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc),
MAYBE_UNUSED(ISEQ blockiseq)
)
{
return true;
}
/* attr bool leaf @ send(ci, cc, blockiseq)(...)(val) */
bool
attr_leaf_send(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc),
MAYBE_UNUSED(ISEQ blockiseq)
)
{
return false;
}
/* attr const char* name @ send(ci, cc, blockiseq)(...)(val) */
const char*
attr_name_send(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc),
MAYBE_UNUSED(ISEQ blockiseq)
)
{
return insn_name(BIN(send));
}
/* attr rb_num_t open @ send(ci, cc, blockiseq)(...)(val) */
rb_num_t
attr_open_send(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc),
MAYBE_UNUSED(ISEQ blockiseq)
)
{
return 3;
}
/* attr rb_num_t popn @ send(ci, cc, blockiseq)(...)(val) */
rb_num_t
attr_popn_send(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc),
MAYBE_UNUSED(ISEQ blockiseq)
)
{
return 0;
}
/* attr rb_num_t retn @ send(ci, cc, blockiseq)(...)(val) */
rb_num_t
attr_retn_send(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc),
MAYBE_UNUSED(ISEQ blockiseq)
)
{
return 1;
}
/* attr rb_snum_t sp_inc @ send(ci, cc, blockiseq)(...)(val) */
rb_snum_t
attr_sp_inc_send(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc),
MAYBE_UNUSED(ISEQ blockiseq)
)
{
return
#line 743 "insns.def"
- (int)(ci->orig_argc + ((ci->flag & VM_CALL_ARGS_BLOCKARG) ? 1 : 0));
#line 5079 "insns_info.inc"
}
/* attr rb_num_t width @ send(ci, cc, blockiseq)(...)(val) */
rb_num_t
attr_width_send(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc),
MAYBE_UNUSED(ISEQ blockiseq)
)
{
return 4;
}
/* attr enum ruby_vminsn_type bin @ opt_send_without_block(ci, cc)(...)(val) */
enum ruby_vminsn_type
attr_bin_opt_send_without_block(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return BIN(opt_send_without_block);
}
/* attr bool handles_sp @ opt_send_without_block(ci, cc)(...)(val) */
bool
attr_handles_sp_opt_send_without_block(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return
#line 759 "insns.def"
true;
#line 5113 "insns_info.inc"
}
/* attr bool leaf @ opt_send_without_block(ci, cc)(...)(val) */
bool
attr_leaf_opt_send_without_block(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return ! attr_handles_sp_opt_send_without_block(ci, cc);
}
/* attr const char* name @ opt_send_without_block(ci, cc)(...)(val) */
const char*
attr_name_opt_send_without_block(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return insn_name(BIN(opt_send_without_block));
}
/* attr rb_num_t open @ opt_send_without_block(ci, cc)(...)(val) */
rb_num_t
attr_open_opt_send_without_block(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return 2;
}
/* attr rb_num_t popn @ opt_send_without_block(ci, cc)(...)(val) */
rb_num_t
attr_popn_opt_send_without_block(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return 0;
}
/* attr rb_num_t retn @ opt_send_without_block(ci, cc)(...)(val) */
rb_num_t
attr_retn_opt_send_without_block(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return 1;
}
/* attr rb_snum_t sp_inc @ opt_send_without_block(ci, cc)(...)(val) */
rb_snum_t
attr_sp_inc_opt_send_without_block(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return
#line 760 "insns.def"
-ci->orig_argc;
#line 5176 "insns_info.inc"
}
/* attr rb_num_t width @ opt_send_without_block(ci, cc)(...)(val) */
rb_num_t
attr_width_opt_send_without_block(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return 3;
}
/* attr enum ruby_vminsn_type bin @ opt_str_freeze(str, ci, cc)()(val) */
enum ruby_vminsn_type
attr_bin_opt_str_freeze(
MAYBE_UNUSED(VALUE str),
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return BIN(opt_str_freeze);
}
/* attr bool handles_sp @ opt_str_freeze(str, ci, cc)()(val) */
bool
attr_handles_sp_opt_str_freeze(
MAYBE_UNUSED(VALUE str),
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return false;
}
/* attr bool leaf @ opt_str_freeze(str, ci, cc)()(val) */
bool
attr_leaf_opt_str_freeze(
MAYBE_UNUSED(VALUE str),
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return true;
}
/* attr const char* name @ opt_str_freeze(str, ci, cc)()(val) */
const char*
attr_name_opt_str_freeze(
MAYBE_UNUSED(VALUE str),
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return insn_name(BIN(opt_str_freeze));
}
/* attr rb_num_t open @ opt_str_freeze(str, ci, cc)()(val) */
rb_num_t
attr_open_opt_str_freeze(
MAYBE_UNUSED(VALUE str),
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return 3;
}
/* attr rb_num_t popn @ opt_str_freeze(str, ci, cc)()(val) */
rb_num_t
attr_popn_opt_str_freeze(
MAYBE_UNUSED(VALUE str),
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return 0;
}
/* attr rb_num_t retn @ opt_str_freeze(str, ci, cc)()(val) */
rb_num_t
attr_retn_opt_str_freeze(
MAYBE_UNUSED(VALUE str),
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return 1;
}
/* attr rb_snum_t sp_inc @ opt_str_freeze(str, ci, cc)()(val) */
rb_snum_t
attr_sp_inc_opt_str_freeze(
MAYBE_UNUSED(VALUE str),
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return 1;
}
/* attr rb_num_t width @ opt_str_freeze(str, ci, cc)()(val) */
rb_num_t
attr_width_opt_str_freeze(
MAYBE_UNUSED(VALUE str),
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return 4;
}
/* attr enum ruby_vminsn_type bin @ opt_str_uminus(str, ci, cc)()(val) */
enum ruby_vminsn_type
attr_bin_opt_str_uminus(
MAYBE_UNUSED(VALUE str),
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return BIN(opt_str_uminus);
}
/* attr bool handles_sp @ opt_str_uminus(str, ci, cc)()(val) */
bool
attr_handles_sp_opt_str_uminus(
MAYBE_UNUSED(VALUE str),
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return false;
}
/* attr bool leaf @ opt_str_uminus(str, ci, cc)()(val) */
bool
attr_leaf_opt_str_uminus(
MAYBE_UNUSED(VALUE str),
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return true;
}
/* attr const char* name @ opt_str_uminus(str, ci, cc)()(val) */
const char*
attr_name_opt_str_uminus(
MAYBE_UNUSED(VALUE str),
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return insn_name(BIN(opt_str_uminus));
}
/* attr rb_num_t open @ opt_str_uminus(str, ci, cc)()(val) */
rb_num_t
attr_open_opt_str_uminus(
MAYBE_UNUSED(VALUE str),
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return 3;
}
/* attr rb_num_t popn @ opt_str_uminus(str, ci, cc)()(val) */
rb_num_t
attr_popn_opt_str_uminus(
MAYBE_UNUSED(VALUE str),
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return 0;
}
/* attr rb_num_t retn @ opt_str_uminus(str, ci, cc)()(val) */
rb_num_t
attr_retn_opt_str_uminus(
MAYBE_UNUSED(VALUE str),
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return 1;
}
/* attr rb_snum_t sp_inc @ opt_str_uminus(str, ci, cc)()(val) */
rb_snum_t
attr_sp_inc_opt_str_uminus(
MAYBE_UNUSED(VALUE str),
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return 1;
}
/* attr rb_num_t width @ opt_str_uminus(str, ci, cc)()(val) */
rb_num_t
attr_width_opt_str_uminus(
MAYBE_UNUSED(VALUE str),
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return 4;
}
/* attr enum ruby_vminsn_type bin @ opt_newarray_max(num)(...)(val) */
enum ruby_vminsn_type
attr_bin_opt_newarray_max(MAYBE_UNUSED(rb_num_t num))
{
return BIN(opt_newarray_max);
}
/* attr bool handles_sp @ opt_newarray_max(num)(...)(val) */
bool
attr_handles_sp_opt_newarray_max(MAYBE_UNUSED(rb_num_t num))
{
return false;
}
/* attr bool leaf @ opt_newarray_max(num)(...)(val) */
bool
attr_leaf_opt_newarray_max(MAYBE_UNUSED(rb_num_t num))
{
return
#line 805 "insns.def"
false;
#line 5408 "insns_info.inc"
}
/* attr const char* name @ opt_newarray_max(num)(...)(val) */
const char*
attr_name_opt_newarray_max(MAYBE_UNUSED(rb_num_t num))
{
return insn_name(BIN(opt_newarray_max));
}
/* attr rb_num_t open @ opt_newarray_max(num)(...)(val) */
rb_num_t
attr_open_opt_newarray_max(MAYBE_UNUSED(rb_num_t num))
{
return 1;
}
/* attr rb_num_t popn @ opt_newarray_max(num)(...)(val) */
rb_num_t
attr_popn_opt_newarray_max(MAYBE_UNUSED(rb_num_t num))
{
return 0;
}
/* attr rb_num_t retn @ opt_newarray_max(num)(...)(val) */
rb_num_t
attr_retn_opt_newarray_max(MAYBE_UNUSED(rb_num_t num))
{
return 1;
}
/* attr rb_snum_t sp_inc @ opt_newarray_max(num)(...)(val) */
rb_snum_t
attr_sp_inc_opt_newarray_max(MAYBE_UNUSED(rb_num_t num))
{
return
#line 806 "insns.def"
1 - (rb_snum_t)num;
#line 5446 "insns_info.inc"
}
/* attr rb_num_t width @ opt_newarray_max(num)(...)(val) */
rb_num_t
attr_width_opt_newarray_max(MAYBE_UNUSED(rb_num_t num))
{
return 2;
}
/* attr enum ruby_vminsn_type bin @ opt_newarray_min(num)(...)(val) */
enum ruby_vminsn_type
attr_bin_opt_newarray_min(MAYBE_UNUSED(rb_num_t num))
{
return BIN(opt_newarray_min);
}
/* attr bool handles_sp @ opt_newarray_min(num)(...)(val) */
bool
attr_handles_sp_opt_newarray_min(MAYBE_UNUSED(rb_num_t num))
{
return false;
}
/* attr bool leaf @ opt_newarray_min(num)(...)(val) */
bool
attr_leaf_opt_newarray_min(MAYBE_UNUSED(rb_num_t num))
{
return
#line 817 "insns.def"
false;
#line 5477 "insns_info.inc"
}
/* attr const char* name @ opt_newarray_min(num)(...)(val) */
const char*
attr_name_opt_newarray_min(MAYBE_UNUSED(rb_num_t num))
{
return insn_name(BIN(opt_newarray_min));
}
/* attr rb_num_t open @ opt_newarray_min(num)(...)(val) */
rb_num_t
attr_open_opt_newarray_min(MAYBE_UNUSED(rb_num_t num))
{
return 1;
}
/* attr rb_num_t popn @ opt_newarray_min(num)(...)(val) */
rb_num_t
attr_popn_opt_newarray_min(MAYBE_UNUSED(rb_num_t num))
{
return 0;
}
/* attr rb_num_t retn @ opt_newarray_min(num)(...)(val) */
rb_num_t
attr_retn_opt_newarray_min(MAYBE_UNUSED(rb_num_t num))
{
return 1;
}
/* attr rb_snum_t sp_inc @ opt_newarray_min(num)(...)(val) */
rb_snum_t
attr_sp_inc_opt_newarray_min(MAYBE_UNUSED(rb_num_t num))
{
return
#line 818 "insns.def"
1 - (rb_snum_t)num;
#line 5515 "insns_info.inc"
}
/* attr rb_num_t width @ opt_newarray_min(num)(...)(val) */
rb_num_t
attr_width_opt_newarray_min(MAYBE_UNUSED(rb_num_t num))
{
return 2;
}
/* attr enum ruby_vminsn_type bin @ invokesuper(ci, cc, blockiseq)(...)(val) */
enum ruby_vminsn_type
attr_bin_invokesuper(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc),
MAYBE_UNUSED(ISEQ blockiseq)
)
{
return BIN(invokesuper);
}
/* attr bool handles_sp @ invokesuper(ci, cc, blockiseq)(...)(val) */
bool
attr_handles_sp_invokesuper(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc),
MAYBE_UNUSED(ISEQ blockiseq)
)
{
return true;
}
/* attr bool leaf @ invokesuper(ci, cc, blockiseq)(...)(val) */
bool
attr_leaf_invokesuper(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc),
MAYBE_UNUSED(ISEQ blockiseq)
)
{
return false;
}
/* attr const char* name @ invokesuper(ci, cc, blockiseq)(...)(val) */
const char*
attr_name_invokesuper(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc),
MAYBE_UNUSED(ISEQ blockiseq)
)
{
return insn_name(BIN(invokesuper));
}
/* attr rb_num_t open @ invokesuper(ci, cc, blockiseq)(...)(val) */
rb_num_t
attr_open_invokesuper(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc),
MAYBE_UNUSED(ISEQ blockiseq)
)
{
return 3;
}
/* attr rb_num_t popn @ invokesuper(ci, cc, blockiseq)(...)(val) */
rb_num_t
attr_popn_invokesuper(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc),
MAYBE_UNUSED(ISEQ blockiseq)
)
{
return 0;
}
/* attr rb_num_t retn @ invokesuper(ci, cc, blockiseq)(...)(val) */
rb_num_t
attr_retn_invokesuper(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc),
MAYBE_UNUSED(ISEQ blockiseq)
)
{
return 1;
}
/* attr rb_snum_t sp_inc @ invokesuper(ci, cc, blockiseq)(...)(val) */
rb_snum_t
attr_sp_inc_invokesuper(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc),
MAYBE_UNUSED(ISEQ blockiseq)
)
{
return
#line 829 "insns.def"
- (int)(ci->orig_argc + ((ci->flag & VM_CALL_ARGS_BLOCKARG) ? 1 : 0));
#line 5613 "insns_info.inc"
}
/* attr rb_num_t width @ invokesuper(ci, cc, blockiseq)(...)(val) */
rb_num_t
attr_width_invokesuper(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc),
MAYBE_UNUSED(ISEQ blockiseq)
)
{
return 4;
}
/* attr enum ruby_vminsn_type bin @ invokeblock(ci)(...)(val) */
enum ruby_vminsn_type
attr_bin_invokeblock(MAYBE_UNUSED(CALL_INFO ci))
{
return BIN(invokeblock);
}
/* attr bool handles_sp @ invokeblock(ci)(...)(val) */
bool
attr_handles_sp_invokeblock(MAYBE_UNUSED(CALL_INFO ci))
{
return
#line 845 "insns.def"
true;
#line 5641 "insns_info.inc"
}
/* attr bool leaf @ invokeblock(ci)(...)(val) */
bool
attr_leaf_invokeblock(MAYBE_UNUSED(CALL_INFO ci))
{
return ! attr_handles_sp_invokeblock(ci);
}
/* attr const char* name @ invokeblock(ci)(...)(val) */
const char*
attr_name_invokeblock(MAYBE_UNUSED(CALL_INFO ci))
{
return insn_name(BIN(invokeblock));
}
/* attr rb_num_t open @ invokeblock(ci)(...)(val) */
rb_num_t
attr_open_invokeblock(MAYBE_UNUSED(CALL_INFO ci))
{
return 1;
}
/* attr rb_num_t popn @ invokeblock(ci)(...)(val) */
rb_num_t
attr_popn_invokeblock(MAYBE_UNUSED(CALL_INFO ci))
{
return 0;
}
/* attr rb_num_t retn @ invokeblock(ci)(...)(val) */
rb_num_t
attr_retn_invokeblock(MAYBE_UNUSED(CALL_INFO ci))
{
return 1;
}
/* attr rb_snum_t sp_inc @ invokeblock(ci)(...)(val) */
rb_snum_t
attr_sp_inc_invokeblock(MAYBE_UNUSED(CALL_INFO ci))
{
return
#line 846 "insns.def"
1 - ci->orig_argc;
#line 5686 "insns_info.inc"
}
/* attr rb_num_t width @ invokeblock(ci)(...)(val) */
rb_num_t
attr_width_invokeblock(MAYBE_UNUSED(CALL_INFO ci))
{
return 2;
}
/* attr enum ruby_vminsn_type bin @ leave()(val)(val) */
enum ruby_vminsn_type
attr_bin_leave(void)
{
return BIN(leave);
}
/* attr bool handles_sp @ leave()(val)(val) */
bool
attr_handles_sp_leave(void)
{
return
#line 876 "insns.def"
true;
#line 5710 "insns_info.inc"
}
/* attr bool leaf @ leave()(val)(val) */
bool
attr_leaf_leave(void)
{
return
#line 875 "insns.def"
false;
#line 5720 "insns_info.inc"
}
/* attr const char* name @ leave()(val)(val) */
const char*
attr_name_leave(void)
{
return insn_name(BIN(leave));
}
/* attr rb_num_t open @ leave()(val)(val) */
rb_num_t
attr_open_leave(void)
{
return 0;
}
/* attr rb_num_t popn @ leave()(val)(val) */
rb_num_t
attr_popn_leave(void)
{
return 1;
}
/* attr rb_num_t retn @ leave()(val)(val) */
rb_num_t
attr_retn_leave(void)
{
return 1;
}
/* attr rb_snum_t sp_inc @ leave()(val)(val) */
rb_snum_t
attr_sp_inc_leave(void)
{
return 0;
}
/* attr rb_num_t width @ leave()(val)(val) */
rb_num_t
attr_width_leave(void)
{
return 1;
}
/* attr enum ruby_vminsn_type bin @ throw(throw_state)(throwobj)(val) */
enum ruby_vminsn_type
attr_bin_throw(MAYBE_UNUSED(rb_num_t throw_state))
{
return BIN(throw);
}
/* attr bool handles_sp @ throw(throw_state)(throwobj)(val) */
bool
attr_handles_sp_throw(MAYBE_UNUSED(rb_num_t throw_state))
{
return false;
}
/* attr bool leaf @ throw(throw_state)(throwobj)(val) */
bool
attr_leaf_throw(MAYBE_UNUSED(rb_num_t throw_state))
{
return
#line 911 "insns.def"
false;
#line 5786 "insns_info.inc"
}
/* attr const char* name @ throw(throw_state)(throwobj)(val) */
const char*
attr_name_throw(MAYBE_UNUSED(rb_num_t throw_state))
{
return insn_name(BIN(throw));
}
/* attr rb_num_t open @ throw(throw_state)(throwobj)(val) */
rb_num_t
attr_open_throw(MAYBE_UNUSED(rb_num_t throw_state))
{
return 1;
}
/* attr rb_num_t popn @ throw(throw_state)(throwobj)(val) */
rb_num_t
attr_popn_throw(MAYBE_UNUSED(rb_num_t throw_state))
{
return 1;
}
/* attr rb_num_t retn @ throw(throw_state)(throwobj)(val) */
rb_num_t
attr_retn_throw(MAYBE_UNUSED(rb_num_t throw_state))
{
return 1;
}
/* attr rb_snum_t sp_inc @ throw(throw_state)(throwobj)(val) */
rb_snum_t
attr_sp_inc_throw(MAYBE_UNUSED(rb_num_t throw_state))
{
return 0;
}
/* attr rb_num_t width @ throw(throw_state)(throwobj)(val) */
rb_num_t
attr_width_throw(MAYBE_UNUSED(rb_num_t throw_state))
{
return 2;
}
/* attr enum ruby_vminsn_type bin @ jump(dst)()() */
enum ruby_vminsn_type
attr_bin_jump(MAYBE_UNUSED(OFFSET dst))
{
return BIN(jump);
}
/* attr bool handles_sp @ jump(dst)()() */
bool
attr_handles_sp_jump(MAYBE_UNUSED(OFFSET dst))
{
return false;
}
/* attr bool leaf @ jump(dst)()() */
bool
attr_leaf_jump(MAYBE_UNUSED(OFFSET dst))
{
return
#line 930 "insns.def"
false;
#line 5852 "insns_info.inc"
}
/* attr const char* name @ jump(dst)()() */
const char*
attr_name_jump(MAYBE_UNUSED(OFFSET dst))
{
return insn_name(BIN(jump));
}
/* attr rb_num_t open @ jump(dst)()() */
rb_num_t
attr_open_jump(MAYBE_UNUSED(OFFSET dst))
{
return 1;
}
/* attr rb_num_t popn @ jump(dst)()() */
rb_num_t
attr_popn_jump(MAYBE_UNUSED(OFFSET dst))
{
return 0;
}
/* attr rb_num_t retn @ jump(dst)()() */
rb_num_t
attr_retn_jump(MAYBE_UNUSED(OFFSET dst))
{
return 0;
}
/* attr rb_snum_t sp_inc @ jump(dst)()() */
rb_snum_t
attr_sp_inc_jump(MAYBE_UNUSED(OFFSET dst))
{
return 0;
}
/* attr rb_num_t width @ jump(dst)()() */
rb_num_t
attr_width_jump(MAYBE_UNUSED(OFFSET dst))
{
return 2;
}
/* attr enum ruby_vminsn_type bin @ branchif(dst)(val)() */
enum ruby_vminsn_type
attr_bin_branchif(MAYBE_UNUSED(OFFSET dst))
{
return BIN(branchif);
}
/* attr bool handles_sp @ branchif(dst)(val)() */
bool
attr_handles_sp_branchif(MAYBE_UNUSED(OFFSET dst))
{
return false;
}
/* attr bool leaf @ branchif(dst)(val)() */
bool
attr_leaf_branchif(MAYBE_UNUSED(OFFSET dst))
{
return
#line 943 "insns.def"
false;
#line 5918 "insns_info.inc"
}
/* attr const char* name @ branchif(dst)(val)() */
const char*
attr_name_branchif(MAYBE_UNUSED(OFFSET dst))
{
return insn_name(BIN(branchif));
}
/* attr rb_num_t open @ branchif(dst)(val)() */
rb_num_t
attr_open_branchif(MAYBE_UNUSED(OFFSET dst))
{
return 1;
}
/* attr rb_num_t popn @ branchif(dst)(val)() */
rb_num_t
attr_popn_branchif(MAYBE_UNUSED(OFFSET dst))
{
return 1;
}
/* attr rb_num_t retn @ branchif(dst)(val)() */
rb_num_t
attr_retn_branchif(MAYBE_UNUSED(OFFSET dst))
{
return 0;
}
/* attr rb_snum_t sp_inc @ branchif(dst)(val)() */
rb_snum_t
attr_sp_inc_branchif(MAYBE_UNUSED(OFFSET dst))
{
return -1;
}
/* attr rb_num_t width @ branchif(dst)(val)() */
rb_num_t
attr_width_branchif(MAYBE_UNUSED(OFFSET dst))
{
return 2;
}
/* attr enum ruby_vminsn_type bin @ branchunless(dst)(val)() */
enum ruby_vminsn_type
attr_bin_branchunless(MAYBE_UNUSED(OFFSET dst))
{
return BIN(branchunless);
}
/* attr bool handles_sp @ branchunless(dst)(val)() */
bool
attr_handles_sp_branchunless(MAYBE_UNUSED(OFFSET dst))
{
return false;
}
/* attr bool leaf @ branchunless(dst)(val)() */
bool
attr_leaf_branchunless(MAYBE_UNUSED(OFFSET dst))
{
return
#line 958 "insns.def"
false;
#line 5984 "insns_info.inc"
}
/* attr const char* name @ branchunless(dst)(val)() */
const char*
attr_name_branchunless(MAYBE_UNUSED(OFFSET dst))
{
return insn_name(BIN(branchunless));
}
/* attr rb_num_t open @ branchunless(dst)(val)() */
rb_num_t
attr_open_branchunless(MAYBE_UNUSED(OFFSET dst))
{
return 1;
}
/* attr rb_num_t popn @ branchunless(dst)(val)() */
rb_num_t
attr_popn_branchunless(MAYBE_UNUSED(OFFSET dst))
{
return 1;
}
/* attr rb_num_t retn @ branchunless(dst)(val)() */
rb_num_t
attr_retn_branchunless(MAYBE_UNUSED(OFFSET dst))
{
return 0;
}
/* attr rb_snum_t sp_inc @ branchunless(dst)(val)() */
rb_snum_t
attr_sp_inc_branchunless(MAYBE_UNUSED(OFFSET dst))
{
return -1;
}
/* attr rb_num_t width @ branchunless(dst)(val)() */
rb_num_t
attr_width_branchunless(MAYBE_UNUSED(OFFSET dst))
{
return 2;
}
/* attr enum ruby_vminsn_type bin @ branchnil(dst)(val)() */
enum ruby_vminsn_type
attr_bin_branchnil(MAYBE_UNUSED(OFFSET dst))
{
return BIN(branchnil);
}
/* attr bool handles_sp @ branchnil(dst)(val)() */
bool
attr_handles_sp_branchnil(MAYBE_UNUSED(OFFSET dst))
{
return false;
}
/* attr bool leaf @ branchnil(dst)(val)() */
bool
attr_leaf_branchnil(MAYBE_UNUSED(OFFSET dst))
{
return
#line 973 "insns.def"
false;
#line 6050 "insns_info.inc"
}
/* attr const char* name @ branchnil(dst)(val)() */
const char*
attr_name_branchnil(MAYBE_UNUSED(OFFSET dst))
{
return insn_name(BIN(branchnil));
}
/* attr rb_num_t open @ branchnil(dst)(val)() */
rb_num_t
attr_open_branchnil(MAYBE_UNUSED(OFFSET dst))
{
return 1;
}
/* attr rb_num_t popn @ branchnil(dst)(val)() */
rb_num_t
attr_popn_branchnil(MAYBE_UNUSED(OFFSET dst))
{
return 1;
}
/* attr rb_num_t retn @ branchnil(dst)(val)() */
rb_num_t
attr_retn_branchnil(MAYBE_UNUSED(OFFSET dst))
{
return 0;
}
/* attr rb_snum_t sp_inc @ branchnil(dst)(val)() */
rb_snum_t
attr_sp_inc_branchnil(MAYBE_UNUSED(OFFSET dst))
{
return -1;
}
/* attr rb_num_t width @ branchnil(dst)(val)() */
rb_num_t
attr_width_branchnil(MAYBE_UNUSED(OFFSET dst))
{
return 2;
}
/* attr enum ruby_vminsn_type bin @ opt_getinlinecache(dst, ic)()(val) */
enum ruby_vminsn_type
attr_bin_opt_getinlinecache(
MAYBE_UNUSED(OFFSET dst),
MAYBE_UNUSED(IC ic)
)
{
return BIN(opt_getinlinecache);
}
/* attr bool handles_sp @ opt_getinlinecache(dst, ic)()(val) */
bool
attr_handles_sp_opt_getinlinecache(
MAYBE_UNUSED(OFFSET dst),
MAYBE_UNUSED(IC ic)
)
{
return false;
}
/* attr bool leaf @ opt_getinlinecache(dst, ic)()(val) */
bool
attr_leaf_opt_getinlinecache(
MAYBE_UNUSED(OFFSET dst),
MAYBE_UNUSED(IC ic)
)
{
return true;
}
/* attr const char* name @ opt_getinlinecache(dst, ic)()(val) */
const char*
attr_name_opt_getinlinecache(
MAYBE_UNUSED(OFFSET dst),
MAYBE_UNUSED(IC ic)
)
{
return insn_name(BIN(opt_getinlinecache));
}
/* attr rb_num_t open @ opt_getinlinecache(dst, ic)()(val) */
rb_num_t
attr_open_opt_getinlinecache(
MAYBE_UNUSED(OFFSET dst),
MAYBE_UNUSED(IC ic)
)
{
return 2;
}
/* attr rb_num_t popn @ opt_getinlinecache(dst, ic)()(val) */
rb_num_t
attr_popn_opt_getinlinecache(
MAYBE_UNUSED(OFFSET dst),
MAYBE_UNUSED(IC ic)
)
{
return 0;
}
/* attr rb_num_t retn @ opt_getinlinecache(dst, ic)()(val) */
rb_num_t
attr_retn_opt_getinlinecache(
MAYBE_UNUSED(OFFSET dst),
MAYBE_UNUSED(IC ic)
)
{
return 1;
}
/* attr rb_snum_t sp_inc @ opt_getinlinecache(dst, ic)()(val) */
rb_snum_t
attr_sp_inc_opt_getinlinecache(
MAYBE_UNUSED(OFFSET dst),
MAYBE_UNUSED(IC ic)
)
{
return 1;
}
/* attr rb_num_t width @ opt_getinlinecache(dst, ic)()(val) */
rb_num_t
attr_width_opt_getinlinecache(
MAYBE_UNUSED(OFFSET dst),
MAYBE_UNUSED(IC ic)
)
{
return 3;
}
/* attr enum ruby_vminsn_type bin @ opt_setinlinecache(ic)(val)(val) */
enum ruby_vminsn_type
attr_bin_opt_setinlinecache(MAYBE_UNUSED(IC ic))
{
return BIN(opt_setinlinecache);
}
/* attr bool handles_sp @ opt_setinlinecache(ic)(val)(val) */
bool
attr_handles_sp_opt_setinlinecache(MAYBE_UNUSED(IC ic))
{
return false;
}
/* attr bool leaf @ opt_setinlinecache(ic)(val)(val) */
bool
attr_leaf_opt_setinlinecache(MAYBE_UNUSED(IC ic))
{
return true;
}
/* attr const char* name @ opt_setinlinecache(ic)(val)(val) */
const char*
attr_name_opt_setinlinecache(MAYBE_UNUSED(IC ic))
{
return insn_name(BIN(opt_setinlinecache));
}
/* attr rb_num_t open @ opt_setinlinecache(ic)(val)(val) */
rb_num_t
attr_open_opt_setinlinecache(MAYBE_UNUSED(IC ic))
{
return 1;
}
/* attr rb_num_t popn @ opt_setinlinecache(ic)(val)(val) */
rb_num_t
attr_popn_opt_setinlinecache(MAYBE_UNUSED(IC ic))
{
return 1;
}
/* attr rb_num_t retn @ opt_setinlinecache(ic)(val)(val) */
rb_num_t
attr_retn_opt_setinlinecache(MAYBE_UNUSED(IC ic))
{
return 1;
}
/* attr rb_snum_t sp_inc @ opt_setinlinecache(ic)(val)(val) */
rb_snum_t
attr_sp_inc_opt_setinlinecache(MAYBE_UNUSED(IC ic))
{
return 0;
}
/* attr rb_num_t width @ opt_setinlinecache(ic)(val)(val) */
rb_num_t
attr_width_opt_setinlinecache(MAYBE_UNUSED(IC ic))
{
return 2;
}
/* attr enum ruby_vminsn_type bin @ once(iseq, ise)()(val) */
enum ruby_vminsn_type
attr_bin_once(
MAYBE_UNUSED(ISEQ iseq),
MAYBE_UNUSED(ISE ise)
)
{
return BIN(once);
}
/* attr bool handles_sp @ once(iseq, ise)()(val) */
bool
attr_handles_sp_once(
MAYBE_UNUSED(ISEQ iseq),
MAYBE_UNUSED(ISE ise)
)
{
return true;
}
/* attr bool leaf @ once(iseq, ise)()(val) */
bool
attr_leaf_once(
MAYBE_UNUSED(ISEQ iseq),
MAYBE_UNUSED(ISE ise)
)
{
return false;
}
/* attr const char* name @ once(iseq, ise)()(val) */
const char*
attr_name_once(
MAYBE_UNUSED(ISEQ iseq),
MAYBE_UNUSED(ISE ise)
)
{
return insn_name(BIN(once));
}
/* attr rb_num_t open @ once(iseq, ise)()(val) */
rb_num_t
attr_open_once(
MAYBE_UNUSED(ISEQ iseq),
MAYBE_UNUSED(ISE ise)
)
{
return 2;
}
/* attr rb_num_t popn @ once(iseq, ise)()(val) */
rb_num_t
attr_popn_once(
MAYBE_UNUSED(ISEQ iseq),
MAYBE_UNUSED(ISE ise)
)
{
return 0;
}
/* attr rb_num_t retn @ once(iseq, ise)()(val) */
rb_num_t
attr_retn_once(
MAYBE_UNUSED(ISEQ iseq),
MAYBE_UNUSED(ISE ise)
)
{
return 1;
}
/* attr rb_snum_t sp_inc @ once(iseq, ise)()(val) */
rb_snum_t
attr_sp_inc_once(
MAYBE_UNUSED(ISEQ iseq),
MAYBE_UNUSED(ISE ise)
)
{
return 1;
}
/* attr rb_num_t width @ once(iseq, ise)()(val) */
rb_num_t
attr_width_once(
MAYBE_UNUSED(ISEQ iseq),
MAYBE_UNUSED(ISE ise)
)
{
return 3;
}
/* attr enum ruby_vminsn_type bin @ opt_case_dispatch(hash, else_offset)(..., key)() */
enum ruby_vminsn_type
attr_bin_opt_case_dispatch(
MAYBE_UNUSED(CDHASH hash),
MAYBE_UNUSED(OFFSET else_offset)
)
{
return BIN(opt_case_dispatch);
}
/* attr bool handles_sp @ opt_case_dispatch(hash, else_offset)(..., key)() */
bool
attr_handles_sp_opt_case_dispatch(
MAYBE_UNUSED(CDHASH hash),
MAYBE_UNUSED(OFFSET else_offset)
)
{
return false;
}
/* attr bool leaf @ opt_case_dispatch(hash, else_offset)(..., key)() */
bool
attr_leaf_opt_case_dispatch(
MAYBE_UNUSED(CDHASH hash),
MAYBE_UNUSED(OFFSET else_offset)
)
{
return true;
}
/* attr const char* name @ opt_case_dispatch(hash, else_offset)(..., key)() */
const char*
attr_name_opt_case_dispatch(
MAYBE_UNUSED(CDHASH hash),
MAYBE_UNUSED(OFFSET else_offset)
)
{
return insn_name(BIN(opt_case_dispatch));
}
/* attr rb_num_t open @ opt_case_dispatch(hash, else_offset)(..., key)() */
rb_num_t
attr_open_opt_case_dispatch(
MAYBE_UNUSED(CDHASH hash),
MAYBE_UNUSED(OFFSET else_offset)
)
{
return 2;
}
/* attr rb_num_t popn @ opt_case_dispatch(hash, else_offset)(..., key)() */
rb_num_t
attr_popn_opt_case_dispatch(
MAYBE_UNUSED(CDHASH hash),
MAYBE_UNUSED(OFFSET else_offset)
)
{
return 1;
}
/* attr rb_num_t retn @ opt_case_dispatch(hash, else_offset)(..., key)() */
rb_num_t
attr_retn_opt_case_dispatch(
MAYBE_UNUSED(CDHASH hash),
MAYBE_UNUSED(OFFSET else_offset)
)
{
return 0;
}
/* attr rb_snum_t sp_inc @ opt_case_dispatch(hash, else_offset)(..., key)() */
rb_snum_t
attr_sp_inc_opt_case_dispatch(
MAYBE_UNUSED(CDHASH hash),
MAYBE_UNUSED(OFFSET else_offset)
)
{
return
#line 1027 "insns.def"
-1;
#line 6418 "insns_info.inc"
}
/* attr rb_num_t width @ opt_case_dispatch(hash, else_offset)(..., key)() */
rb_num_t
attr_width_opt_case_dispatch(
MAYBE_UNUSED(CDHASH hash),
MAYBE_UNUSED(OFFSET else_offset)
)
{
return 3;
}
/* attr enum ruby_vminsn_type bin @ opt_plus(ci, cc)(recv, obj)(val) */
enum ruby_vminsn_type
attr_bin_opt_plus(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return BIN(opt_plus);
}
/* attr bool handles_sp @ opt_plus(ci, cc)(recv, obj)(val) */
bool
attr_handles_sp_opt_plus(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return false;
}
/* attr bool leaf @ opt_plus(ci, cc)(recv, obj)(val) */
bool
attr_leaf_opt_plus(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return
#line 1046 "insns.def"
false;
#line 6461 "insns_info.inc"
}
/* attr const char* name @ opt_plus(ci, cc)(recv, obj)(val) */
const char*
attr_name_opt_plus(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return insn_name(BIN(opt_plus));
}
/* attr rb_num_t open @ opt_plus(ci, cc)(recv, obj)(val) */
rb_num_t
attr_open_opt_plus(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return 2;
}
/* attr rb_num_t popn @ opt_plus(ci, cc)(recv, obj)(val) */
rb_num_t
attr_popn_opt_plus(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return 2;
}
/* attr rb_num_t retn @ opt_plus(ci, cc)(recv, obj)(val) */
rb_num_t
attr_retn_opt_plus(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return 1;
}
/* attr rb_snum_t sp_inc @ opt_plus(ci, cc)(recv, obj)(val) */
rb_snum_t
attr_sp_inc_opt_plus(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return -1;
}
/* attr rb_num_t width @ opt_plus(ci, cc)(recv, obj)(val) */
rb_num_t
attr_width_opt_plus(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return 3;
}
/* attr enum ruby_vminsn_type bin @ opt_minus(ci, cc)(recv, obj)(val) */
enum ruby_vminsn_type
attr_bin_opt_minus(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return BIN(opt_minus);
}
/* attr bool handles_sp @ opt_minus(ci, cc)(recv, obj)(val) */
bool
attr_handles_sp_opt_minus(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return false;
}
/* attr bool leaf @ opt_minus(ci, cc)(recv, obj)(val) */
bool
attr_leaf_opt_minus(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return true;
}
/* attr const char* name @ opt_minus(ci, cc)(recv, obj)(val) */
const char*
attr_name_opt_minus(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return insn_name(BIN(opt_minus));
}
/* attr rb_num_t open @ opt_minus(ci, cc)(recv, obj)(val) */
rb_num_t
attr_open_opt_minus(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return 2;
}
/* attr rb_num_t popn @ opt_minus(ci, cc)(recv, obj)(val) */
rb_num_t
attr_popn_opt_minus(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return 2;
}
/* attr rb_num_t retn @ opt_minus(ci, cc)(recv, obj)(val) */
rb_num_t
attr_retn_opt_minus(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return 1;
}
/* attr rb_snum_t sp_inc @ opt_minus(ci, cc)(recv, obj)(val) */
rb_snum_t
attr_sp_inc_opt_minus(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return -1;
}
/* attr rb_num_t width @ opt_minus(ci, cc)(recv, obj)(val) */
rb_num_t
attr_width_opt_minus(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return 3;
}
/* attr enum ruby_vminsn_type bin @ opt_mult(ci, cc)(recv, obj)(val) */
enum ruby_vminsn_type
attr_bin_opt_mult(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return BIN(opt_mult);
}
/* attr bool handles_sp @ opt_mult(ci, cc)(recv, obj)(val) */
bool
attr_handles_sp_opt_mult(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return false;
}
/* attr bool leaf @ opt_mult(ci, cc)(recv, obj)(val) */
bool
attr_leaf_opt_mult(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return true;
}
/* attr const char* name @ opt_mult(ci, cc)(recv, obj)(val) */
const char*
attr_name_opt_mult(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return insn_name(BIN(opt_mult));
}
/* attr rb_num_t open @ opt_mult(ci, cc)(recv, obj)(val) */
rb_num_t
attr_open_opt_mult(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return 2;
}
/* attr rb_num_t popn @ opt_mult(ci, cc)(recv, obj)(val) */
rb_num_t
attr_popn_opt_mult(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return 2;
}
/* attr rb_num_t retn @ opt_mult(ci, cc)(recv, obj)(val) */
rb_num_t
attr_retn_opt_mult(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return 1;
}
/* attr rb_snum_t sp_inc @ opt_mult(ci, cc)(recv, obj)(val) */
rb_snum_t
attr_sp_inc_opt_mult(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return -1;
}
/* attr rb_num_t width @ opt_mult(ci, cc)(recv, obj)(val) */
rb_num_t
attr_width_opt_mult(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return 3;
}
/* attr enum ruby_vminsn_type bin @ opt_div(ci, cc)(recv, obj)(val) */
enum ruby_vminsn_type
attr_bin_opt_div(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return BIN(opt_div);
}
/* attr bool handles_sp @ opt_div(ci, cc)(recv, obj)(val) */
bool
attr_handles_sp_opt_div(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return false;
}
/* attr bool leaf @ opt_div(ci, cc)(recv, obj)(val) */
bool
attr_leaf_opt_div(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return true;
}
/* attr const char* name @ opt_div(ci, cc)(recv, obj)(val) */
const char*
attr_name_opt_div(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return insn_name(BIN(opt_div));
}
/* attr rb_num_t open @ opt_div(ci, cc)(recv, obj)(val) */
rb_num_t
attr_open_opt_div(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return 2;
}
/* attr rb_num_t popn @ opt_div(ci, cc)(recv, obj)(val) */
rb_num_t
attr_popn_opt_div(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return 2;
}
/* attr rb_num_t retn @ opt_div(ci, cc)(recv, obj)(val) */
rb_num_t
attr_retn_opt_div(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return 1;
}
/* attr rb_snum_t sp_inc @ opt_div(ci, cc)(recv, obj)(val) */
rb_snum_t
attr_sp_inc_opt_div(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return -1;
}
/* attr rb_num_t width @ opt_div(ci, cc)(recv, obj)(val) */
rb_num_t
attr_width_opt_div(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return 3;
}
/* attr enum ruby_vminsn_type bin @ opt_mod(ci, cc)(recv, obj)(val) */
enum ruby_vminsn_type
attr_bin_opt_mod(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return BIN(opt_mod);
}
/* attr bool handles_sp @ opt_mod(ci, cc)(recv, obj)(val) */
bool
attr_handles_sp_opt_mod(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return false;
}
/* attr bool leaf @ opt_mod(ci, cc)(recv, obj)(val) */
bool
attr_leaf_opt_mod(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return true;
}
/* attr const char* name @ opt_mod(ci, cc)(recv, obj)(val) */
const char*
attr_name_opt_mod(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return insn_name(BIN(opt_mod));
}
/* attr rb_num_t open @ opt_mod(ci, cc)(recv, obj)(val) */
rb_num_t
attr_open_opt_mod(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return 2;
}
/* attr rb_num_t popn @ opt_mod(ci, cc)(recv, obj)(val) */
rb_num_t
attr_popn_opt_mod(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return 2;
}
/* attr rb_num_t retn @ opt_mod(ci, cc)(recv, obj)(val) */
rb_num_t
attr_retn_opt_mod(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return 1;
}
/* attr rb_snum_t sp_inc @ opt_mod(ci, cc)(recv, obj)(val) */
rb_snum_t
attr_sp_inc_opt_mod(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return -1;
}
/* attr rb_num_t width @ opt_mod(ci, cc)(recv, obj)(val) */
rb_num_t
attr_width_opt_mod(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return 3;
}
/* attr enum ruby_vminsn_type bin @ opt_eq(ci, cc)(recv, obj)(val) */
enum ruby_vminsn_type
attr_bin_opt_eq(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return BIN(opt_eq);
}
/* attr bool handles_sp @ opt_eq(ci, cc)(recv, obj)(val) */
bool
attr_handles_sp_opt_eq(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return false;
}
/* attr bool leaf @ opt_eq(ci, cc)(recv, obj)(val) */
bool
attr_leaf_opt_eq(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return
#line 1120 "insns.def"
false;
#line 6914 "insns_info.inc"
}
/* attr const char* name @ opt_eq(ci, cc)(recv, obj)(val) */
const char*
attr_name_opt_eq(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return insn_name(BIN(opt_eq));
}
/* attr rb_num_t open @ opt_eq(ci, cc)(recv, obj)(val) */
rb_num_t
attr_open_opt_eq(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return 2;
}
/* attr rb_num_t popn @ opt_eq(ci, cc)(recv, obj)(val) */
rb_num_t
attr_popn_opt_eq(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return 2;
}
/* attr rb_num_t retn @ opt_eq(ci, cc)(recv, obj)(val) */
rb_num_t
attr_retn_opt_eq(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return 1;
}
/* attr rb_snum_t sp_inc @ opt_eq(ci, cc)(recv, obj)(val) */
rb_snum_t
attr_sp_inc_opt_eq(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return -1;
}
/* attr rb_num_t width @ opt_eq(ci, cc)(recv, obj)(val) */
rb_num_t
attr_width_opt_eq(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return 3;
}
/* attr enum ruby_vminsn_type bin @ opt_neq(ci_eq, cc_eq, ci, cc)(recv, obj)(val) */
enum ruby_vminsn_type
attr_bin_opt_neq(
MAYBE_UNUSED(CALL_INFO ci_eq),
MAYBE_UNUSED(CALL_CACHE cc_eq),
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return BIN(opt_neq);
}
/* attr bool handles_sp @ opt_neq(ci_eq, cc_eq, ci, cc)(recv, obj)(val) */
bool
attr_handles_sp_opt_neq(
MAYBE_UNUSED(CALL_INFO ci_eq),
MAYBE_UNUSED(CALL_CACHE cc_eq),
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return false;
}
/* attr bool leaf @ opt_neq(ci_eq, cc_eq, ci, cc)(recv, obj)(val) */
bool
attr_leaf_opt_neq(
MAYBE_UNUSED(CALL_INFO ci_eq),
MAYBE_UNUSED(CALL_CACHE cc_eq),
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return
#line 1136 "insns.def"
false;
#line 7013 "insns_info.inc"
}
/* attr const char* name @ opt_neq(ci_eq, cc_eq, ci, cc)(recv, obj)(val) */
const char*
attr_name_opt_neq(
MAYBE_UNUSED(CALL_INFO ci_eq),
MAYBE_UNUSED(CALL_CACHE cc_eq),
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return insn_name(BIN(opt_neq));
}
/* attr rb_num_t open @ opt_neq(ci_eq, cc_eq, ci, cc)(recv, obj)(val) */
rb_num_t
attr_open_opt_neq(
MAYBE_UNUSED(CALL_INFO ci_eq),
MAYBE_UNUSED(CALL_CACHE cc_eq),
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return 4;
}
/* attr rb_num_t popn @ opt_neq(ci_eq, cc_eq, ci, cc)(recv, obj)(val) */
rb_num_t
attr_popn_opt_neq(
MAYBE_UNUSED(CALL_INFO ci_eq),
MAYBE_UNUSED(CALL_CACHE cc_eq),
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return 2;
}
/* attr rb_num_t retn @ opt_neq(ci_eq, cc_eq, ci, cc)(recv, obj)(val) */
rb_num_t
attr_retn_opt_neq(
MAYBE_UNUSED(CALL_INFO ci_eq),
MAYBE_UNUSED(CALL_CACHE cc_eq),
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return 1;
}
/* attr rb_snum_t sp_inc @ opt_neq(ci_eq, cc_eq, ci, cc)(recv, obj)(val) */
rb_snum_t
attr_sp_inc_opt_neq(
MAYBE_UNUSED(CALL_INFO ci_eq),
MAYBE_UNUSED(CALL_CACHE cc_eq),
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return -1;
}
/* attr rb_num_t width @ opt_neq(ci_eq, cc_eq, ci, cc)(recv, obj)(val) */
rb_num_t
attr_width_opt_neq(
MAYBE_UNUSED(CALL_INFO ci_eq),
MAYBE_UNUSED(CALL_CACHE cc_eq),
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return 5;
}
/* attr enum ruby_vminsn_type bin @ opt_lt(ci, cc)(recv, obj)(val) */
enum ruby_vminsn_type
attr_bin_opt_lt(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return BIN(opt_lt);
}
/* attr bool handles_sp @ opt_lt(ci, cc)(recv, obj)(val) */
bool
attr_handles_sp_opt_lt(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return false;
}
/* attr bool leaf @ opt_lt(ci, cc)(recv, obj)(val) */
bool
attr_leaf_opt_lt(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return true;
}
/* attr const char* name @ opt_lt(ci, cc)(recv, obj)(val) */
const char*
attr_name_opt_lt(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return insn_name(BIN(opt_lt));
}
/* attr rb_num_t open @ opt_lt(ci, cc)(recv, obj)(val) */
rb_num_t
attr_open_opt_lt(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return 2;
}
/* attr rb_num_t popn @ opt_lt(ci, cc)(recv, obj)(val) */
rb_num_t
attr_popn_opt_lt(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return 2;
}
/* attr rb_num_t retn @ opt_lt(ci, cc)(recv, obj)(val) */
rb_num_t
attr_retn_opt_lt(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return 1;
}
/* attr rb_snum_t sp_inc @ opt_lt(ci, cc)(recv, obj)(val) */
rb_snum_t
attr_sp_inc_opt_lt(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return -1;
}
/* attr rb_num_t width @ opt_lt(ci, cc)(recv, obj)(val) */
rb_num_t
attr_width_opt_lt(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return 3;
}
/* attr enum ruby_vminsn_type bin @ opt_le(ci, cc)(recv, obj)(val) */
enum ruby_vminsn_type
attr_bin_opt_le(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return BIN(opt_le);
}
/* attr bool handles_sp @ opt_le(ci, cc)(recv, obj)(val) */
bool
attr_handles_sp_opt_le(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return false;
}
/* attr bool leaf @ opt_le(ci, cc)(recv, obj)(val) */
bool
attr_leaf_opt_le(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return true;
}
/* attr const char* name @ opt_le(ci, cc)(recv, obj)(val) */
const char*
attr_name_opt_le(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return insn_name(BIN(opt_le));
}
/* attr rb_num_t open @ opt_le(ci, cc)(recv, obj)(val) */
rb_num_t
attr_open_opt_le(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return 2;
}
/* attr rb_num_t popn @ opt_le(ci, cc)(recv, obj)(val) */
rb_num_t
attr_popn_opt_le(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return 2;
}
/* attr rb_num_t retn @ opt_le(ci, cc)(recv, obj)(val) */
rb_num_t
attr_retn_opt_le(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return 1;
}
/* attr rb_snum_t sp_inc @ opt_le(ci, cc)(recv, obj)(val) */
rb_snum_t
attr_sp_inc_opt_le(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return -1;
}
/* attr rb_num_t width @ opt_le(ci, cc)(recv, obj)(val) */
rb_num_t
attr_width_opt_le(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return 3;
}
/* attr enum ruby_vminsn_type bin @ opt_gt(ci, cc)(recv, obj)(val) */
enum ruby_vminsn_type
attr_bin_opt_gt(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return BIN(opt_gt);
}
/* attr bool handles_sp @ opt_gt(ci, cc)(recv, obj)(val) */
bool
attr_handles_sp_opt_gt(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return false;
}
/* attr bool leaf @ opt_gt(ci, cc)(recv, obj)(val) */
bool
attr_leaf_opt_gt(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return true;
}
/* attr const char* name @ opt_gt(ci, cc)(recv, obj)(val) */
const char*
attr_name_opt_gt(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return insn_name(BIN(opt_gt));
}
/* attr rb_num_t open @ opt_gt(ci, cc)(recv, obj)(val) */
rb_num_t
attr_open_opt_gt(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return 2;
}
/* attr rb_num_t popn @ opt_gt(ci, cc)(recv, obj)(val) */
rb_num_t
attr_popn_opt_gt(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return 2;
}
/* attr rb_num_t retn @ opt_gt(ci, cc)(recv, obj)(val) */
rb_num_t
attr_retn_opt_gt(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return 1;
}
/* attr rb_snum_t sp_inc @ opt_gt(ci, cc)(recv, obj)(val) */
rb_snum_t
attr_sp_inc_opt_gt(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return -1;
}
/* attr rb_num_t width @ opt_gt(ci, cc)(recv, obj)(val) */
rb_num_t
attr_width_opt_gt(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return 3;
}
/* attr enum ruby_vminsn_type bin @ opt_ge(ci, cc)(recv, obj)(val) */
enum ruby_vminsn_type
attr_bin_opt_ge(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return BIN(opt_ge);
}
/* attr bool handles_sp @ opt_ge(ci, cc)(recv, obj)(val) */
bool
attr_handles_sp_opt_ge(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return false;
}
/* attr bool leaf @ opt_ge(ci, cc)(recv, obj)(val) */
bool
attr_leaf_opt_ge(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return true;
}
/* attr const char* name @ opt_ge(ci, cc)(recv, obj)(val) */
const char*
attr_name_opt_ge(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return insn_name(BIN(opt_ge));
}
/* attr rb_num_t open @ opt_ge(ci, cc)(recv, obj)(val) */
rb_num_t
attr_open_opt_ge(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return 2;
}
/* attr rb_num_t popn @ opt_ge(ci, cc)(recv, obj)(val) */
rb_num_t
attr_popn_opt_ge(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return 2;
}
/* attr rb_num_t retn @ opt_ge(ci, cc)(recv, obj)(val) */
rb_num_t
attr_retn_opt_ge(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return 1;
}
/* attr rb_snum_t sp_inc @ opt_ge(ci, cc)(recv, obj)(val) */
rb_snum_t
attr_sp_inc_opt_ge(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return -1;
}
/* attr rb_num_t width @ opt_ge(ci, cc)(recv, obj)(val) */
rb_num_t
attr_width_opt_ge(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return 3;
}
/* attr enum ruby_vminsn_type bin @ opt_ltlt(ci, cc)(recv, obj)(val) */
enum ruby_vminsn_type
attr_bin_opt_ltlt(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return BIN(opt_ltlt);
}
/* attr bool handles_sp @ opt_ltlt(ci, cc)(recv, obj)(val) */
bool
attr_handles_sp_opt_ltlt(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return false;
}
/* attr bool leaf @ opt_ltlt(ci, cc)(recv, obj)(val) */
bool
attr_leaf_opt_ltlt(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return true;
}
/* attr const char* name @ opt_ltlt(ci, cc)(recv, obj)(val) */
const char*
attr_name_opt_ltlt(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return insn_name(BIN(opt_ltlt));
}
/* attr rb_num_t open @ opt_ltlt(ci, cc)(recv, obj)(val) */
rb_num_t
attr_open_opt_ltlt(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return 2;
}
/* attr rb_num_t popn @ opt_ltlt(ci, cc)(recv, obj)(val) */
rb_num_t
attr_popn_opt_ltlt(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return 2;
}
/* attr rb_num_t retn @ opt_ltlt(ci, cc)(recv, obj)(val) */
rb_num_t
attr_retn_opt_ltlt(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return 1;
}
/* attr rb_snum_t sp_inc @ opt_ltlt(ci, cc)(recv, obj)(val) */
rb_snum_t
attr_sp_inc_opt_ltlt(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return -1;
}
/* attr rb_num_t width @ opt_ltlt(ci, cc)(recv, obj)(val) */
rb_num_t
attr_width_opt_ltlt(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return 3;
}
/* attr enum ruby_vminsn_type bin @ opt_and(ci, cc)(recv, obj)(val) */
enum ruby_vminsn_type
attr_bin_opt_and(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return BIN(opt_and);
}
/* attr bool handles_sp @ opt_and(ci, cc)(recv, obj)(val) */
bool
attr_handles_sp_opt_and(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return false;
}
/* attr bool leaf @ opt_and(ci, cc)(recv, obj)(val) */
bool
attr_leaf_opt_and(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return true;
}
/* attr const char* name @ opt_and(ci, cc)(recv, obj)(val) */
const char*
attr_name_opt_and(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return insn_name(BIN(opt_and));
}
/* attr rb_num_t open @ opt_and(ci, cc)(recv, obj)(val) */
rb_num_t
attr_open_opt_and(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return 2;
}
/* attr rb_num_t popn @ opt_and(ci, cc)(recv, obj)(val) */
rb_num_t
attr_popn_opt_and(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return 2;
}
/* attr rb_num_t retn @ opt_and(ci, cc)(recv, obj)(val) */
rb_num_t
attr_retn_opt_and(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return 1;
}
/* attr rb_snum_t sp_inc @ opt_and(ci, cc)(recv, obj)(val) */
rb_snum_t
attr_sp_inc_opt_and(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return -1;
}
/* attr rb_num_t width @ opt_and(ci, cc)(recv, obj)(val) */
rb_num_t
attr_width_opt_and(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return 3;
}
/* attr enum ruby_vminsn_type bin @ opt_or(ci, cc)(recv, obj)(val) */
enum ruby_vminsn_type
attr_bin_opt_or(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return BIN(opt_or);
}
/* attr bool handles_sp @ opt_or(ci, cc)(recv, obj)(val) */
bool
attr_handles_sp_opt_or(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return false;
}
/* attr bool leaf @ opt_or(ci, cc)(recv, obj)(val) */
bool
attr_leaf_opt_or(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return true;
}
/* attr const char* name @ opt_or(ci, cc)(recv, obj)(val) */
const char*
attr_name_opt_or(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return insn_name(BIN(opt_or));
}
/* attr rb_num_t open @ opt_or(ci, cc)(recv, obj)(val) */
rb_num_t
attr_open_opt_or(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return 2;
}
/* attr rb_num_t popn @ opt_or(ci, cc)(recv, obj)(val) */
rb_num_t
attr_popn_opt_or(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return 2;
}
/* attr rb_num_t retn @ opt_or(ci, cc)(recv, obj)(val) */
rb_num_t
attr_retn_opt_or(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return 1;
}
/* attr rb_snum_t sp_inc @ opt_or(ci, cc)(recv, obj)(val) */
rb_snum_t
attr_sp_inc_opt_or(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return -1;
}
/* attr rb_num_t width @ opt_or(ci, cc)(recv, obj)(val) */
rb_num_t
attr_width_opt_or(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return 3;
}
/* attr enum ruby_vminsn_type bin @ opt_aref(ci, cc)(recv, obj)(val) */
enum ruby_vminsn_type
attr_bin_opt_aref(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return BIN(opt_aref);
}
/* attr bool handles_sp @ opt_aref(ci, cc)(recv, obj)(val) */
bool
attr_handles_sp_opt_aref(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return false;
}
/* attr bool leaf @ opt_aref(ci, cc)(recv, obj)(val) */
bool
attr_leaf_opt_aref(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return
#line 1253 "insns.def"
false;
#line 7748 "insns_info.inc"
}
/* attr const char* name @ opt_aref(ci, cc)(recv, obj)(val) */
const char*
attr_name_opt_aref(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return insn_name(BIN(opt_aref));
}
/* attr rb_num_t open @ opt_aref(ci, cc)(recv, obj)(val) */
rb_num_t
attr_open_opt_aref(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return 2;
}
/* attr rb_num_t popn @ opt_aref(ci, cc)(recv, obj)(val) */
rb_num_t
attr_popn_opt_aref(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return 2;
}
/* attr rb_num_t retn @ opt_aref(ci, cc)(recv, obj)(val) */
rb_num_t
attr_retn_opt_aref(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return 1;
}
/* attr rb_snum_t sp_inc @ opt_aref(ci, cc)(recv, obj)(val) */
rb_snum_t
attr_sp_inc_opt_aref(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return -1;
}
/* attr rb_num_t width @ opt_aref(ci, cc)(recv, obj)(val) */
rb_num_t
attr_width_opt_aref(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return 3;
}
/* attr enum ruby_vminsn_type bin @ opt_aset(ci, cc)(recv, obj, set)(val) */
enum ruby_vminsn_type
attr_bin_opt_aset(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return BIN(opt_aset);
}
/* attr bool handles_sp @ opt_aset(ci, cc)(recv, obj, set)(val) */
bool
attr_handles_sp_opt_aset(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return false;
}
/* attr bool leaf @ opt_aset(ci, cc)(recv, obj, set)(val) */
bool
attr_leaf_opt_aset(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return
#line 1270 "insns.def"
false;
#line 7841 "insns_info.inc"
}
/* attr const char* name @ opt_aset(ci, cc)(recv, obj, set)(val) */
const char*
attr_name_opt_aset(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return insn_name(BIN(opt_aset));
}
/* attr rb_num_t open @ opt_aset(ci, cc)(recv, obj, set)(val) */
rb_num_t
attr_open_opt_aset(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return 2;
}
/* attr rb_num_t popn @ opt_aset(ci, cc)(recv, obj, set)(val) */
rb_num_t
attr_popn_opt_aset(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return 3;
}
/* attr rb_num_t retn @ opt_aset(ci, cc)(recv, obj, set)(val) */
rb_num_t
attr_retn_opt_aset(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return 1;
}
/* attr rb_snum_t sp_inc @ opt_aset(ci, cc)(recv, obj, set)(val) */
rb_snum_t
attr_sp_inc_opt_aset(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return -2;
}
/* attr rb_num_t width @ opt_aset(ci, cc)(recv, obj, set)(val) */
rb_num_t
attr_width_opt_aset(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return 3;
}
/* attr enum ruby_vminsn_type bin @ opt_aset_with(key, ci, cc)(recv, val)(val) */
enum ruby_vminsn_type
attr_bin_opt_aset_with(
MAYBE_UNUSED(VALUE key),
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return BIN(opt_aset_with);
}
/* attr bool handles_sp @ opt_aset_with(key, ci, cc)(recv, val)(val) */
bool
attr_handles_sp_opt_aset_with(
MAYBE_UNUSED(VALUE key),
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return false;
}
/* attr bool leaf @ opt_aset_with(key, ci, cc)(recv, val)(val) */
bool
attr_leaf_opt_aset_with(
MAYBE_UNUSED(VALUE key),
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return
#line 1286 "insns.def"
false;
#line 7937 "insns_info.inc"
}
/* attr const char* name @ opt_aset_with(key, ci, cc)(recv, val)(val) */
const char*
attr_name_opt_aset_with(
MAYBE_UNUSED(VALUE key),
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return insn_name(BIN(opt_aset_with));
}
/* attr rb_num_t open @ opt_aset_with(key, ci, cc)(recv, val)(val) */
rb_num_t
attr_open_opt_aset_with(
MAYBE_UNUSED(VALUE key),
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return 3;
}
/* attr rb_num_t popn @ opt_aset_with(key, ci, cc)(recv, val)(val) */
rb_num_t
attr_popn_opt_aset_with(
MAYBE_UNUSED(VALUE key),
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return 2;
}
/* attr rb_num_t retn @ opt_aset_with(key, ci, cc)(recv, val)(val) */
rb_num_t
attr_retn_opt_aset_with(
MAYBE_UNUSED(VALUE key),
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return 1;
}
/* attr rb_snum_t sp_inc @ opt_aset_with(key, ci, cc)(recv, val)(val) */
rb_snum_t
attr_sp_inc_opt_aset_with(
MAYBE_UNUSED(VALUE key),
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return -1;
}
/* attr rb_num_t width @ opt_aset_with(key, ci, cc)(recv, val)(val) */
rb_num_t
attr_width_opt_aset_with(
MAYBE_UNUSED(VALUE key),
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return 4;
}
/* attr enum ruby_vminsn_type bin @ opt_aref_with(key, ci, cc)(recv)(val) */
enum ruby_vminsn_type
attr_bin_opt_aref_with(
MAYBE_UNUSED(VALUE key),
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return BIN(opt_aref_with);
}
/* attr bool handles_sp @ opt_aref_with(key, ci, cc)(recv)(val) */
bool
attr_handles_sp_opt_aref_with(
MAYBE_UNUSED(VALUE key),
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return false;
}
/* attr bool leaf @ opt_aref_with(key, ci, cc)(recv)(val) */
bool
attr_leaf_opt_aref_with(
MAYBE_UNUSED(VALUE key),
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return
#line 1309 "insns.def"
false;
#line 8039 "insns_info.inc"
}
/* attr const char* name @ opt_aref_with(key, ci, cc)(recv)(val) */
const char*
attr_name_opt_aref_with(
MAYBE_UNUSED(VALUE key),
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return insn_name(BIN(opt_aref_with));
}
/* attr rb_num_t open @ opt_aref_with(key, ci, cc)(recv)(val) */
rb_num_t
attr_open_opt_aref_with(
MAYBE_UNUSED(VALUE key),
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return 3;
}
/* attr rb_num_t popn @ opt_aref_with(key, ci, cc)(recv)(val) */
rb_num_t
attr_popn_opt_aref_with(
MAYBE_UNUSED(VALUE key),
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return 1;
}
/* attr rb_num_t retn @ opt_aref_with(key, ci, cc)(recv)(val) */
rb_num_t
attr_retn_opt_aref_with(
MAYBE_UNUSED(VALUE key),
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return 1;
}
/* attr rb_snum_t sp_inc @ opt_aref_with(key, ci, cc)(recv)(val) */
rb_snum_t
attr_sp_inc_opt_aref_with(
MAYBE_UNUSED(VALUE key),
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return 0;
}
/* attr rb_num_t width @ opt_aref_with(key, ci, cc)(recv)(val) */
rb_num_t
attr_width_opt_aref_with(
MAYBE_UNUSED(VALUE key),
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return 4;
}
/* attr enum ruby_vminsn_type bin @ opt_length(ci, cc)(recv)(val) */
enum ruby_vminsn_type
attr_bin_opt_length(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return BIN(opt_length);
}
/* attr bool handles_sp @ opt_length(ci, cc)(recv)(val) */
bool
attr_handles_sp_opt_length(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return false;
}
/* attr bool leaf @ opt_length(ci, cc)(recv)(val) */
bool
attr_leaf_opt_length(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return true;
}
/* attr const char* name @ opt_length(ci, cc)(recv)(val) */
const char*
attr_name_opt_length(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return insn_name(BIN(opt_length));
}
/* attr rb_num_t open @ opt_length(ci, cc)(recv)(val) */
rb_num_t
attr_open_opt_length(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return 2;
}
/* attr rb_num_t popn @ opt_length(ci, cc)(recv)(val) */
rb_num_t
attr_popn_opt_length(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return 1;
}
/* attr rb_num_t retn @ opt_length(ci, cc)(recv)(val) */
rb_num_t
attr_retn_opt_length(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return 1;
}
/* attr rb_snum_t sp_inc @ opt_length(ci, cc)(recv)(val) */
rb_snum_t
attr_sp_inc_opt_length(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return 0;
}
/* attr rb_num_t width @ opt_length(ci, cc)(recv)(val) */
rb_num_t
attr_width_opt_length(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return 3;
}
/* attr enum ruby_vminsn_type bin @ opt_size(ci, cc)(recv)(val) */
enum ruby_vminsn_type
attr_bin_opt_size(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return BIN(opt_size);
}
/* attr bool handles_sp @ opt_size(ci, cc)(recv)(val) */
bool
attr_handles_sp_opt_size(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return false;
}
/* attr bool leaf @ opt_size(ci, cc)(recv)(val) */
bool
attr_leaf_opt_size(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return true;
}
/* attr const char* name @ opt_size(ci, cc)(recv)(val) */
const char*
attr_name_opt_size(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return insn_name(BIN(opt_size));
}
/* attr rb_num_t open @ opt_size(ci, cc)(recv)(val) */
rb_num_t
attr_open_opt_size(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return 2;
}
/* attr rb_num_t popn @ opt_size(ci, cc)(recv)(val) */
rb_num_t
attr_popn_opt_size(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return 1;
}
/* attr rb_num_t retn @ opt_size(ci, cc)(recv)(val) */
rb_num_t
attr_retn_opt_size(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return 1;
}
/* attr rb_snum_t sp_inc @ opt_size(ci, cc)(recv)(val) */
rb_snum_t
attr_sp_inc_opt_size(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return 0;
}
/* attr rb_num_t width @ opt_size(ci, cc)(recv)(val) */
rb_num_t
attr_width_opt_size(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return 3;
}
/* attr enum ruby_vminsn_type bin @ opt_empty_p(ci, cc)(recv)(val) */
enum ruby_vminsn_type
attr_bin_opt_empty_p(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return BIN(opt_empty_p);
}
/* attr bool handles_sp @ opt_empty_p(ci, cc)(recv)(val) */
bool
attr_handles_sp_opt_empty_p(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return false;
}
/* attr bool leaf @ opt_empty_p(ci, cc)(recv)(val) */
bool
attr_leaf_opt_empty_p(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return true;
}
/* attr const char* name @ opt_empty_p(ci, cc)(recv)(val) */
const char*
attr_name_opt_empty_p(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return insn_name(BIN(opt_empty_p));
}
/* attr rb_num_t open @ opt_empty_p(ci, cc)(recv)(val) */
rb_num_t
attr_open_opt_empty_p(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return 2;
}
/* attr rb_num_t popn @ opt_empty_p(ci, cc)(recv)(val) */
rb_num_t
attr_popn_opt_empty_p(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return 1;
}
/* attr rb_num_t retn @ opt_empty_p(ci, cc)(recv)(val) */
rb_num_t
attr_retn_opt_empty_p(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return 1;
}
/* attr rb_snum_t sp_inc @ opt_empty_p(ci, cc)(recv)(val) */
rb_snum_t
attr_sp_inc_opt_empty_p(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return 0;
}
/* attr rb_num_t width @ opt_empty_p(ci, cc)(recv)(val) */
rb_num_t
attr_width_opt_empty_p(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return 3;
}
/* attr enum ruby_vminsn_type bin @ opt_succ(ci, cc)(recv)(val) */
enum ruby_vminsn_type
attr_bin_opt_succ(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return BIN(opt_succ);
}
/* attr bool handles_sp @ opt_succ(ci, cc)(recv)(val) */
bool
attr_handles_sp_opt_succ(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return false;
}
/* attr bool leaf @ opt_succ(ci, cc)(recv)(val) */
bool
attr_leaf_opt_succ(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return true;
}
/* attr const char* name @ opt_succ(ci, cc)(recv)(val) */
const char*
attr_name_opt_succ(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return insn_name(BIN(opt_succ));
}
/* attr rb_num_t open @ opt_succ(ci, cc)(recv)(val) */
rb_num_t
attr_open_opt_succ(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return 2;
}
/* attr rb_num_t popn @ opt_succ(ci, cc)(recv)(val) */
rb_num_t
attr_popn_opt_succ(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return 1;
}
/* attr rb_num_t retn @ opt_succ(ci, cc)(recv)(val) */
rb_num_t
attr_retn_opt_succ(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return 1;
}
/* attr rb_snum_t sp_inc @ opt_succ(ci, cc)(recv)(val) */
rb_snum_t
attr_sp_inc_opt_succ(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return 0;
}
/* attr rb_num_t width @ opt_succ(ci, cc)(recv)(val) */
rb_num_t
attr_width_opt_succ(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return 3;
}
/* attr enum ruby_vminsn_type bin @ opt_not(ci, cc)(recv)(val) */
enum ruby_vminsn_type
attr_bin_opt_not(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return BIN(opt_not);
}
/* attr bool handles_sp @ opt_not(ci, cc)(recv)(val) */
bool
attr_handles_sp_opt_not(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return false;
}
/* attr bool leaf @ opt_not(ci, cc)(recv)(val) */
bool
attr_leaf_opt_not(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return true;
}
/* attr const char* name @ opt_not(ci, cc)(recv)(val) */
const char*
attr_name_opt_not(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return insn_name(BIN(opt_not));
}
/* attr rb_num_t open @ opt_not(ci, cc)(recv)(val) */
rb_num_t
attr_open_opt_not(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return 2;
}
/* attr rb_num_t popn @ opt_not(ci, cc)(recv)(val) */
rb_num_t
attr_popn_opt_not(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return 1;
}
/* attr rb_num_t retn @ opt_not(ci, cc)(recv)(val) */
rb_num_t
attr_retn_opt_not(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return 1;
}
/* attr rb_snum_t sp_inc @ opt_not(ci, cc)(recv)(val) */
rb_snum_t
attr_sp_inc_opt_not(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return 0;
}
/* attr rb_num_t width @ opt_not(ci, cc)(recv)(val) */
rb_num_t
attr_width_opt_not(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return 3;
}
/* attr enum ruby_vminsn_type bin @ opt_regexpmatch1(recv)(obj)(val) */
enum ruby_vminsn_type
attr_bin_opt_regexpmatch1(MAYBE_UNUSED(VALUE recv))
{
return BIN(opt_regexpmatch1);
}
/* attr bool handles_sp @ opt_regexpmatch1(recv)(obj)(val) */
bool
attr_handles_sp_opt_regexpmatch1(MAYBE_UNUSED(VALUE recv))
{
return false;
}
/* attr bool leaf @ opt_regexpmatch1(recv)(obj)(val) */
bool
attr_leaf_opt_regexpmatch1(MAYBE_UNUSED(VALUE recv))
{
return
#line 1397 "insns.def"
BASIC_OP_UNREDEFINED_P(BOP_MATCH, REGEXP_REDEFINED_OP_FLAG);
#line 8579 "insns_info.inc"
}
/* attr const char* name @ opt_regexpmatch1(recv)(obj)(val) */
const char*
attr_name_opt_regexpmatch1(MAYBE_UNUSED(VALUE recv))
{
return insn_name(BIN(opt_regexpmatch1));
}
/* attr rb_num_t open @ opt_regexpmatch1(recv)(obj)(val) */
rb_num_t
attr_open_opt_regexpmatch1(MAYBE_UNUSED(VALUE recv))
{
return 1;
}
/* attr rb_num_t popn @ opt_regexpmatch1(recv)(obj)(val) */
rb_num_t
attr_popn_opt_regexpmatch1(MAYBE_UNUSED(VALUE recv))
{
return 1;
}
/* attr rb_num_t retn @ opt_regexpmatch1(recv)(obj)(val) */
rb_num_t
attr_retn_opt_regexpmatch1(MAYBE_UNUSED(VALUE recv))
{
return 1;
}
/* attr rb_snum_t sp_inc @ opt_regexpmatch1(recv)(obj)(val) */
rb_snum_t
attr_sp_inc_opt_regexpmatch1(MAYBE_UNUSED(VALUE recv))
{
return 0;
}
/* attr rb_num_t width @ opt_regexpmatch1(recv)(obj)(val) */
rb_num_t
attr_width_opt_regexpmatch1(MAYBE_UNUSED(VALUE recv))
{
return 2;
}
/* attr enum ruby_vminsn_type bin @ opt_regexpmatch2(ci, cc)(obj2, obj1)(val) */
enum ruby_vminsn_type
attr_bin_opt_regexpmatch2(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return BIN(opt_regexpmatch2);
}
/* attr bool handles_sp @ opt_regexpmatch2(ci, cc)(obj2, obj1)(val) */
bool
attr_handles_sp_opt_regexpmatch2(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return false;
}
/* attr bool leaf @ opt_regexpmatch2(ci, cc)(obj2, obj1)(val) */
bool
attr_leaf_opt_regexpmatch2(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return true;
}
/* attr const char* name @ opt_regexpmatch2(ci, cc)(obj2, obj1)(val) */
const char*
attr_name_opt_regexpmatch2(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return insn_name(BIN(opt_regexpmatch2));
}
/* attr rb_num_t open @ opt_regexpmatch2(ci, cc)(obj2, obj1)(val) */
rb_num_t
attr_open_opt_regexpmatch2(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return 2;
}
/* attr rb_num_t popn @ opt_regexpmatch2(ci, cc)(obj2, obj1)(val) */
rb_num_t
attr_popn_opt_regexpmatch2(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return 2;
}
/* attr rb_num_t retn @ opt_regexpmatch2(ci, cc)(obj2, obj1)(val) */
rb_num_t
attr_retn_opt_regexpmatch2(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return 1;
}
/* attr rb_snum_t sp_inc @ opt_regexpmatch2(ci, cc)(obj2, obj1)(val) */
rb_snum_t
attr_sp_inc_opt_regexpmatch2(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return -1;
}
/* attr rb_num_t width @ opt_regexpmatch2(ci, cc)(obj2, obj1)(val) */
rb_num_t
attr_width_opt_regexpmatch2(
MAYBE_UNUSED(CALL_INFO ci),
MAYBE_UNUSED(CALL_CACHE cc)
)
{
return 3;
}
/* attr enum ruby_vminsn_type bin @ opt_call_c_function(funcptr)()() */
enum ruby_vminsn_type
attr_bin_opt_call_c_function(MAYBE_UNUSED(rb_insn_func_t funcptr))
{
return BIN(opt_call_c_function);
}
/* attr bool handles_sp @ opt_call_c_function(funcptr)()() */
bool
attr_handles_sp_opt_call_c_function(MAYBE_UNUSED(rb_insn_func_t funcptr))
{
return
#line 1423 "insns.def"
true;
#line 8728 "insns_info.inc"
}
/* attr bool leaf @ opt_call_c_function(funcptr)()() */
bool
attr_leaf_opt_call_c_function(MAYBE_UNUSED(rb_insn_func_t funcptr))
{
return
#line 1422 "insns.def"
false;
#line 8738 "insns_info.inc"
}
/* attr const char* name @ opt_call_c_function(funcptr)()() */
const char*
attr_name_opt_call_c_function(MAYBE_UNUSED(rb_insn_func_t funcptr))
{
return insn_name(BIN(opt_call_c_function));
}
/* attr rb_num_t open @ opt_call_c_function(funcptr)()() */
rb_num_t
attr_open_opt_call_c_function(MAYBE_UNUSED(rb_insn_func_t funcptr))
{
return 1;
}
/* attr rb_num_t popn @ opt_call_c_function(funcptr)()() */
rb_num_t
attr_popn_opt_call_c_function(MAYBE_UNUSED(rb_insn_func_t funcptr))
{
return 0;
}
/* attr rb_num_t retn @ opt_call_c_function(funcptr)()() */
rb_num_t
attr_retn_opt_call_c_function(MAYBE_UNUSED(rb_insn_func_t funcptr))
{
return 0;
}
/* attr rb_snum_t sp_inc @ opt_call_c_function(funcptr)()() */
rb_snum_t
attr_sp_inc_opt_call_c_function(MAYBE_UNUSED(rb_insn_func_t funcptr))
{
return 0;
}
/* attr rb_num_t width @ opt_call_c_function(funcptr)()() */
rb_num_t
attr_width_opt_call_c_function(MAYBE_UNUSED(rb_insn_func_t funcptr))
{
return 2;
}
/* attr enum ruby_vminsn_type bin @ bitblt()()(ret) */
enum ruby_vminsn_type
attr_bin_bitblt(void)
{
return BIN(bitblt);
}
/* attr bool handles_sp @ bitblt()()(ret) */
bool
attr_handles_sp_bitblt(void)
{
return false;
}
/* attr bool leaf @ bitblt()()(ret) */
bool
attr_leaf_bitblt(void)
{
return true;
}
/* attr const char* name @ bitblt()()(ret) */
const char*
attr_name_bitblt(void)
{
return insn_name(BIN(bitblt));
}
/* attr rb_num_t open @ bitblt()()(ret) */
rb_num_t
attr_open_bitblt(void)
{
return 0;
}
/* attr rb_num_t popn @ bitblt()()(ret) */
rb_num_t
attr_popn_bitblt(void)
{
return 0;
}
/* attr rb_num_t retn @ bitblt()()(ret) */
rb_num_t
attr_retn_bitblt(void)
{
return 1;
}
/* attr rb_snum_t sp_inc @ bitblt()()(ret) */
rb_snum_t
attr_sp_inc_bitblt(void)
{
return 1;
}
/* attr rb_num_t width @ bitblt()()(ret) */
rb_num_t
attr_width_bitblt(void)
{
return 1;
}
/* attr enum ruby_vminsn_type bin @ answer()()(ret) */
enum ruby_vminsn_type
attr_bin_answer(void)
{
return BIN(answer);
}
/* attr bool handles_sp @ answer()()(ret) */
bool
attr_handles_sp_answer(void)
{
return false;
}
/* attr bool leaf @ answer()()(ret) */
bool
attr_leaf_answer(void)
{
return true;
}
/* attr const char* name @ answer()()(ret) */
const char*
attr_name_answer(void)
{
return insn_name(BIN(answer));
}
/* attr rb_num_t open @ answer()()(ret) */
rb_num_t
attr_open_answer(void)
{
return 0;
}
/* attr rb_num_t popn @ answer()()(ret) */
rb_num_t
attr_popn_answer(void)
{
return 0;
}
/* attr rb_num_t retn @ answer()()(ret) */
rb_num_t
attr_retn_answer(void)
{
return 1;
}
/* attr rb_snum_t sp_inc @ answer()()(ret) */
rb_snum_t
attr_sp_inc_answer(void)
{
return 1;
}
/* attr rb_num_t width @ answer()()(ret) */
rb_num_t
attr_width_answer(void)
{
return 1;
}
/* attr enum ruby_vminsn_type bin @ getlocal_WC_0(idx)()(val) */
enum ruby_vminsn_type
attr_bin_getlocal_WC_0(MAYBE_UNUSED(lindex_t idx))
{
return BIN(getlocal_WC_0);
}
/* attr bool handles_sp @ getlocal_WC_0(idx)()(val) */
bool
attr_handles_sp_getlocal_WC_0(MAYBE_UNUSED(lindex_t idx))
{
return false;
}
/* attr bool leaf @ getlocal_WC_0(idx)()(val) */
bool
attr_leaf_getlocal_WC_0(MAYBE_UNUSED(lindex_t idx))
{
return true;
}
/* attr const char* name @ getlocal_WC_0(idx)()(val) */
const char*
attr_name_getlocal_WC_0(MAYBE_UNUSED(lindex_t idx))
{
return insn_name(BIN(getlocal_WC_0));
}
/* attr rb_num_t open @ getlocal_WC_0(idx)()(val) */
rb_num_t
attr_open_getlocal_WC_0(MAYBE_UNUSED(lindex_t idx))
{
return 1;
}
/* attr rb_num_t popn @ getlocal_WC_0(idx)()(val) */
rb_num_t
attr_popn_getlocal_WC_0(MAYBE_UNUSED(lindex_t idx))
{
return 0;
}
/* attr rb_num_t retn @ getlocal_WC_0(idx)()(val) */
rb_num_t
attr_retn_getlocal_WC_0(MAYBE_UNUSED(lindex_t idx))
{
return 1;
}
/* attr rb_snum_t sp_inc @ getlocal_WC_0(idx)()(val) */
rb_snum_t
attr_sp_inc_getlocal_WC_0(MAYBE_UNUSED(lindex_t idx))
{
return 1;
}
/* attr rb_num_t width @ getlocal_WC_0(idx)()(val) */
rb_num_t
attr_width_getlocal_WC_0(MAYBE_UNUSED(lindex_t idx))
{
return 2;
}
/* attr enum ruby_vminsn_type bin @ getlocal_WC_1(idx)()(val) */
enum ruby_vminsn_type
attr_bin_getlocal_WC_1(MAYBE_UNUSED(lindex_t idx))
{
return BIN(getlocal_WC_1);
}
/* attr bool handles_sp @ getlocal_WC_1(idx)()(val) */
bool
attr_handles_sp_getlocal_WC_1(MAYBE_UNUSED(lindex_t idx))
{
return false;
}
/* attr bool leaf @ getlocal_WC_1(idx)()(val) */
bool
attr_leaf_getlocal_WC_1(MAYBE_UNUSED(lindex_t idx))
{
return true;
}
/* attr const char* name @ getlocal_WC_1(idx)()(val) */
const char*
attr_name_getlocal_WC_1(MAYBE_UNUSED(lindex_t idx))
{
return insn_name(BIN(getlocal_WC_1));
}
/* attr rb_num_t open @ getlocal_WC_1(idx)()(val) */
rb_num_t
attr_open_getlocal_WC_1(MAYBE_UNUSED(lindex_t idx))
{
return 1;
}
/* attr rb_num_t popn @ getlocal_WC_1(idx)()(val) */
rb_num_t
attr_popn_getlocal_WC_1(MAYBE_UNUSED(lindex_t idx))
{
return 0;
}
/* attr rb_num_t retn @ getlocal_WC_1(idx)()(val) */
rb_num_t
attr_retn_getlocal_WC_1(MAYBE_UNUSED(lindex_t idx))
{
return 1;
}
/* attr rb_snum_t sp_inc @ getlocal_WC_1(idx)()(val) */
rb_snum_t
attr_sp_inc_getlocal_WC_1(MAYBE_UNUSED(lindex_t idx))
{
return 1;
}
/* attr rb_num_t width @ getlocal_WC_1(idx)()(val) */
rb_num_t
attr_width_getlocal_WC_1(MAYBE_UNUSED(lindex_t idx))
{
return 2;
}
/* attr enum ruby_vminsn_type bin @ setlocal_WC_0(idx)(val)() */
enum ruby_vminsn_type
attr_bin_setlocal_WC_0(MAYBE_UNUSED(lindex_t idx))
{
return BIN(setlocal_WC_0);
}
/* attr bool handles_sp @ setlocal_WC_0(idx)(val)() */
bool
attr_handles_sp_setlocal_WC_0(MAYBE_UNUSED(lindex_t idx))
{
return false;
}
/* attr bool leaf @ setlocal_WC_0(idx)(val)() */
bool
attr_leaf_setlocal_WC_0(MAYBE_UNUSED(lindex_t idx))
{
return true;
}
/* attr const char* name @ setlocal_WC_0(idx)(val)() */
const char*
attr_name_setlocal_WC_0(MAYBE_UNUSED(lindex_t idx))
{
return insn_name(BIN(setlocal_WC_0));
}
/* attr rb_num_t open @ setlocal_WC_0(idx)(val)() */
rb_num_t
attr_open_setlocal_WC_0(MAYBE_UNUSED(lindex_t idx))
{
return 1;
}
/* attr rb_num_t popn @ setlocal_WC_0(idx)(val)() */
rb_num_t
attr_popn_setlocal_WC_0(MAYBE_UNUSED(lindex_t idx))
{
return 1;
}
/* attr rb_num_t retn @ setlocal_WC_0(idx)(val)() */
rb_num_t
attr_retn_setlocal_WC_0(MAYBE_UNUSED(lindex_t idx))
{
return 0;
}
/* attr rb_snum_t sp_inc @ setlocal_WC_0(idx)(val)() */
rb_snum_t
attr_sp_inc_setlocal_WC_0(MAYBE_UNUSED(lindex_t idx))
{
return -1;
}
/* attr rb_num_t width @ setlocal_WC_0(idx)(val)() */
rb_num_t
attr_width_setlocal_WC_0(MAYBE_UNUSED(lindex_t idx))
{
return 2;
}
/* attr enum ruby_vminsn_type bin @ setlocal_WC_1(idx)(val)() */
enum ruby_vminsn_type
attr_bin_setlocal_WC_1(MAYBE_UNUSED(lindex_t idx))
{
return BIN(setlocal_WC_1);
}
/* attr bool handles_sp @ setlocal_WC_1(idx)(val)() */
bool
attr_handles_sp_setlocal_WC_1(MAYBE_UNUSED(lindex_t idx))
{
return false;
}
/* attr bool leaf @ setlocal_WC_1(idx)(val)() */
bool
attr_leaf_setlocal_WC_1(MAYBE_UNUSED(lindex_t idx))
{
return true;
}
/* attr const char* name @ setlocal_WC_1(idx)(val)() */
const char*
attr_name_setlocal_WC_1(MAYBE_UNUSED(lindex_t idx))
{
return insn_name(BIN(setlocal_WC_1));
}
/* attr rb_num_t open @ setlocal_WC_1(idx)(val)() */
rb_num_t
attr_open_setlocal_WC_1(MAYBE_UNUSED(lindex_t idx))
{
return 1;
}
/* attr rb_num_t popn @ setlocal_WC_1(idx)(val)() */
rb_num_t
attr_popn_setlocal_WC_1(MAYBE_UNUSED(lindex_t idx))
{
return 1;
}
/* attr rb_num_t retn @ setlocal_WC_1(idx)(val)() */
rb_num_t
attr_retn_setlocal_WC_1(MAYBE_UNUSED(lindex_t idx))
{
return 0;
}
/* attr rb_snum_t sp_inc @ setlocal_WC_1(idx)(val)() */
rb_snum_t
attr_sp_inc_setlocal_WC_1(MAYBE_UNUSED(lindex_t idx))
{
return -1;
}
/* attr rb_num_t width @ setlocal_WC_1(idx)(val)() */
rb_num_t
attr_width_setlocal_WC_1(MAYBE_UNUSED(lindex_t idx))
{
return 2;
}
/* attr enum ruby_vminsn_type bin @ putobject_INT2FIX_0_()()(val) */
enum ruby_vminsn_type
attr_bin_putobject_INT2FIX_0_(void)
{
return BIN(putobject_INT2FIX_0_);
}
/* attr bool handles_sp @ putobject_INT2FIX_0_()()(val) */
bool
attr_handles_sp_putobject_INT2FIX_0_(void)
{
return false;
}
/* attr bool leaf @ putobject_INT2FIX_0_()()(val) */
bool
attr_leaf_putobject_INT2FIX_0_(void)
{
return true;
}
/* attr const char* name @ putobject_INT2FIX_0_()()(val) */
const char*
attr_name_putobject_INT2FIX_0_(void)
{
return insn_name(BIN(putobject_INT2FIX_0_));
}
/* attr rb_num_t open @ putobject_INT2FIX_0_()()(val) */
rb_num_t
attr_open_putobject_INT2FIX_0_(void)
{
return 0;
}
/* attr rb_num_t popn @ putobject_INT2FIX_0_()()(val) */
rb_num_t
attr_popn_putobject_INT2FIX_0_(void)
{
return 0;
}
/* attr rb_num_t retn @ putobject_INT2FIX_0_()()(val) */
rb_num_t
attr_retn_putobject_INT2FIX_0_(void)
{
return 1;
}
/* attr rb_snum_t sp_inc @ putobject_INT2FIX_0_()()(val) */
rb_snum_t
attr_sp_inc_putobject_INT2FIX_0_(void)
{
return 1;
}
/* attr rb_num_t width @ putobject_INT2FIX_0_()()(val) */
rb_num_t
attr_width_putobject_INT2FIX_0_(void)
{
return 1;
}
/* attr enum ruby_vminsn_type bin @ putobject_INT2FIX_1_()()(val) */
enum ruby_vminsn_type
attr_bin_putobject_INT2FIX_1_(void)
{
return BIN(putobject_INT2FIX_1_);
}
/* attr bool handles_sp @ putobject_INT2FIX_1_()()(val) */
bool
attr_handles_sp_putobject_INT2FIX_1_(void)
{
return false;
}
/* attr bool leaf @ putobject_INT2FIX_1_()()(val) */
bool
attr_leaf_putobject_INT2FIX_1_(void)
{
return true;
}
/* attr const char* name @ putobject_INT2FIX_1_()()(val) */
const char*
attr_name_putobject_INT2FIX_1_(void)
{
return insn_name(BIN(putobject_INT2FIX_1_));
}
/* attr rb_num_t open @ putobject_INT2FIX_1_()()(val) */
rb_num_t
attr_open_putobject_INT2FIX_1_(void)
{
return 0;
}
/* attr rb_num_t popn @ putobject_INT2FIX_1_()()(val) */
rb_num_t
attr_popn_putobject_INT2FIX_1_(void)
{
return 0;
}
/* attr rb_num_t retn @ putobject_INT2FIX_1_()()(val) */
rb_num_t
attr_retn_putobject_INT2FIX_1_(void)
{
return 1;
}
/* attr rb_snum_t sp_inc @ putobject_INT2FIX_1_()()(val) */
rb_snum_t
attr_sp_inc_putobject_INT2FIX_1_(void)
{
return 1;
}
/* attr rb_num_t width @ putobject_INT2FIX_1_()()(val) */
rb_num_t
attr_width_putobject_INT2FIX_1_(void)
{
return 1;
}
PUREFUNC(MAYBE_UNUSED(static int insn_stack_increase(int depth, int insn, const VALUE *opes)));
PUREFUNC(static rb_snum_t insn_stack_increase_dispatch(enum ruby_vminsn_type insn, const VALUE *opes));
rb_snum_t
insn_stack_increase_dispatch(enum ruby_vminsn_type insn, const VALUE *opes)
{
static const signed char t[] = {
0, 1, -1, 1, -1, 1, 1, -1,
1, -1, 1, -1, 0, -2, 1, -1,
1, 1, 1, 1, 1, 1, -127, -1,
0, -127, 0, -127, 1, 1, -127, -1,
0, -127, -1, -1, 1, -127, 0, -127,
-127, -127, -127, -127, 0, -1, 1, 0,
-1, -127, -127, 1, 1, -127, -127, -127,
-127, 0, 0, 0, -1, -1, -1, 1,
0, 1, -127, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -2, -1, 0, 0, 0, 0,
0, 0, 0, -1, 0, 1, 1, 1,
1, -1, -1, 1, 1, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0,
};
signed char c = t[insn];
ASSERT_VM_INSTRUCTION_SIZE(t);
if (c != -127) {
return c;
}
else switch(insn) {
default:
UNREACHABLE;
case BIN(concatstrings):
return attr_sp_inc_concatstrings(NUM2LONG(opes[0]));
case BIN(toregexp):
return attr_sp_inc_toregexp(NUM2LONG(opes[0]), NUM2LONG(opes[1]));
case BIN(newarray):
return attr_sp_inc_newarray(NUM2LONG(opes[0]));
case BIN(expandarray):
return attr_sp_inc_expandarray(NUM2LONG(opes[0]), NUM2LONG(opes[1]));
case BIN(newhash):
return attr_sp_inc_newhash(NUM2LONG(opes[0]));
case BIN(dupn):
return attr_sp_inc_dupn(NUM2LONG(opes[0]));
case BIN(reverse):
return attr_sp_inc_reverse(NUM2LONG(opes[0]));
case BIN(reput):
return attr_sp_inc_reput();
case BIN(topn):
return attr_sp_inc_topn(NUM2LONG(opes[0]));
case BIN(setn):
return attr_sp_inc_setn(NUM2LONG(opes[0]));
case BIN(adjuststack):
return attr_sp_inc_adjuststack(NUM2LONG(opes[0]));
case BIN(send):
return attr_sp_inc_send((CALL_INFO)(opes[0]), (CALL_CACHE)(opes[1]), (ISEQ)(opes[2]));
case BIN(opt_send_without_block):
return attr_sp_inc_opt_send_without_block((CALL_INFO)(opes[0]), (CALL_CACHE)(opes[1]));
case BIN(opt_newarray_max):
return attr_sp_inc_opt_newarray_max(NUM2LONG(opes[0]));
case BIN(opt_newarray_min):
return attr_sp_inc_opt_newarray_min(NUM2LONG(opes[0]));
case BIN(invokesuper):
return attr_sp_inc_invokesuper((CALL_INFO)(opes[0]), (CALL_CACHE)(opes[1]), (ISEQ)(opes[2]));
case BIN(invokeblock):
return attr_sp_inc_invokeblock((CALL_INFO)(opes[0]));
case BIN(opt_case_dispatch):
return attr_sp_inc_opt_case_dispatch((CDHASH)(opes[0]), (OFFSET)(opes[1]));
}
}
int
insn_stack_increase(int depth, int insn, const VALUE *opes)
{
enum ruby_vminsn_type itype = (enum ruby_vminsn_type)insn;
return depth + (int)insn_stack_increase_dispatch(itype, opes);
}