1/* -*- mode:c; style:ruby; coding: utf-8; indent-tabs-mode: nil -*- */ 2 3/* This is an auto-generated file and is a part of the programming language 4 * Ruby. The person who created a program to generate this file (``I'' 5 * hereafter) would like to refrain from defining licensing of this generated 6 * source code. 7 * 8 * This file consist of many small parts of codes copyrighted by each authors, 9 * not only the ``I'' person. Those original authors agree with some 10 * open-source license. I believe that the license we agree is the condition 11 * mentioned in the file COPYING. It states "4. You may modify and include 12 * the part of the software into any other software ...". But the problem is, 13 * the license never makes it clear if such modified parts still remain in the 14 * same license, or not. The fact that we agree with the source code's 15 * licensing terms do not automatically define that of generated ones. This is 16 * the reason why this file is under unclear situation. All that I know is 17 * that above provision guarantees this file to exist. 18 * 19 * Please let me hesitate to declare something about this nuanced contract. I 20 * am not in the position to take over other authors' license to merge into my 21 * one. Changing them to (say) GPLv3 is not doable by myself. Perhaps someday 22 * it might turn out to be okay to say this file is under a license. I wish the 23 * situation would become more clear in the future. */ 24 25/*******************************************************************/ 26/*******************************************************************/ 27/*******************************************************************/ 28/** 29 This file contains instruction information for yarv instruction sequence.. 30 31 ---- 32 This file is auto generated by insns2vm.rb 33 DO NOT TOUCH! 34 35 If you want to fix something, you must edit "tool/ruby_vm/views/insns_info.inc.erb" 36 or tool/insns2vm.rb 37 */ 38 39enum ruby_insn_type_chars { 40 TS_VARIABLE = '.', 41 TS_CALLCACHE = 'E', 42 TS_CALLINFO = 'C', 43 TS_CDHASH = 'H', 44 TS_GENTRY = 'G', 45 TS_IC = 'K', 46 TS_ID = 'I', 47 TS_ISE = 'T', 48 TS_ISEQ = 'S', 49 TS_OFFSET = 'O', 50 TS_VALUE = 'V', 51 TS_LINDEX = 'L', 52 TS_FUNCPTR = 'F', 53 TS_NUM = 'N' 54}; 55 56CONSTFUNC(MAYBE_UNUSED(static const char *insn_name(VALUE insn))); 57extern const char *rb_vm_insn_name_info; 58MJIT_SYMBOL_EXPORT_BEGIN 59extern const unsigned short rb_vm_insn_name_offset[]; 60MJIT_SYMBOL_EXPORT_END 61 62#ifdef RUBY_VM_INSNS_INFO 63const unsigned short rb_vm_insn_name_offset[] = { 64 0, 4, 13, 22, 36, 50, 69, 80, 91, 111, 131, 148, 65 165, 177, 189, 199, 209, 216, 224, 234, 251, 259, 269, 283, 66 292, 305, 314, 321, 330, 339, 347, 359, 371, 382, 390, 399, 67 403, 407, 412, 417, 425, 431, 436, 441, 453, 461, 472, 485, 68 495, 507, 512, 535, 550, 565, 582, 599, 611, 623, 629, 635, 69 640, 649, 662, 672, 691, 710, 715, 733, 742, 752, 761, 769, 70 777, 784, 792, 799, 806, 813, 820, 829, 837, 844, 853, 862, 71 876, 890, 901, 910, 922, 931, 939, 956, 973, 993, 1000, 1007, 72 1021, 1035, 1049, 1063, 1084, 1105, 1115, 1130, 1145, 1165, 1185, 1210, 73 1227, 1244, 1270, 1296, 1319, 1342, 1360, 1378, 1394, 1410, 1423, 1437, 74 1453, 1476, 1490, 1506, 1526, 1541, 1560, 1575, 1588, 1603, 1618, 1632, 75 1650, 1668, 1685, 1699, 1714, 1724, 1734, 1745, 1756, 1770, 1782, 1793, 76 1804, 1822, 1836, 1853, 1872, 1888, 1906, 1917, 1946, 1967, 1988, 2011, 77 2034, 2052, 2070, 2082, 2094, 2105, 2120, 2139, 2155, 2180, 2205, 2216, 78 2240, 2255, 2271, 2286, 2300, 2314, 2327, 2341, 2354, 2367, 2380, 2393, 79 2408, 2422, 2435, 2450, 2465, 2485, 2505, 2522, 2537, 2555, 2570, 2584, 80 2607, 2630, 2656, 2669, 2682, 2702, 2722, 2742, 2762, 2789, 81}; 82const int rb_vm_max_insn_name_size = 28; 83ASSERT_VM_INSTRUCTION_SIZE(rb_vm_insn_name_offset); 84 85PACKED_STRUCT(struct rb_vm_insn_name_info_tag { 86 const char L000[ 4]; const char L001[ 9]; const char L002[ 9]; 87 const char L003[14]; const char L004[14]; const char L005[19]; 88 const char L006[11]; const char L007[11]; const char L008[20]; 89 const char L009[20]; const char L010[17]; const char L011[17]; 90 const char L012[12]; const char L013[12]; const char L014[10]; 91 const char L015[10]; const char L016[ 7]; const char L017[ 8]; 92 const char L018[10]; const char L019[17]; const char L020[ 8]; 93 const char L021[10]; const char L022[14]; const char L023[ 9]; 94 const char L024[13]; const char L025[ 9]; const char L026[ 7]; 95 const char L027[ 9]; const char L028[ 9]; const char L029[ 8]; 96 const char L030[12]; const char L031[12]; const char L032[11]; 97 const char L033[ 8]; const char L034[ 9]; const char L035[ 4]; 98 const char L036[ 4]; const char L037[ 5]; const char L038[ 5]; 99 const char L039[ 8]; const char L040[ 6]; const char L041[ 5]; 100 const char L042[ 5]; const char L043[12]; const char L044[ 8]; 101 const char L045[11]; const char L046[13]; const char L047[10]; 102 const char L048[12]; const char L049[ 5]; const char L050[23]; 103 const char L051[15]; const char L052[15]; const char L053[17]; 104 const char L054[17]; const char L055[12]; const char L056[12]; 105 const char L057[ 6]; const char L058[ 6]; const char L059[ 5]; 106 const char L060[ 9]; const char L061[13]; const char L062[10]; 107 const char L063[19]; const char L064[19]; const char L065[ 5]; 108 const char L066[18]; const char L067[ 9]; const char L068[10]; 109 const char L069[ 9]; const char L070[ 8]; const char L071[ 8]; 110 const char L072[ 7]; const char L073[ 8]; const char L074[ 7]; 111 const char L075[ 7]; const char L076[ 7]; const char L077[ 7]; 112 const char L078[ 9]; const char L079[ 8]; const char L080[ 7]; 113 const char L081[ 9]; const char L082[ 9]; const char L083[14]; 114 const char L084[14]; const char L085[11]; const char L086[ 9]; 115 const char L087[12]; const char L088[ 9]; const char L089[ 8]; 116 const char L090[17]; const char L091[17]; const char L092[20]; 117 const char L093[ 7]; const char L094[ 7]; const char L095[14]; 118 const char L096[14]; const char L097[14]; const char L098[14]; 119 const char L099[21]; const char L100[21]; const char L101[10]; 120 const char L102[15]; const char L103[15]; const char L104[20]; 121 const char L105[20]; const char L106[25]; const char L107[17]; 122 const char L108[17]; const char L109[26]; const char L110[26]; 123 const char L111[23]; const char L112[23]; const char L113[18]; 124 const char L114[18]; const char L115[16]; const char L116[16]; 125 const char L117[13]; const char L118[14]; const char L119[16]; 126 const char L120[23]; const char L121[14]; const char L122[16]; 127 const char L123[20]; const char L124[15]; const char L125[19]; 128 const char L126[15]; const char L127[13]; const char L128[15]; 129 const char L129[15]; const char L130[14]; const char L131[18]; 130 const char L132[18]; const char L133[17]; const char L134[14]; 131 const char L135[15]; const char L136[10]; const char L137[10]; 132 const char L138[11]; const char L139[11]; const char L140[14]; 133 const char L141[12]; const char L142[11]; const char L143[11]; 134 const char L144[18]; const char L145[14]; const char L146[17]; 135 const char L147[19]; const char L148[16]; const char L149[18]; 136 const char L150[11]; const char L151[29]; const char L152[21]; 137 const char L153[21]; const char L154[23]; const char L155[23]; 138 const char L156[18]; const char L157[18]; const char L158[12]; 139 const char L159[12]; const char L160[11]; const char L161[15]; 140 const char L162[19]; const char L163[16]; const char L164[25]; 141 const char L165[25]; const char L166[11]; const char L167[24]; 142 const char L168[15]; const char L169[16]; const char L170[15]; 143 const char L171[14]; const char L172[14]; const char L173[13]; 144 const char L174[14]; const char L175[13]; const char L176[13]; 145 const char L177[13]; const char L178[13]; const char L179[15]; 146 const char L180[14]; const char L181[13]; const char L182[15]; 147 const char L183[15]; const char L184[20]; const char L185[20]; 148 const char L186[17]; const char L187[15]; const char L188[18]; 149 const char L189[15]; const char L190[14]; const char L191[23]; 150 const char L192[23]; const char L193[26]; const char L194[13]; 151 const char L195[13]; const char L196[20]; const char L197[20]; 152 const char L198[20]; const char L199[20]; const char L200[27]; 153 const char L201[27]; 154}); 155 156static const struct rb_vm_insn_name_info_tag rb_vm_insn_name_base = { 157 "nop" , "getlocal" , 158 "setlocal" , "getblockparam" , 159 "setblockparam" , "getblockparamproxy" , 160 "getspecial" , "setspecial" , 161 "getinstancevariable" , "setinstancevariable" , 162 "getclassvariable" , "setclassvariable" , 163 "getconstant" , "setconstant" , 164 "getglobal" , "setglobal" , 165 "putnil" , "putself" , 166 "putobject" , "putspecialobject" , 167 "putiseq" , "putstring" , 168 "concatstrings" , "tostring" , 169 "freezestring" , "toregexp" , 170 "intern" , "newarray" , 171 "duparray" , "duphash" , 172 "expandarray" , "concatarray" , 173 "splatarray" , "newhash" , 174 "newrange" , "pop" , 175 "dup" , "dupn" , 176 "swap" , "reverse" , 177 "reput" , "topn" , 178 "setn" , "adjuststack" , 179 "defined" , "checkmatch" , 180 "checkkeyword" , "checktype" , 181 "defineclass" , "send" , 182 "opt_send_without_block" , "opt_str_freeze" , 183 "opt_str_uminus" , "opt_newarray_max" , 184 "opt_newarray_min" , "invokesuper" , 185 "invokeblock" , "leave" , 186 "throw" , "jump" , 187 "branchif" , "branchunless" , 188 "branchnil" , "opt_getinlinecache" , 189 "opt_setinlinecache" , "once" , 190 "opt_case_dispatch" , "opt_plus" , 191 "opt_minus" , "opt_mult" , 192 "opt_div" , "opt_mod" , 193 "opt_eq" , "opt_neq" , 194 "opt_lt" , "opt_le" , 195 "opt_gt" , "opt_ge" , 196 "opt_ltlt" , "opt_and" , 197 "opt_or" , "opt_aref" , 198 "opt_aset" , "opt_aset_with" , 199 "opt_aref_with" , "opt_length" , 200 "opt_size" , "opt_empty_p" , 201 "opt_succ" , "opt_not" , 202 "opt_regexpmatch1" , "opt_regexpmatch2" , 203 "opt_call_c_function" , "bitblt" , 204 "answer" , "getlocal_WC_0" , 205 "getlocal_WC_1" , "setlocal_WC_0" , 206 "setlocal_WC_1" , "putobject_INT2FIX_0_" , 207 "putobject_INT2FIX_1_" , "trace_nop" , 208 "trace_getlocal" , "trace_setlocal" , 209 "trace_getblockparam" , "trace_setblockparam" , 210 "trace_getblockparamproxy" , "trace_getspecial" , 211 "trace_setspecial" , "trace_getinstancevariable" , 212 "trace_setinstancevariable" , "trace_getclassvariable" , 213 "trace_setclassvariable" , "trace_getconstant" , 214 "trace_setconstant" , "trace_getglobal" , 215 "trace_setglobal" , "trace_putnil" , 216 "trace_putself" , "trace_putobject" , 217 "trace_putspecialobject" , "trace_putiseq" , 218 "trace_putstring" , "trace_concatstrings" , 219 "trace_tostring" , "trace_freezestring" , 220 "trace_toregexp" , "trace_intern" , 221 "trace_newarray" , "trace_duparray" , 222 "trace_duphash" , "trace_expandarray" , 223 "trace_concatarray" , "trace_splatarray" , 224 "trace_newhash" , "trace_newrange" , 225 "trace_pop" , "trace_dup" , 226 "trace_dupn" , "trace_swap" , 227 "trace_reverse" , "trace_reput" , 228 "trace_topn" , "trace_setn" , 229 "trace_adjuststack" , "trace_defined" , 230 "trace_checkmatch" , "trace_checkkeyword" , 231 "trace_checktype" , "trace_defineclass" , 232 "trace_send" , "trace_opt_send_without_block", 233 "trace_opt_str_freeze" , "trace_opt_str_uminus" , 234 "trace_opt_newarray_max" , "trace_opt_newarray_min" , 235 "trace_invokesuper" , "trace_invokeblock" , 236 "trace_leave" , "trace_throw" , 237 "trace_jump" , "trace_branchif" , 238 "trace_branchunless" , "trace_branchnil" , 239 "trace_opt_getinlinecache" , "trace_opt_setinlinecache" , 240 "trace_once" , "trace_opt_case_dispatch" , 241 "trace_opt_plus" , "trace_opt_minus" , 242 "trace_opt_mult" , "trace_opt_div" , 243 "trace_opt_mod" , "trace_opt_eq" , 244 "trace_opt_neq" , "trace_opt_lt" , 245 "trace_opt_le" , "trace_opt_gt" , 246 "trace_opt_ge" , "trace_opt_ltlt" , 247 "trace_opt_and" , "trace_opt_or" , 248 "trace_opt_aref" , "trace_opt_aset" , 249 "trace_opt_aset_with" , "trace_opt_aref_with" , 250 "trace_opt_length" , "trace_opt_size" , 251 "trace_opt_empty_p" , "trace_opt_succ" , 252 "trace_opt_not" , "trace_opt_regexpmatch1" , 253 "trace_opt_regexpmatch2" , "trace_opt_call_c_function" , 254 "trace_bitblt" , "trace_answer" , 255 "trace_getlocal_WC_0" , "trace_getlocal_WC_1" , 256 "trace_setlocal_WC_0" , "trace_setlocal_WC_1" , 257 "trace_putobject_INT2FIX_0_" , "trace_putobject_INT2FIX_1_" , 258}; 259 260const char *rb_vm_insn_name_info = (const char *)&rb_vm_insn_name_base; 261#endif 262 263const char * 264insn_name(VALUE i) 265{ 266 return &rb_vm_insn_name_info[rb_vm_insn_name_offset[i]]; 267} 268 269CONSTFUNC(MAYBE_UNUSED(static int insn_len(VALUE insn))); 270extern const char rb_vm_insn_len_info[]; 271 272#ifdef RUBY_VM_INSNS_INFO 273const char rb_vm_insn_len_info[] = { 274 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, 275 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, 276 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, 277 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, 278 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, 279 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, 280 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, 281 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, 282 1, 1, 283}; 284#endif 285 286int 287insn_len(VALUE i) 288{ 289 return rb_vm_insn_len_info[i]; 290} 291 292CONSTFUNC(MAYBE_UNUSED(static const char *insn_op_types(VALUE insn))); 293CONSTFUNC(MAYBE_UNUSED(static int insn_op_type(VALUE insn, long pos))); 294extern const char *rb_vm_insn_op_info; 295extern const unsigned short rb_vm_insn_op_offset[]; 296 297#ifdef RUBY_VM_INSNS_INFO 298const unsigned short rb_vm_insn_op_offset[] = { 299 0, 1, 4, 7, 10, 13, 16, 19, 21, 24, 27, 29, 31, 33, 300 35, 37, 39, 40, 41, 43, 45, 47, 49, 51, 52, 54, 57, 58, 301 60, 62, 64, 67, 68, 70, 72, 74, 75, 76, 78, 79, 81, 82, 302 84, 86, 88, 92, 94, 97, 99, 103, 107, 110, 114, 118, 120, 122, 303 126, 128, 129, 131, 133, 135, 137, 139, 142, 144, 147, 150, 153, 156, 304 159, 162, 165, 168, 173, 176, 179, 182, 185, 188, 191, 194, 197, 200, 305 204, 208, 211, 214, 217, 220, 223, 225, 228, 230, 231, 232, 234, 236, 306 238, 240, 241, 242, 243, 246, 249, 252, 255, 258, 261, 263, 266, 269, 307 271, 273, 275, 277, 279, 281, 282, 283, 285, 287, 289, 291, 293, 294, 308 296, 299, 300, 302, 304, 306, 309, 310, 312, 314, 316, 317, 318, 320, 309 321, 323, 324, 326, 328, 330, 334, 336, 339, 341, 345, 349, 352, 356, 310 360, 362, 364, 368, 370, 371, 373, 375, 377, 379, 381, 384, 386, 389, 311 392, 395, 398, 401, 404, 407, 410, 415, 418, 421, 424, 427, 430, 433, 312 436, 439, 442, 446, 450, 453, 456, 459, 462, 465, 467, 470, 472, 473, 313 474, 476, 478, 480, 482, 483, 314}; 315ASSERT_VM_INSTRUCTION_SIZE(rb_vm_insn_op_offset); 316 317PACKED_STRUCT(struct rb_vm_insn_op_info_tag { 318 const char L000[ 1]; const char L001[ 3]; const char L002[ 3]; 319 const char L003[ 3]; const char L004[ 3]; const char L005[ 3]; 320 const char L006[ 3]; const char L007[ 2]; const char L008[ 3]; 321 const char L009[ 3]; const char L010[ 2]; const char L011[ 2]; 322 const char L012[ 2]; const char L013[ 2]; const char L014[ 2]; 323 const char L015[ 2]; const char L016[ 1]; const char L017[ 1]; 324 const char L018[ 2]; const char L019[ 2]; const char L020[ 2]; 325 const char L021[ 2]; const char L022[ 2]; const char L023[ 1]; 326 const char L024[ 2]; const char L025[ 3]; const char L026[ 1]; 327 const char L027[ 2]; const char L028[ 2]; const char L029[ 2]; 328 const char L030[ 3]; const char L031[ 1]; const char L032[ 2]; 329 const char L033[ 2]; const char L034[ 2]; const char L035[ 1]; 330 const char L036[ 1]; const char L037[ 2]; const char L038[ 1]; 331 const char L039[ 2]; const char L040[ 1]; const char L041[ 2]; 332 const char L042[ 2]; const char L043[ 2]; const char L044[ 4]; 333 const char L045[ 2]; const char L046[ 3]; const char L047[ 2]; 334 const char L048[ 4]; const char L049[ 4]; const char L050[ 3]; 335 const char L051[ 4]; const char L052[ 4]; const char L053[ 2]; 336 const char L054[ 2]; const char L055[ 4]; const char L056[ 2]; 337 const char L057[ 1]; const char L058[ 2]; const char L059[ 2]; 338 const char L060[ 2]; const char L061[ 2]; const char L062[ 2]; 339 const char L063[ 3]; const char L064[ 2]; const char L065[ 3]; 340 const char L066[ 3]; const char L067[ 3]; const char L068[ 3]; 341 const char L069[ 3]; const char L070[ 3]; const char L071[ 3]; 342 const char L072[ 3]; const char L073[ 5]; const char L074[ 3]; 343 const char L075[ 3]; const char L076[ 3]; const char L077[ 3]; 344 const char L078[ 3]; const char L079[ 3]; const char L080[ 3]; 345 const char L081[ 3]; const char L082[ 3]; const char L083[ 4]; 346 const char L084[ 4]; const char L085[ 3]; const char L086[ 3]; 347 const char L087[ 3]; const char L088[ 3]; const char L089[ 3]; 348 const char L090[ 2]; const char L091[ 3]; const char L092[ 2]; 349 const char L093[ 1]; const char L094[ 1]; const char L095[ 2]; 350 const char L096[ 2]; const char L097[ 2]; const char L098[ 2]; 351 const char L099[ 1]; const char L100[ 1]; const char L101[ 1]; 352 const char L102[ 3]; const char L103[ 3]; const char L104[ 3]; 353 const char L105[ 3]; const char L106[ 3]; const char L107[ 3]; 354 const char L108[ 2]; const char L109[ 3]; const char L110[ 3]; 355 const char L111[ 2]; const char L112[ 2]; const char L113[ 2]; 356 const char L114[ 2]; const char L115[ 2]; const char L116[ 2]; 357 const char L117[ 1]; const char L118[ 1]; const char L119[ 2]; 358 const char L120[ 2]; const char L121[ 2]; const char L122[ 2]; 359 const char L123[ 2]; const char L124[ 1]; const char L125[ 2]; 360 const char L126[ 3]; const char L127[ 1]; const char L128[ 2]; 361 const char L129[ 2]; const char L130[ 2]; const char L131[ 3]; 362 const char L132[ 1]; const char L133[ 2]; const char L134[ 2]; 363 const char L135[ 2]; const char L136[ 1]; const char L137[ 1]; 364 const char L138[ 2]; const char L139[ 1]; const char L140[ 2]; 365 const char L141[ 1]; const char L142[ 2]; const char L143[ 2]; 366 const char L144[ 2]; const char L145[ 4]; const char L146[ 2]; 367 const char L147[ 3]; const char L148[ 2]; const char L149[ 4]; 368 const char L150[ 4]; const char L151[ 3]; const char L152[ 4]; 369 const char L153[ 4]; const char L154[ 2]; const char L155[ 2]; 370 const char L156[ 4]; const char L157[ 2]; const char L158[ 1]; 371 const char L159[ 2]; const char L160[ 2]; const char L161[ 2]; 372 const char L162[ 2]; const char L163[ 2]; const char L164[ 3]; 373 const char L165[ 2]; const char L166[ 3]; const char L167[ 3]; 374 const char L168[ 3]; const char L169[ 3]; const char L170[ 3]; 375 const char L171[ 3]; const char L172[ 3]; const char L173[ 3]; 376 const char L174[ 5]; const char L175[ 3]; const char L176[ 3]; 377 const char L177[ 3]; const char L178[ 3]; const char L179[ 3]; 378 const char L180[ 3]; const char L181[ 3]; const char L182[ 3]; 379 const char L183[ 3]; const char L184[ 4]; const char L185[ 4]; 380 const char L186[ 3]; const char L187[ 3]; const char L188[ 3]; 381 const char L189[ 3]; const char L190[ 3]; const char L191[ 2]; 382 const char L192[ 3]; const char L193[ 2]; const char L194[ 1]; 383 const char L195[ 1]; const char L196[ 2]; const char L197[ 2]; 384 const char L198[ 2]; const char L199[ 2]; const char L200[ 1]; 385 const char L201[ 1]; 386}); 387 388static const struct rb_vm_insn_op_info_tag rb_vm_insn_op_base = { 389 "" , "LN" , "LN" , "LN" , "LN" , "LN" , "NN" , "N" , 390 "IK" , "IK" , "I" , "I" , "I" , "I" , "G" , "G" , 391 "" , "" , "V" , "N" , "S" , "V" , "N" , "" , 392 "V" , "NN" , "" , "N" , "V" , "V" , "NN" , "" , 393 "V" , "N" , "N" , "" , "" , "N" , "" , "N" , 394 "" , "N" , "N" , "N" , "NVV" , "N" , "LL" , "N" , 395 "ISN" , "CES" , "CE" , "VCE" , "VCE" , "N" , "N" , "CES" , 396 "C" , "" , "N" , "O" , "O" , "O" , "O" , "OK" , 397 "K" , "ST" , "HO" , "CE" , "CE" , "CE" , "CE" , "CE" , 398 "CE" , "CECE", "CE" , "CE" , "CE" , "CE" , "CE" , "CE" , 399 "CE" , "CE" , "CE" , "VCE" , "VCE" , "CE" , "CE" , "CE" , 400 "CE" , "CE" , "V" , "CE" , "F" , "" , "" , "L" , 401 "L" , "L" , "L" , "" , "" , "" , "LN" , "LN" , 402 "LN" , "LN" , "LN" , "NN" , "N" , "IK" , "IK" , "I" , 403 "I" , "I" , "I" , "G" , "G" , "" , "" , "V" , 404 "N" , "S" , "V" , "N" , "" , "V" , "NN" , "" , 405 "N" , "V" , "V" , "NN" , "" , "V" , "N" , "N" , 406 "" , "" , "N" , "" , "N" , "" , "N" , "N" , 407 "N" , "NVV" , "N" , "LL" , "N" , "ISN" , "CES" , "CE" , 408 "VCE" , "VCE" , "N" , "N" , "CES" , "C" , "" , "N" , 409 "O" , "O" , "O" , "O" , "OK" , "K" , "ST" , "HO" , 410 "CE" , "CE" , "CE" , "CE" , "CE" , "CE" , "CECE", "CE" , 411 "CE" , "CE" , "CE" , "CE" , "CE" , "CE" , "CE" , "CE" , 412 "VCE" , "VCE" , "CE" , "CE" , "CE" , "CE" , "CE" , "V" , 413 "CE" , "F" , "" , "" , "L" , "L" , "L" , "L" , 414 "" , "" , 415}; 416 417const char *rb_vm_insn_op_info = (const char *)&rb_vm_insn_op_base; 418#endif 419 420const char * 421insn_op_types(VALUE i) 422{ 423 return &rb_vm_insn_op_info[rb_vm_insn_op_offset[i]]; 424} 425 426int 427insn_op_type(VALUE i, long j) 428{ 429 if (j >= insn_len(i)) { 430 return 0; 431 } 432 else { 433 return insn_op_types(i)[j]; 434 } 435} 436 437 438static bool 439leafness_of_getglobal(VALUE gentry) 440{ 441 const struct rb_global_entry *e = (void *)gentry; 442 443 if (UNLIKELY(rb_gvar_is_traced(e))) { 444 return false; 445 } 446 else { 447 /* We cannot write this function using a switch() because a 448 * case label cannot be a function pointer. */ 449 static rb_gvar_getter_t *const allowlist[] = { 450 rb_gvar_val_getter, 451 rb_gvar_var_getter, 452 rb_gvar_undef_getter, 453 }; 454 rb_gvar_getter_t *f = rb_gvar_getter_function_of(e); 455 int i; 456 457 for (i = 0; i < numberof(allowlist); i++) { 458 if (f == allowlist[i]) { 459 return true; 460 } 461 } 462 return false; 463 } 464} 465 466static bool 467leafness_of_setglobal(VALUE gentry) 468{ 469 const struct rb_global_entry *e = (void *)gentry; 470 471 if (UNLIKELY(rb_gvar_is_traced(e))) { 472 return false; 473 } 474 else { 475 /* We cannot write this function using a switch() because a 476 * case label cannot be a function pointer. */ 477 static rb_gvar_setter_t *const allowlist[] = { 478 rb_gvar_val_setter, 479 rb_gvar_readonly_setter, 480 rb_gvar_var_setter, 481 rb_gvar_undef_setter, 482 }; 483 rb_gvar_setter_t *f = rb_gvar_setter_function_of(e); 484 int i; 485 486 for (i = 0; i < numberof(allowlist); i++) { 487 if (f == allowlist[i]) { 488 return true; 489 } 490 } 491 return false; 492 } 493} 494 495#include "iseq.h" 496 497static bool 498leafness_of_defined(rb_num_t op_type) 499{ 500 /* see also: vm_insnhelper.c:vm_defined() */ 501 switch (op_type) { 502 case DEFINED_IVAR: 503 case DEFINED_IVAR2: 504 case DEFINED_GVAR: 505 case DEFINED_CVAR: 506 case DEFINED_YIELD: 507 case DEFINED_REF: 508 case DEFINED_ZSUPER: 509 return false; 510 case DEFINED_CONST: 511 /* has rb_autoload_load(); */ 512 return false; 513 case DEFINED_FUNC: 514 case DEFINED_METHOD: 515 /* calls #respond_to_missing? */ 516 return false; 517 default: 518 rb_bug("unknown operand %ld: blame @shyouhei.", op_type); 519 } 520} 521 522static bool 523leafness_of_checkmatch(rb_num_t flag) 524{ 525 /* see also: vm_insnhelper.c:check_match() */ 526 if (flag == VM_CHECKMATCH_TYPE_WHEN) { 527 return true; 528 } 529 else { 530 /* has rb_funcallv() */ 531 return false; 532 } 533} 534 535#ifndef RUBY_VM_EXEC_H 536/* can't #include "vm_exec.h" here... */ 537typedef long OFFSET; 538typedef unsigned long lindex_t; 539typedef VALUE GENTRY; 540typedef rb_iseq_t *ISEQ; 541#endif 542 543PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_nop(void))); 544PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_nop(void))); 545PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_nop(void))); 546PUREFUNC(MAYBE_UNUSED(static const char* attr_name_nop(void))); 547PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_nop(void))); 548PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_nop(void))); 549PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_nop(void))); 550PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_nop(void))); 551PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_nop(void))); 552PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_getlocal(lindex_t idx, rb_num_t level))); 553PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_getlocal(lindex_t idx, rb_num_t level))); 554PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_getlocal(lindex_t idx, rb_num_t level))); 555PUREFUNC(MAYBE_UNUSED(static const char* attr_name_getlocal(lindex_t idx, rb_num_t level))); 556PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_getlocal(lindex_t idx, rb_num_t level))); 557PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_getlocal(lindex_t idx, rb_num_t level))); 558PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_getlocal(lindex_t idx, rb_num_t level))); 559PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_getlocal(lindex_t idx, rb_num_t level))); 560PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_getlocal(lindex_t idx, rb_num_t level))); 561PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_setlocal(lindex_t idx, rb_num_t level))); 562PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_setlocal(lindex_t idx, rb_num_t level))); 563PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_setlocal(lindex_t idx, rb_num_t level))); 564PUREFUNC(MAYBE_UNUSED(static const char* attr_name_setlocal(lindex_t idx, rb_num_t level))); 565PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_setlocal(lindex_t idx, rb_num_t level))); 566PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_setlocal(lindex_t idx, rb_num_t level))); 567PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_setlocal(lindex_t idx, rb_num_t level))); 568PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_setlocal(lindex_t idx, rb_num_t level))); 569PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_setlocal(lindex_t idx, rb_num_t level))); 570PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_getblockparam(lindex_t idx, rb_num_t level))); 571PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_getblockparam(lindex_t idx, rb_num_t level))); 572PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_getblockparam(lindex_t idx, rb_num_t level))); 573PUREFUNC(MAYBE_UNUSED(static const char* attr_name_getblockparam(lindex_t idx, rb_num_t level))); 574PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_getblockparam(lindex_t idx, rb_num_t level))); 575PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_getblockparam(lindex_t idx, rb_num_t level))); 576PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_getblockparam(lindex_t idx, rb_num_t level))); 577PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_getblockparam(lindex_t idx, rb_num_t level))); 578PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_getblockparam(lindex_t idx, rb_num_t level))); 579PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_setblockparam(lindex_t idx, rb_num_t level))); 580PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_setblockparam(lindex_t idx, rb_num_t level))); 581PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_setblockparam(lindex_t idx, rb_num_t level))); 582PUREFUNC(MAYBE_UNUSED(static const char* attr_name_setblockparam(lindex_t idx, rb_num_t level))); 583PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_setblockparam(lindex_t idx, rb_num_t level))); 584PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_setblockparam(lindex_t idx, rb_num_t level))); 585PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_setblockparam(lindex_t idx, rb_num_t level))); 586PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_setblockparam(lindex_t idx, rb_num_t level))); 587PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_setblockparam(lindex_t idx, rb_num_t level))); 588PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_getblockparamproxy(lindex_t idx, rb_num_t level))); 589PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_getblockparamproxy(lindex_t idx, rb_num_t level))); 590PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_getblockparamproxy(lindex_t idx, rb_num_t level))); 591PUREFUNC(MAYBE_UNUSED(static const char* attr_name_getblockparamproxy(lindex_t idx, rb_num_t level))); 592PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_getblockparamproxy(lindex_t idx, rb_num_t level))); 593PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_getblockparamproxy(lindex_t idx, rb_num_t level))); 594PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_getblockparamproxy(lindex_t idx, rb_num_t level))); 595PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_getblockparamproxy(lindex_t idx, rb_num_t level))); 596PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_getblockparamproxy(lindex_t idx, rb_num_t level))); 597PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_getspecial(rb_num_t key, rb_num_t type))); 598PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_getspecial(rb_num_t key, rb_num_t type))); 599PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_getspecial(rb_num_t key, rb_num_t type))); 600PUREFUNC(MAYBE_UNUSED(static const char* attr_name_getspecial(rb_num_t key, rb_num_t type))); 601PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_getspecial(rb_num_t key, rb_num_t type))); 602PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_getspecial(rb_num_t key, rb_num_t type))); 603PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_getspecial(rb_num_t key, rb_num_t type))); 604PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_getspecial(rb_num_t key, rb_num_t type))); 605PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_getspecial(rb_num_t key, rb_num_t type))); 606PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_setspecial(rb_num_t key))); 607PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_setspecial(rb_num_t key))); 608PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_setspecial(rb_num_t key))); 609PUREFUNC(MAYBE_UNUSED(static const char* attr_name_setspecial(rb_num_t key))); 610PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_setspecial(rb_num_t key))); 611PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_setspecial(rb_num_t key))); 612PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_setspecial(rb_num_t key))); 613PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_setspecial(rb_num_t key))); 614PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_setspecial(rb_num_t key))); 615PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_getinstancevariable(ID id, IC ic))); 616PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_getinstancevariable(ID id, IC ic))); 617PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_getinstancevariable(ID id, IC ic))); 618PUREFUNC(MAYBE_UNUSED(static const char* attr_name_getinstancevariable(ID id, IC ic))); 619PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_getinstancevariable(ID id, IC ic))); 620PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_getinstancevariable(ID id, IC ic))); 621PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_getinstancevariable(ID id, IC ic))); 622PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_getinstancevariable(ID id, IC ic))); 623PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_getinstancevariable(ID id, IC ic))); 624PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_setinstancevariable(ID id, IC ic))); 625PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_setinstancevariable(ID id, IC ic))); 626PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_setinstancevariable(ID id, IC ic))); 627PUREFUNC(MAYBE_UNUSED(static const char* attr_name_setinstancevariable(ID id, IC ic))); 628PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_setinstancevariable(ID id, IC ic))); 629PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_setinstancevariable(ID id, IC ic))); 630PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_setinstancevariable(ID id, IC ic))); 631PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_setinstancevariable(ID id, IC ic))); 632PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_setinstancevariable(ID id, IC ic))); 633PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_getclassvariable(ID id))); 634PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_getclassvariable(ID id))); 635PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_getclassvariable(ID id))); 636PUREFUNC(MAYBE_UNUSED(static const char* attr_name_getclassvariable(ID id))); 637PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_getclassvariable(ID id))); 638PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_getclassvariable(ID id))); 639PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_getclassvariable(ID id))); 640PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_getclassvariable(ID id))); 641PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_getclassvariable(ID id))); 642PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_setclassvariable(ID id))); 643PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_setclassvariable(ID id))); 644PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_setclassvariable(ID id))); 645PUREFUNC(MAYBE_UNUSED(static const char* attr_name_setclassvariable(ID id))); 646PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_setclassvariable(ID id))); 647PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_setclassvariable(ID id))); 648PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_setclassvariable(ID id))); 649PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_setclassvariable(ID id))); 650PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_setclassvariable(ID id))); 651PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_getconstant(ID id))); 652PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_getconstant(ID id))); 653PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_getconstant(ID id))); 654PUREFUNC(MAYBE_UNUSED(static const char* attr_name_getconstant(ID id))); 655PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_getconstant(ID id))); 656PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_getconstant(ID id))); 657PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_getconstant(ID id))); 658PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_getconstant(ID id))); 659PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_getconstant(ID id))); 660PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_setconstant(ID id))); 661PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_setconstant(ID id))); 662PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_setconstant(ID id))); 663PUREFUNC(MAYBE_UNUSED(static const char* attr_name_setconstant(ID id))); 664PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_setconstant(ID id))); 665PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_setconstant(ID id))); 666PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_setconstant(ID id))); 667PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_setconstant(ID id))); 668PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_setconstant(ID id))); 669PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_getglobal(GENTRY entry))); 670PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_getglobal(GENTRY entry))); 671PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_getglobal(GENTRY entry))); 672PUREFUNC(MAYBE_UNUSED(static const char* attr_name_getglobal(GENTRY entry))); 673PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_getglobal(GENTRY entry))); 674PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_getglobal(GENTRY entry))); 675PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_getglobal(GENTRY entry))); 676PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_getglobal(GENTRY entry))); 677PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_getglobal(GENTRY entry))); 678PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_setglobal(GENTRY entry))); 679PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_setglobal(GENTRY entry))); 680PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_setglobal(GENTRY entry))); 681PUREFUNC(MAYBE_UNUSED(static const char* attr_name_setglobal(GENTRY entry))); 682PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_setglobal(GENTRY entry))); 683PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_setglobal(GENTRY entry))); 684PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_setglobal(GENTRY entry))); 685PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_setglobal(GENTRY entry))); 686PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_setglobal(GENTRY entry))); 687PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_putnil(void))); 688PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_putnil(void))); 689PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_putnil(void))); 690PUREFUNC(MAYBE_UNUSED(static const char* attr_name_putnil(void))); 691PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_putnil(void))); 692PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_putnil(void))); 693PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_putnil(void))); 694PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_putnil(void))); 695PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_putnil(void))); 696PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_putself(void))); 697PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_putself(void))); 698PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_putself(void))); 699PUREFUNC(MAYBE_UNUSED(static const char* attr_name_putself(void))); 700PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_putself(void))); 701PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_putself(void))); 702PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_putself(void))); 703PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_putself(void))); 704PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_putself(void))); 705PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_putobject(VALUE val))); 706PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_putobject(VALUE val))); 707PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_putobject(VALUE val))); 708PUREFUNC(MAYBE_UNUSED(static const char* attr_name_putobject(VALUE val))); 709PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_putobject(VALUE val))); 710PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_putobject(VALUE val))); 711PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_putobject(VALUE val))); 712PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_putobject(VALUE val))); 713PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_putobject(VALUE val))); 714PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_putspecialobject(rb_num_t value_type))); 715PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_putspecialobject(rb_num_t value_type))); 716PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_putspecialobject(rb_num_t value_type))); 717PUREFUNC(MAYBE_UNUSED(static const char* attr_name_putspecialobject(rb_num_t value_type))); 718PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_putspecialobject(rb_num_t value_type))); 719PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_putspecialobject(rb_num_t value_type))); 720PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_putspecialobject(rb_num_t value_type))); 721PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_putspecialobject(rb_num_t value_type))); 722PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_putspecialobject(rb_num_t value_type))); 723PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_putiseq(ISEQ iseq))); 724PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_putiseq(ISEQ iseq))); 725PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_putiseq(ISEQ iseq))); 726PUREFUNC(MAYBE_UNUSED(static const char* attr_name_putiseq(ISEQ iseq))); 727PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_putiseq(ISEQ iseq))); 728PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_putiseq(ISEQ iseq))); 729PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_putiseq(ISEQ iseq))); 730PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_putiseq(ISEQ iseq))); 731PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_putiseq(ISEQ iseq))); 732PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_putstring(VALUE str))); 733PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_putstring(VALUE str))); 734PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_putstring(VALUE str))); 735PUREFUNC(MAYBE_UNUSED(static const char* attr_name_putstring(VALUE str))); 736PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_putstring(VALUE str))); 737PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_putstring(VALUE str))); 738PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_putstring(VALUE str))); 739PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_putstring(VALUE str))); 740PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_putstring(VALUE str))); 741PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_concatstrings(rb_num_t num))); 742PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_concatstrings(rb_num_t num))); 743PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_concatstrings(rb_num_t num))); 744PUREFUNC(MAYBE_UNUSED(static const char* attr_name_concatstrings(rb_num_t num))); 745PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_concatstrings(rb_num_t num))); 746PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_concatstrings(rb_num_t num))); 747PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_concatstrings(rb_num_t num))); 748PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_concatstrings(rb_num_t num))); 749PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_concatstrings(rb_num_t num))); 750PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_tostring(void))); 751PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_tostring(void))); 752PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_tostring(void))); 753PUREFUNC(MAYBE_UNUSED(static const char* attr_name_tostring(void))); 754PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_tostring(void))); 755PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_tostring(void))); 756PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_tostring(void))); 757PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_tostring(void))); 758PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_tostring(void))); 759PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_freezestring(VALUE debug_info))); 760PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_freezestring(VALUE debug_info))); 761PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_freezestring(VALUE debug_info))); 762PUREFUNC(MAYBE_UNUSED(static const char* attr_name_freezestring(VALUE debug_info))); 763PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_freezestring(VALUE debug_info))); 764PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_freezestring(VALUE debug_info))); 765PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_freezestring(VALUE debug_info))); 766PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_freezestring(VALUE debug_info))); 767PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_freezestring(VALUE debug_info))); 768PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_toregexp(rb_num_t opt, rb_num_t cnt))); 769PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_toregexp(rb_num_t opt, rb_num_t cnt))); 770PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_toregexp(rb_num_t opt, rb_num_t cnt))); 771PUREFUNC(MAYBE_UNUSED(static const char* attr_name_toregexp(rb_num_t opt, rb_num_t cnt))); 772PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_toregexp(rb_num_t opt, rb_num_t cnt))); 773PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_toregexp(rb_num_t opt, rb_num_t cnt))); 774PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_toregexp(rb_num_t opt, rb_num_t cnt))); 775PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_toregexp(rb_num_t opt, rb_num_t cnt))); 776PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_toregexp(rb_num_t opt, rb_num_t cnt))); 777PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_intern(void))); 778PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_intern(void))); 779PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_intern(void))); 780PUREFUNC(MAYBE_UNUSED(static const char* attr_name_intern(void))); 781PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_intern(void))); 782PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_intern(void))); 783PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_intern(void))); 784PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_intern(void))); 785PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_intern(void))); 786PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_newarray(rb_num_t num))); 787PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_newarray(rb_num_t num))); 788PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_newarray(rb_num_t num))); 789PUREFUNC(MAYBE_UNUSED(static const char* attr_name_newarray(rb_num_t num))); 790PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_newarray(rb_num_t num))); 791PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_newarray(rb_num_t num))); 792PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_newarray(rb_num_t num))); 793PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_newarray(rb_num_t num))); 794PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_newarray(rb_num_t num))); 795PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_duparray(VALUE ary))); 796PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_duparray(VALUE ary))); 797PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_duparray(VALUE ary))); 798PUREFUNC(MAYBE_UNUSED(static const char* attr_name_duparray(VALUE ary))); 799PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_duparray(VALUE ary))); 800PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_duparray(VALUE ary))); 801PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_duparray(VALUE ary))); 802PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_duparray(VALUE ary))); 803PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_duparray(VALUE ary))); 804PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_duphash(VALUE hash))); 805PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_duphash(VALUE hash))); 806PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_duphash(VALUE hash))); 807PUREFUNC(MAYBE_UNUSED(static const char* attr_name_duphash(VALUE hash))); 808PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_duphash(VALUE hash))); 809PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_duphash(VALUE hash))); 810PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_duphash(VALUE hash))); 811PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_duphash(VALUE hash))); 812PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_duphash(VALUE hash))); 813PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_expandarray(rb_num_t num, rb_num_t flag))); 814PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_expandarray(rb_num_t num, rb_num_t flag))); 815PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_expandarray(rb_num_t num, rb_num_t flag))); 816PUREFUNC(MAYBE_UNUSED(static const char* attr_name_expandarray(rb_num_t num, rb_num_t flag))); 817PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_expandarray(rb_num_t num, rb_num_t flag))); 818PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_expandarray(rb_num_t num, rb_num_t flag))); 819PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_expandarray(rb_num_t num, rb_num_t flag))); 820PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_expandarray(rb_num_t num, rb_num_t flag))); 821PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_expandarray(rb_num_t num, rb_num_t flag))); 822PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_concatarray(void))); 823PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_concatarray(void))); 824PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_concatarray(void))); 825PUREFUNC(MAYBE_UNUSED(static const char* attr_name_concatarray(void))); 826PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_concatarray(void))); 827PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_concatarray(void))); 828PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_concatarray(void))); 829PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_concatarray(void))); 830PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_concatarray(void))); 831PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_splatarray(VALUE flag))); 832PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_splatarray(VALUE flag))); 833PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_splatarray(VALUE flag))); 834PUREFUNC(MAYBE_UNUSED(static const char* attr_name_splatarray(VALUE flag))); 835PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_splatarray(VALUE flag))); 836PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_splatarray(VALUE flag))); 837PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_splatarray(VALUE flag))); 838PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_splatarray(VALUE flag))); 839PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_splatarray(VALUE flag))); 840PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_newhash(rb_num_t num))); 841PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_newhash(rb_num_t num))); 842PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_newhash(rb_num_t num))); 843PUREFUNC(MAYBE_UNUSED(static const char* attr_name_newhash(rb_num_t num))); 844PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_newhash(rb_num_t num))); 845PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_newhash(rb_num_t num))); 846PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_newhash(rb_num_t num))); 847PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_newhash(rb_num_t num))); 848PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_newhash(rb_num_t num))); 849PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_newrange(rb_num_t flag))); 850PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_newrange(rb_num_t flag))); 851PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_newrange(rb_num_t flag))); 852PUREFUNC(MAYBE_UNUSED(static const char* attr_name_newrange(rb_num_t flag))); 853PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_newrange(rb_num_t flag))); 854PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_newrange(rb_num_t flag))); 855PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_newrange(rb_num_t flag))); 856PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_newrange(rb_num_t flag))); 857PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_newrange(rb_num_t flag))); 858PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_pop(void))); 859PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_pop(void))); 860PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_pop(void))); 861PUREFUNC(MAYBE_UNUSED(static const char* attr_name_pop(void))); 862PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_pop(void))); 863PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_pop(void))); 864PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_pop(void))); 865PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_pop(void))); 866PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_pop(void))); 867PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_dup(void))); 868PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_dup(void))); 869PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_dup(void))); 870PUREFUNC(MAYBE_UNUSED(static const char* attr_name_dup(void))); 871PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_dup(void))); 872PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_dup(void))); 873PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_dup(void))); 874PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_dup(void))); 875PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_dup(void))); 876PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_dupn(rb_num_t n))); 877PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_dupn(rb_num_t n))); 878PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_dupn(rb_num_t n))); 879PUREFUNC(MAYBE_UNUSED(static const char* attr_name_dupn(rb_num_t n))); 880PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_dupn(rb_num_t n))); 881PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_dupn(rb_num_t n))); 882PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_dupn(rb_num_t n))); 883PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_dupn(rb_num_t n))); 884PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_dupn(rb_num_t n))); 885PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_swap(void))); 886PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_swap(void))); 887PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_swap(void))); 888PUREFUNC(MAYBE_UNUSED(static const char* attr_name_swap(void))); 889PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_swap(void))); 890PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_swap(void))); 891PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_swap(void))); 892PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_swap(void))); 893PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_swap(void))); 894PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_reverse(rb_num_t n))); 895PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_reverse(rb_num_t n))); 896PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_reverse(rb_num_t n))); 897PUREFUNC(MAYBE_UNUSED(static const char* attr_name_reverse(rb_num_t n))); 898PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_reverse(rb_num_t n))); 899PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_reverse(rb_num_t n))); 900PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_reverse(rb_num_t n))); 901PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_reverse(rb_num_t n))); 902PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_reverse(rb_num_t n))); 903PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_reput(void))); 904PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_reput(void))); 905PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_reput(void))); 906PUREFUNC(MAYBE_UNUSED(static const char* attr_name_reput(void))); 907PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_reput(void))); 908PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_reput(void))); 909PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_reput(void))); 910PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_reput(void))); 911PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_reput(void))); 912PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_topn(rb_num_t n))); 913PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_topn(rb_num_t n))); 914PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_topn(rb_num_t n))); 915PUREFUNC(MAYBE_UNUSED(static const char* attr_name_topn(rb_num_t n))); 916PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_topn(rb_num_t n))); 917PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_topn(rb_num_t n))); 918PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_topn(rb_num_t n))); 919PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_topn(rb_num_t n))); 920PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_topn(rb_num_t n))); 921PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_setn(rb_num_t n))); 922PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_setn(rb_num_t n))); 923PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_setn(rb_num_t n))); 924PUREFUNC(MAYBE_UNUSED(static const char* attr_name_setn(rb_num_t n))); 925PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_setn(rb_num_t n))); 926PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_setn(rb_num_t n))); 927PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_setn(rb_num_t n))); 928PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_setn(rb_num_t n))); 929PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_setn(rb_num_t n))); 930PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_adjuststack(rb_num_t n))); 931PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_adjuststack(rb_num_t n))); 932PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_adjuststack(rb_num_t n))); 933PUREFUNC(MAYBE_UNUSED(static const char* attr_name_adjuststack(rb_num_t n))); 934PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_adjuststack(rb_num_t n))); 935PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_adjuststack(rb_num_t n))); 936PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_adjuststack(rb_num_t n))); 937PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_adjuststack(rb_num_t n))); 938PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_adjuststack(rb_num_t n))); 939PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_defined(rb_num_t op_type, VALUE obj, VALUE needstr))); 940PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_defined(rb_num_t op_type, VALUE obj, VALUE needstr))); 941PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_defined(rb_num_t op_type, VALUE obj, VALUE needstr))); 942PUREFUNC(MAYBE_UNUSED(static const char* attr_name_defined(rb_num_t op_type, VALUE obj, VALUE needstr))); 943PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_defined(rb_num_t op_type, VALUE obj, VALUE needstr))); 944PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_defined(rb_num_t op_type, VALUE obj, VALUE needstr))); 945PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_defined(rb_num_t op_type, VALUE obj, VALUE needstr))); 946PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_defined(rb_num_t op_type, VALUE obj, VALUE needstr))); 947PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_defined(rb_num_t op_type, VALUE obj, VALUE needstr))); 948PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_checkmatch(rb_num_t flag))); 949PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_checkmatch(rb_num_t flag))); 950PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_checkmatch(rb_num_t flag))); 951PUREFUNC(MAYBE_UNUSED(static const char* attr_name_checkmatch(rb_num_t flag))); 952PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_checkmatch(rb_num_t flag))); 953PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_checkmatch(rb_num_t flag))); 954PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_checkmatch(rb_num_t flag))); 955PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_checkmatch(rb_num_t flag))); 956PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_checkmatch(rb_num_t flag))); 957PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_checkkeyword(lindex_t kw_bits_index, lindex_t keyword_index))); 958PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_checkkeyword(lindex_t kw_bits_index, lindex_t keyword_index))); 959PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_checkkeyword(lindex_t kw_bits_index, lindex_t keyword_index))); 960PUREFUNC(MAYBE_UNUSED(static const char* attr_name_checkkeyword(lindex_t kw_bits_index, lindex_t keyword_index))); 961PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_checkkeyword(lindex_t kw_bits_index, lindex_t keyword_index))); 962PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_checkkeyword(lindex_t kw_bits_index, lindex_t keyword_index))); 963PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_checkkeyword(lindex_t kw_bits_index, lindex_t keyword_index))); 964PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_checkkeyword(lindex_t kw_bits_index, lindex_t keyword_index))); 965PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_checkkeyword(lindex_t kw_bits_index, lindex_t keyword_index))); 966PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_checktype(rb_num_t type))); 967PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_checktype(rb_num_t type))); 968PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_checktype(rb_num_t type))); 969PUREFUNC(MAYBE_UNUSED(static const char* attr_name_checktype(rb_num_t type))); 970PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_checktype(rb_num_t type))); 971PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_checktype(rb_num_t type))); 972PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_checktype(rb_num_t type))); 973PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_checktype(rb_num_t type))); 974PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_checktype(rb_num_t type))); 975PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_defineclass(ID id, ISEQ class_iseq, rb_num_t flags))); 976PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_defineclass(ID id, ISEQ class_iseq, rb_num_t flags))); 977PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_defineclass(ID id, ISEQ class_iseq, rb_num_t flags))); 978PUREFUNC(MAYBE_UNUSED(static const char* attr_name_defineclass(ID id, ISEQ class_iseq, rb_num_t flags))); 979PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_defineclass(ID id, ISEQ class_iseq, rb_num_t flags))); 980PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_defineclass(ID id, ISEQ class_iseq, rb_num_t flags))); 981PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_defineclass(ID id, ISEQ class_iseq, rb_num_t flags))); 982PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_defineclass(ID id, ISEQ class_iseq, rb_num_t flags))); 983PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_defineclass(ID id, ISEQ class_iseq, rb_num_t flags))); 984PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_send(CALL_INFO ci, CALL_CACHE cc, ISEQ blockiseq))); 985PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_send(CALL_INFO ci, CALL_CACHE cc, ISEQ blockiseq))); 986PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_send(CALL_INFO ci, CALL_CACHE cc, ISEQ blockiseq))); 987PUREFUNC(MAYBE_UNUSED(static const char* attr_name_send(CALL_INFO ci, CALL_CACHE cc, ISEQ blockiseq))); 988PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_send(CALL_INFO ci, CALL_CACHE cc, ISEQ blockiseq))); 989PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_send(CALL_INFO ci, CALL_CACHE cc, ISEQ blockiseq))); 990PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_send(CALL_INFO ci, CALL_CACHE cc, ISEQ blockiseq))); 991PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_send(CALL_INFO ci, CALL_CACHE cc, ISEQ blockiseq))); 992PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_send(CALL_INFO ci, CALL_CACHE cc, ISEQ blockiseq))); 993PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_opt_send_without_block(CALL_INFO ci, CALL_CACHE cc))); 994PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_opt_send_without_block(CALL_INFO ci, CALL_CACHE cc))); 995PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_opt_send_without_block(CALL_INFO ci, CALL_CACHE cc))); 996PUREFUNC(MAYBE_UNUSED(static const char* attr_name_opt_send_without_block(CALL_INFO ci, CALL_CACHE cc))); 997PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_opt_send_without_block(CALL_INFO ci, CALL_CACHE cc))); 998PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_opt_send_without_block(CALL_INFO ci, CALL_CACHE cc))); 999PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_opt_send_without_block(CALL_INFO ci, CALL_CACHE cc))); 1000PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_opt_send_without_block(CALL_INFO ci, CALL_CACHE cc))); 1001PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_opt_send_without_block(CALL_INFO ci, CALL_CACHE cc))); 1002PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_opt_str_freeze(VALUE str, CALL_INFO ci, CALL_CACHE cc))); 1003PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_opt_str_freeze(VALUE str, CALL_INFO ci, CALL_CACHE cc))); 1004PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_opt_str_freeze(VALUE str, CALL_INFO ci, CALL_CACHE cc))); 1005PUREFUNC(MAYBE_UNUSED(static const char* attr_name_opt_str_freeze(VALUE str, CALL_INFO ci, CALL_CACHE cc))); 1006PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_opt_str_freeze(VALUE str, CALL_INFO ci, CALL_CACHE cc))); 1007PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_opt_str_freeze(VALUE str, CALL_INFO ci, CALL_CACHE cc))); 1008PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_opt_str_freeze(VALUE str, CALL_INFO ci, CALL_CACHE cc))); 1009PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_opt_str_freeze(VALUE str, CALL_INFO ci, CALL_CACHE cc))); 1010PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_opt_str_freeze(VALUE str, CALL_INFO ci, CALL_CACHE cc))); 1011PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_opt_str_uminus(VALUE str, CALL_INFO ci, CALL_CACHE cc))); 1012PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_opt_str_uminus(VALUE str, CALL_INFO ci, CALL_CACHE cc))); 1013PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_opt_str_uminus(VALUE str, CALL_INFO ci, CALL_CACHE cc))); 1014PUREFUNC(MAYBE_UNUSED(static const char* attr_name_opt_str_uminus(VALUE str, CALL_INFO ci, CALL_CACHE cc))); 1015PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_opt_str_uminus(VALUE str, CALL_INFO ci, CALL_CACHE cc))); 1016PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_opt_str_uminus(VALUE str, CALL_INFO ci, CALL_CACHE cc))); 1017PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_opt_str_uminus(VALUE str, CALL_INFO ci, CALL_CACHE cc))); 1018PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_opt_str_uminus(VALUE str, CALL_INFO ci, CALL_CACHE cc))); 1019PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_opt_str_uminus(VALUE str, CALL_INFO ci, CALL_CACHE cc))); 1020PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_opt_newarray_max(rb_num_t num))); 1021PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_opt_newarray_max(rb_num_t num))); 1022PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_opt_newarray_max(rb_num_t num))); 1023PUREFUNC(MAYBE_UNUSED(static const char* attr_name_opt_newarray_max(rb_num_t num))); 1024PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_opt_newarray_max(rb_num_t num))); 1025PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_opt_newarray_max(rb_num_t num))); 1026PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_opt_newarray_max(rb_num_t num))); 1027PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_opt_newarray_max(rb_num_t num))); 1028PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_opt_newarray_max(rb_num_t num))); 1029PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_opt_newarray_min(rb_num_t num))); 1030PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_opt_newarray_min(rb_num_t num))); 1031PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_opt_newarray_min(rb_num_t num))); 1032PUREFUNC(MAYBE_UNUSED(static const char* attr_name_opt_newarray_min(rb_num_t num))); 1033PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_opt_newarray_min(rb_num_t num))); 1034PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_opt_newarray_min(rb_num_t num))); 1035PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_opt_newarray_min(rb_num_t num))); 1036PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_opt_newarray_min(rb_num_t num))); 1037PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_opt_newarray_min(rb_num_t num))); 1038PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_invokesuper(CALL_INFO ci, CALL_CACHE cc, ISEQ blockiseq))); 1039PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_invokesuper(CALL_INFO ci, CALL_CACHE cc, ISEQ blockiseq))); 1040PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_invokesuper(CALL_INFO ci, CALL_CACHE cc, ISEQ blockiseq))); 1041PUREFUNC(MAYBE_UNUSED(static const char* attr_name_invokesuper(CALL_INFO ci, CALL_CACHE cc, ISEQ blockiseq))); 1042PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_invokesuper(CALL_INFO ci, CALL_CACHE cc, ISEQ blockiseq))); 1043PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_invokesuper(CALL_INFO ci, CALL_CACHE cc, ISEQ blockiseq))); 1044PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_invokesuper(CALL_INFO ci, CALL_CACHE cc, ISEQ blockiseq))); 1045PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_invokesuper(CALL_INFO ci, CALL_CACHE cc, ISEQ blockiseq))); 1046PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_invokesuper(CALL_INFO ci, CALL_CACHE cc, ISEQ blockiseq))); 1047PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_invokeblock(CALL_INFO ci))); 1048PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_invokeblock(CALL_INFO ci))); 1049PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_invokeblock(CALL_INFO ci))); 1050PUREFUNC(MAYBE_UNUSED(static const char* attr_name_invokeblock(CALL_INFO ci))); 1051PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_invokeblock(CALL_INFO ci))); 1052PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_invokeblock(CALL_INFO ci))); 1053PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_invokeblock(CALL_INFO ci))); 1054PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_invokeblock(CALL_INFO ci))); 1055PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_invokeblock(CALL_INFO ci))); 1056PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_leave(void))); 1057PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_leave(void))); 1058PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_leave(void))); 1059PUREFUNC(MAYBE_UNUSED(static const char* attr_name_leave(void))); 1060PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_leave(void))); 1061PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_leave(void))); 1062PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_leave(void))); 1063PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_leave(void))); 1064PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_leave(void))); 1065PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_throw(rb_num_t throw_state))); 1066PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_throw(rb_num_t throw_state))); 1067PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_throw(rb_num_t throw_state))); 1068PUREFUNC(MAYBE_UNUSED(static const char* attr_name_throw(rb_num_t throw_state))); 1069PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_throw(rb_num_t throw_state))); 1070PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_throw(rb_num_t throw_state))); 1071PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_throw(rb_num_t throw_state))); 1072PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_throw(rb_num_t throw_state))); 1073PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_throw(rb_num_t throw_state))); 1074PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_jump(OFFSET dst))); 1075PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_jump(OFFSET dst))); 1076PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_jump(OFFSET dst))); 1077PUREFUNC(MAYBE_UNUSED(static const char* attr_name_jump(OFFSET dst))); 1078PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_jump(OFFSET dst))); 1079PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_jump(OFFSET dst))); 1080PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_jump(OFFSET dst))); 1081PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_jump(OFFSET dst))); 1082PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_jump(OFFSET dst))); 1083PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_branchif(OFFSET dst))); 1084PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_branchif(OFFSET dst))); 1085PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_branchif(OFFSET dst))); 1086PUREFUNC(MAYBE_UNUSED(static const char* attr_name_branchif(OFFSET dst))); 1087PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_branchif(OFFSET dst))); 1088PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_branchif(OFFSET dst))); 1089PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_branchif(OFFSET dst))); 1090PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_branchif(OFFSET dst))); 1091PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_branchif(OFFSET dst))); 1092PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_branchunless(OFFSET dst))); 1093PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_branchunless(OFFSET dst))); 1094PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_branchunless(OFFSET dst))); 1095PUREFUNC(MAYBE_UNUSED(static const char* attr_name_branchunless(OFFSET dst))); 1096PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_branchunless(OFFSET dst))); 1097PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_branchunless(OFFSET dst))); 1098PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_branchunless(OFFSET dst))); 1099PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_branchunless(OFFSET dst))); 1100PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_branchunless(OFFSET dst))); 1101PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_branchnil(OFFSET dst))); 1102PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_branchnil(OFFSET dst))); 1103PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_branchnil(OFFSET dst))); 1104PUREFUNC(MAYBE_UNUSED(static const char* attr_name_branchnil(OFFSET dst))); 1105PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_branchnil(OFFSET dst))); 1106PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_branchnil(OFFSET dst))); 1107PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_branchnil(OFFSET dst))); 1108PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_branchnil(OFFSET dst))); 1109PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_branchnil(OFFSET dst))); 1110PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_opt_getinlinecache(OFFSET dst, IC ic))); 1111PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_opt_getinlinecache(OFFSET dst, IC ic))); 1112PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_opt_getinlinecache(OFFSET dst, IC ic))); 1113PUREFUNC(MAYBE_UNUSED(static const char* attr_name_opt_getinlinecache(OFFSET dst, IC ic))); 1114PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_opt_getinlinecache(OFFSET dst, IC ic))); 1115PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_opt_getinlinecache(OFFSET dst, IC ic))); 1116PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_opt_getinlinecache(OFFSET dst, IC ic))); 1117PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_opt_getinlinecache(OFFSET dst, IC ic))); 1118PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_opt_getinlinecache(OFFSET dst, IC ic))); 1119PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_opt_setinlinecache(IC ic))); 1120PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_opt_setinlinecache(IC ic))); 1121PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_opt_setinlinecache(IC ic))); 1122PUREFUNC(MAYBE_UNUSED(static const char* attr_name_opt_setinlinecache(IC ic))); 1123PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_opt_setinlinecache(IC ic))); 1124PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_opt_setinlinecache(IC ic))); 1125PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_opt_setinlinecache(IC ic))); 1126PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_opt_setinlinecache(IC ic))); 1127PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_opt_setinlinecache(IC ic))); 1128PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_once(ISEQ iseq, ISE ise))); 1129PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_once(ISEQ iseq, ISE ise))); 1130PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_once(ISEQ iseq, ISE ise))); 1131PUREFUNC(MAYBE_UNUSED(static const char* attr_name_once(ISEQ iseq, ISE ise))); 1132PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_once(ISEQ iseq, ISE ise))); 1133PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_once(ISEQ iseq, ISE ise))); 1134PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_once(ISEQ iseq, ISE ise))); 1135PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_once(ISEQ iseq, ISE ise))); 1136PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_once(ISEQ iseq, ISE ise))); 1137PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_opt_case_dispatch(CDHASH hash, OFFSET else_offset))); 1138PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_opt_case_dispatch(CDHASH hash, OFFSET else_offset))); 1139PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_opt_case_dispatch(CDHASH hash, OFFSET else_offset))); 1140PUREFUNC(MAYBE_UNUSED(static const char* attr_name_opt_case_dispatch(CDHASH hash, OFFSET else_offset))); 1141PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_opt_case_dispatch(CDHASH hash, OFFSET else_offset))); 1142PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_opt_case_dispatch(CDHASH hash, OFFSET else_offset))); 1143PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_opt_case_dispatch(CDHASH hash, OFFSET else_offset))); 1144PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_opt_case_dispatch(CDHASH hash, OFFSET else_offset))); 1145PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_opt_case_dispatch(CDHASH hash, OFFSET else_offset))); 1146PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_opt_plus(CALL_INFO ci, CALL_CACHE cc))); 1147PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_opt_plus(CALL_INFO ci, CALL_CACHE cc))); 1148PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_opt_plus(CALL_INFO ci, CALL_CACHE cc))); 1149PUREFUNC(MAYBE_UNUSED(static const char* attr_name_opt_plus(CALL_INFO ci, CALL_CACHE cc))); 1150PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_opt_plus(CALL_INFO ci, CALL_CACHE cc))); 1151PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_opt_plus(CALL_INFO ci, CALL_CACHE cc))); 1152PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_opt_plus(CALL_INFO ci, CALL_CACHE cc))); 1153PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_opt_plus(CALL_INFO ci, CALL_CACHE cc))); 1154PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_opt_plus(CALL_INFO ci, CALL_CACHE cc))); 1155PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_opt_minus(CALL_INFO ci, CALL_CACHE cc))); 1156PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_opt_minus(CALL_INFO ci, CALL_CACHE cc))); 1157PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_opt_minus(CALL_INFO ci, CALL_CACHE cc))); 1158PUREFUNC(MAYBE_UNUSED(static const char* attr_name_opt_minus(CALL_INFO ci, CALL_CACHE cc))); 1159PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_opt_minus(CALL_INFO ci, CALL_CACHE cc))); 1160PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_opt_minus(CALL_INFO ci, CALL_CACHE cc))); 1161PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_opt_minus(CALL_INFO ci, CALL_CACHE cc))); 1162PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_opt_minus(CALL_INFO ci, CALL_CACHE cc))); 1163PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_opt_minus(CALL_INFO ci, CALL_CACHE cc))); 1164PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_opt_mult(CALL_INFO ci, CALL_CACHE cc))); 1165PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_opt_mult(CALL_INFO ci, CALL_CACHE cc))); 1166PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_opt_mult(CALL_INFO ci, CALL_CACHE cc))); 1167PUREFUNC(MAYBE_UNUSED(static const char* attr_name_opt_mult(CALL_INFO ci, CALL_CACHE cc))); 1168PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_opt_mult(CALL_INFO ci, CALL_CACHE cc))); 1169PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_opt_mult(CALL_INFO ci, CALL_CACHE cc))); 1170PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_opt_mult(CALL_INFO ci, CALL_CACHE cc))); 1171PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_opt_mult(CALL_INFO ci, CALL_CACHE cc))); 1172PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_opt_mult(CALL_INFO ci, CALL_CACHE cc))); 1173PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_opt_div(CALL_INFO ci, CALL_CACHE cc))); 1174PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_opt_div(CALL_INFO ci, CALL_CACHE cc))); 1175PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_opt_div(CALL_INFO ci, CALL_CACHE cc))); 1176PUREFUNC(MAYBE_UNUSED(static const char* attr_name_opt_div(CALL_INFO ci, CALL_CACHE cc))); 1177PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_opt_div(CALL_INFO ci, CALL_CACHE cc))); 1178PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_opt_div(CALL_INFO ci, CALL_CACHE cc))); 1179PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_opt_div(CALL_INFO ci, CALL_CACHE cc))); 1180PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_opt_div(CALL_INFO ci, CALL_CACHE cc))); 1181PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_opt_div(CALL_INFO ci, CALL_CACHE cc))); 1182PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_opt_mod(CALL_INFO ci, CALL_CACHE cc))); 1183PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_opt_mod(CALL_INFO ci, CALL_CACHE cc))); 1184PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_opt_mod(CALL_INFO ci, CALL_CACHE cc))); 1185PUREFUNC(MAYBE_UNUSED(static const char* attr_name_opt_mod(CALL_INFO ci, CALL_CACHE cc))); 1186PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_opt_mod(CALL_INFO ci, CALL_CACHE cc))); 1187PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_opt_mod(CALL_INFO ci, CALL_CACHE cc))); 1188PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_opt_mod(CALL_INFO ci, CALL_CACHE cc))); 1189PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_opt_mod(CALL_INFO ci, CALL_CACHE cc))); 1190PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_opt_mod(CALL_INFO ci, CALL_CACHE cc))); 1191PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_opt_eq(CALL_INFO ci, CALL_CACHE cc))); 1192PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_opt_eq(CALL_INFO ci, CALL_CACHE cc))); 1193PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_opt_eq(CALL_INFO ci, CALL_CACHE cc))); 1194PUREFUNC(MAYBE_UNUSED(static const char* attr_name_opt_eq(CALL_INFO ci, CALL_CACHE cc))); 1195PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_opt_eq(CALL_INFO ci, CALL_CACHE cc))); 1196PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_opt_eq(CALL_INFO ci, CALL_CACHE cc))); 1197PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_opt_eq(CALL_INFO ci, CALL_CACHE cc))); 1198PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_opt_eq(CALL_INFO ci, CALL_CACHE cc))); 1199PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_opt_eq(CALL_INFO ci, CALL_CACHE cc))); 1200PUREFUNC(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))); 1201PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_opt_neq(CALL_INFO ci_eq, CALL_CACHE cc_eq, CALL_INFO ci, CALL_CACHE cc))); 1202PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_opt_neq(CALL_INFO ci_eq, CALL_CACHE cc_eq, CALL_INFO ci, CALL_CACHE cc))); 1203PUREFUNC(MAYBE_UNUSED(static const char* attr_name_opt_neq(CALL_INFO ci_eq, CALL_CACHE cc_eq, CALL_INFO ci, CALL_CACHE cc))); 1204PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_opt_neq(CALL_INFO ci_eq, CALL_CACHE cc_eq, CALL_INFO ci, CALL_CACHE cc))); 1205PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_opt_neq(CALL_INFO ci_eq, CALL_CACHE cc_eq, CALL_INFO ci, CALL_CACHE cc))); 1206PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_opt_neq(CALL_INFO ci_eq, CALL_CACHE cc_eq, CALL_INFO ci, CALL_CACHE cc))); 1207PUREFUNC(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))); 1208PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_opt_neq(CALL_INFO ci_eq, CALL_CACHE cc_eq, CALL_INFO ci, CALL_CACHE cc))); 1209PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_opt_lt(CALL_INFO ci, CALL_CACHE cc))); 1210PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_opt_lt(CALL_INFO ci, CALL_CACHE cc))); 1211PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_opt_lt(CALL_INFO ci, CALL_CACHE cc))); 1212PUREFUNC(MAYBE_UNUSED(static const char* attr_name_opt_lt(CALL_INFO ci, CALL_CACHE cc))); 1213PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_opt_lt(CALL_INFO ci, CALL_CACHE cc))); 1214PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_opt_lt(CALL_INFO ci, CALL_CACHE cc))); 1215PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_opt_lt(CALL_INFO ci, CALL_CACHE cc))); 1216PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_opt_lt(CALL_INFO ci, CALL_CACHE cc))); 1217PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_opt_lt(CALL_INFO ci, CALL_CACHE cc))); 1218PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_opt_le(CALL_INFO ci, CALL_CACHE cc))); 1219PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_opt_le(CALL_INFO ci, CALL_CACHE cc))); 1220PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_opt_le(CALL_INFO ci, CALL_CACHE cc))); 1221PUREFUNC(MAYBE_UNUSED(static const char* attr_name_opt_le(CALL_INFO ci, CALL_CACHE cc))); 1222PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_opt_le(CALL_INFO ci, CALL_CACHE cc))); 1223PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_opt_le(CALL_INFO ci, CALL_CACHE cc))); 1224PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_opt_le(CALL_INFO ci, CALL_CACHE cc))); 1225PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_opt_le(CALL_INFO ci, CALL_CACHE cc))); 1226PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_opt_le(CALL_INFO ci, CALL_CACHE cc))); 1227PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_opt_gt(CALL_INFO ci, CALL_CACHE cc))); 1228PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_opt_gt(CALL_INFO ci, CALL_CACHE cc))); 1229PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_opt_gt(CALL_INFO ci, CALL_CACHE cc))); 1230PUREFUNC(MAYBE_UNUSED(static const char* attr_name_opt_gt(CALL_INFO ci, CALL_CACHE cc))); 1231PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_opt_gt(CALL_INFO ci, CALL_CACHE cc))); 1232PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_opt_gt(CALL_INFO ci, CALL_CACHE cc))); 1233PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_opt_gt(CALL_INFO ci, CALL_CACHE cc))); 1234PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_opt_gt(CALL_INFO ci, CALL_CACHE cc))); 1235PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_opt_gt(CALL_INFO ci, CALL_CACHE cc))); 1236PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_opt_ge(CALL_INFO ci, CALL_CACHE cc))); 1237PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_opt_ge(CALL_INFO ci, CALL_CACHE cc))); 1238PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_opt_ge(CALL_INFO ci, CALL_CACHE cc))); 1239PUREFUNC(MAYBE_UNUSED(static const char* attr_name_opt_ge(CALL_INFO ci, CALL_CACHE cc))); 1240PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_opt_ge(CALL_INFO ci, CALL_CACHE cc))); 1241PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_opt_ge(CALL_INFO ci, CALL_CACHE cc))); 1242PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_opt_ge(CALL_INFO ci, CALL_CACHE cc))); 1243PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_opt_ge(CALL_INFO ci, CALL_CACHE cc))); 1244PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_opt_ge(CALL_INFO ci, CALL_CACHE cc))); 1245PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_opt_ltlt(CALL_INFO ci, CALL_CACHE cc))); 1246PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_opt_ltlt(CALL_INFO ci, CALL_CACHE cc))); 1247PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_opt_ltlt(CALL_INFO ci, CALL_CACHE cc))); 1248PUREFUNC(MAYBE_UNUSED(static const char* attr_name_opt_ltlt(CALL_INFO ci, CALL_CACHE cc))); 1249PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_opt_ltlt(CALL_INFO ci, CALL_CACHE cc))); 1250PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_opt_ltlt(CALL_INFO ci, CALL_CACHE cc))); 1251PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_opt_ltlt(CALL_INFO ci, CALL_CACHE cc))); 1252PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_opt_ltlt(CALL_INFO ci, CALL_CACHE cc))); 1253PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_opt_ltlt(CALL_INFO ci, CALL_CACHE cc))); 1254PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_opt_and(CALL_INFO ci, CALL_CACHE cc))); 1255PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_opt_and(CALL_INFO ci, CALL_CACHE cc))); 1256PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_opt_and(CALL_INFO ci, CALL_CACHE cc))); 1257PUREFUNC(MAYBE_UNUSED(static const char* attr_name_opt_and(CALL_INFO ci, CALL_CACHE cc))); 1258PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_opt_and(CALL_INFO ci, CALL_CACHE cc))); 1259PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_opt_and(CALL_INFO ci, CALL_CACHE cc))); 1260PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_opt_and(CALL_INFO ci, CALL_CACHE cc))); 1261PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_opt_and(CALL_INFO ci, CALL_CACHE cc))); 1262PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_opt_and(CALL_INFO ci, CALL_CACHE cc))); 1263PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_opt_or(CALL_INFO ci, CALL_CACHE cc))); 1264PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_opt_or(CALL_INFO ci, CALL_CACHE cc))); 1265PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_opt_or(CALL_INFO ci, CALL_CACHE cc))); 1266PUREFUNC(MAYBE_UNUSED(static const char* attr_name_opt_or(CALL_INFO ci, CALL_CACHE cc))); 1267PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_opt_or(CALL_INFO ci, CALL_CACHE cc))); 1268PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_opt_or(CALL_INFO ci, CALL_CACHE cc))); 1269PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_opt_or(CALL_INFO ci, CALL_CACHE cc))); 1270PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_opt_or(CALL_INFO ci, CALL_CACHE cc))); 1271PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_opt_or(CALL_INFO ci, CALL_CACHE cc))); 1272PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_opt_aref(CALL_INFO ci, CALL_CACHE cc))); 1273PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_opt_aref(CALL_INFO ci, CALL_CACHE cc))); 1274PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_opt_aref(CALL_INFO ci, CALL_CACHE cc))); 1275PUREFUNC(MAYBE_UNUSED(static const char* attr_name_opt_aref(CALL_INFO ci, CALL_CACHE cc))); 1276PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_opt_aref(CALL_INFO ci, CALL_CACHE cc))); 1277PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_opt_aref(CALL_INFO ci, CALL_CACHE cc))); 1278PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_opt_aref(CALL_INFO ci, CALL_CACHE cc))); 1279PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_opt_aref(CALL_INFO ci, CALL_CACHE cc))); 1280PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_opt_aref(CALL_INFO ci, CALL_CACHE cc))); 1281PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_opt_aset(CALL_INFO ci, CALL_CACHE cc))); 1282PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_opt_aset(CALL_INFO ci, CALL_CACHE cc))); 1283PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_opt_aset(CALL_INFO ci, CALL_CACHE cc))); 1284PUREFUNC(MAYBE_UNUSED(static const char* attr_name_opt_aset(CALL_INFO ci, CALL_CACHE cc))); 1285PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_opt_aset(CALL_INFO ci, CALL_CACHE cc))); 1286PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_opt_aset(CALL_INFO ci, CALL_CACHE cc))); 1287PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_opt_aset(CALL_INFO ci, CALL_CACHE cc))); 1288PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_opt_aset(CALL_INFO ci, CALL_CACHE cc))); 1289PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_opt_aset(CALL_INFO ci, CALL_CACHE cc))); 1290PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_opt_aset_with(VALUE key, CALL_INFO ci, CALL_CACHE cc))); 1291PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_opt_aset_with(VALUE key, CALL_INFO ci, CALL_CACHE cc))); 1292PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_opt_aset_with(VALUE key, CALL_INFO ci, CALL_CACHE cc))); 1293PUREFUNC(MAYBE_UNUSED(static const char* attr_name_opt_aset_with(VALUE key, CALL_INFO ci, CALL_CACHE cc))); 1294PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_opt_aset_with(VALUE key, CALL_INFO ci, CALL_CACHE cc))); 1295PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_opt_aset_with(VALUE key, CALL_INFO ci, CALL_CACHE cc))); 1296PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_opt_aset_with(VALUE key, CALL_INFO ci, CALL_CACHE cc))); 1297PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_opt_aset_with(VALUE key, CALL_INFO ci, CALL_CACHE cc))); 1298PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_opt_aset_with(VALUE key, CALL_INFO ci, CALL_CACHE cc))); 1299PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_opt_aref_with(VALUE key, CALL_INFO ci, CALL_CACHE cc))); 1300PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_opt_aref_with(VALUE key, CALL_INFO ci, CALL_CACHE cc))); 1301PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_opt_aref_with(VALUE key, CALL_INFO ci, CALL_CACHE cc))); 1302PUREFUNC(MAYBE_UNUSED(static const char* attr_name_opt_aref_with(VALUE key, CALL_INFO ci, CALL_CACHE cc))); 1303PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_opt_aref_with(VALUE key, CALL_INFO ci, CALL_CACHE cc))); 1304PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_opt_aref_with(VALUE key, CALL_INFO ci, CALL_CACHE cc))); 1305PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_opt_aref_with(VALUE key, CALL_INFO ci, CALL_CACHE cc))); 1306PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_opt_aref_with(VALUE key, CALL_INFO ci, CALL_CACHE cc))); 1307PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_opt_aref_with(VALUE key, CALL_INFO ci, CALL_CACHE cc))); 1308PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_opt_length(CALL_INFO ci, CALL_CACHE cc))); 1309PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_opt_length(CALL_INFO ci, CALL_CACHE cc))); 1310PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_opt_length(CALL_INFO ci, CALL_CACHE cc))); 1311PUREFUNC(MAYBE_UNUSED(static const char* attr_name_opt_length(CALL_INFO ci, CALL_CACHE cc))); 1312PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_opt_length(CALL_INFO ci, CALL_CACHE cc))); 1313PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_opt_length(CALL_INFO ci, CALL_CACHE cc))); 1314PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_opt_length(CALL_INFO ci, CALL_CACHE cc))); 1315PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_opt_length(CALL_INFO ci, CALL_CACHE cc))); 1316PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_opt_length(CALL_INFO ci, CALL_CACHE cc))); 1317PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_opt_size(CALL_INFO ci, CALL_CACHE cc))); 1318PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_opt_size(CALL_INFO ci, CALL_CACHE cc))); 1319PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_opt_size(CALL_INFO ci, CALL_CACHE cc))); 1320PUREFUNC(MAYBE_UNUSED(static const char* attr_name_opt_size(CALL_INFO ci, CALL_CACHE cc))); 1321PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_opt_size(CALL_INFO ci, CALL_CACHE cc))); 1322PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_opt_size(CALL_INFO ci, CALL_CACHE cc))); 1323PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_opt_size(CALL_INFO ci, CALL_CACHE cc))); 1324PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_opt_size(CALL_INFO ci, CALL_CACHE cc))); 1325PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_opt_size(CALL_INFO ci, CALL_CACHE cc))); 1326PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_opt_empty_p(CALL_INFO ci, CALL_CACHE cc))); 1327PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_opt_empty_p(CALL_INFO ci, CALL_CACHE cc))); 1328PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_opt_empty_p(CALL_INFO ci, CALL_CACHE cc))); 1329PUREFUNC(MAYBE_UNUSED(static const char* attr_name_opt_empty_p(CALL_INFO ci, CALL_CACHE cc))); 1330PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_opt_empty_p(CALL_INFO ci, CALL_CACHE cc))); 1331PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_opt_empty_p(CALL_INFO ci, CALL_CACHE cc))); 1332PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_opt_empty_p(CALL_INFO ci, CALL_CACHE cc))); 1333PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_opt_empty_p(CALL_INFO ci, CALL_CACHE cc))); 1334PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_opt_empty_p(CALL_INFO ci, CALL_CACHE cc))); 1335PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_opt_succ(CALL_INFO ci, CALL_CACHE cc))); 1336PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_opt_succ(CALL_INFO ci, CALL_CACHE cc))); 1337PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_opt_succ(CALL_INFO ci, CALL_CACHE cc))); 1338PUREFUNC(MAYBE_UNUSED(static const char* attr_name_opt_succ(CALL_INFO ci, CALL_CACHE cc))); 1339PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_opt_succ(CALL_INFO ci, CALL_CACHE cc))); 1340PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_opt_succ(CALL_INFO ci, CALL_CACHE cc))); 1341PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_opt_succ(CALL_INFO ci, CALL_CACHE cc))); 1342PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_opt_succ(CALL_INFO ci, CALL_CACHE cc))); 1343PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_opt_succ(CALL_INFO ci, CALL_CACHE cc))); 1344PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_opt_not(CALL_INFO ci, CALL_CACHE cc))); 1345PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_opt_not(CALL_INFO ci, CALL_CACHE cc))); 1346PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_opt_not(CALL_INFO ci, CALL_CACHE cc))); 1347PUREFUNC(MAYBE_UNUSED(static const char* attr_name_opt_not(CALL_INFO ci, CALL_CACHE cc))); 1348PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_opt_not(CALL_INFO ci, CALL_CACHE cc))); 1349PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_opt_not(CALL_INFO ci, CALL_CACHE cc))); 1350PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_opt_not(CALL_INFO ci, CALL_CACHE cc))); 1351PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_opt_not(CALL_INFO ci, CALL_CACHE cc))); 1352PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_opt_not(CALL_INFO ci, CALL_CACHE cc))); 1353PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_opt_regexpmatch1(VALUE recv))); 1354PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_opt_regexpmatch1(VALUE recv))); 1355PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_opt_regexpmatch1(VALUE recv))); 1356PUREFUNC(MAYBE_UNUSED(static const char* attr_name_opt_regexpmatch1(VALUE recv))); 1357PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_opt_regexpmatch1(VALUE recv))); 1358PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_opt_regexpmatch1(VALUE recv))); 1359PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_opt_regexpmatch1(VALUE recv))); 1360PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_opt_regexpmatch1(VALUE recv))); 1361PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_opt_regexpmatch1(VALUE recv))); 1362PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_opt_regexpmatch2(CALL_INFO ci, CALL_CACHE cc))); 1363PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_opt_regexpmatch2(CALL_INFO ci, CALL_CACHE cc))); 1364PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_opt_regexpmatch2(CALL_INFO ci, CALL_CACHE cc))); 1365PUREFUNC(MAYBE_UNUSED(static const char* attr_name_opt_regexpmatch2(CALL_INFO ci, CALL_CACHE cc))); 1366PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_opt_regexpmatch2(CALL_INFO ci, CALL_CACHE cc))); 1367PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_opt_regexpmatch2(CALL_INFO ci, CALL_CACHE cc))); 1368PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_opt_regexpmatch2(CALL_INFO ci, CALL_CACHE cc))); 1369PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_opt_regexpmatch2(CALL_INFO ci, CALL_CACHE cc))); 1370PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_opt_regexpmatch2(CALL_INFO ci, CALL_CACHE cc))); 1371PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_opt_call_c_function(rb_insn_func_t funcptr))); 1372PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_opt_call_c_function(rb_insn_func_t funcptr))); 1373PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_opt_call_c_function(rb_insn_func_t funcptr))); 1374PUREFUNC(MAYBE_UNUSED(static const char* attr_name_opt_call_c_function(rb_insn_func_t funcptr))); 1375PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_opt_call_c_function(rb_insn_func_t funcptr))); 1376PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_opt_call_c_function(rb_insn_func_t funcptr))); 1377PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_opt_call_c_function(rb_insn_func_t funcptr))); 1378PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_opt_call_c_function(rb_insn_func_t funcptr))); 1379PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_opt_call_c_function(rb_insn_func_t funcptr))); 1380PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_bitblt(void))); 1381PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_bitblt(void))); 1382PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_bitblt(void))); 1383PUREFUNC(MAYBE_UNUSED(static const char* attr_name_bitblt(void))); 1384PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_bitblt(void))); 1385PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_bitblt(void))); 1386PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_bitblt(void))); 1387PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_bitblt(void))); 1388PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_bitblt(void))); 1389PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_answer(void))); 1390PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_answer(void))); 1391PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_answer(void))); 1392PUREFUNC(MAYBE_UNUSED(static const char* attr_name_answer(void))); 1393PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_answer(void))); 1394PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_answer(void))); 1395PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_answer(void))); 1396PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_answer(void))); 1397PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_answer(void))); 1398PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_getlocal_WC_0(lindex_t idx))); 1399PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_getlocal_WC_0(lindex_t idx))); 1400PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_getlocal_WC_0(lindex_t idx))); 1401PUREFUNC(MAYBE_UNUSED(static const char* attr_name_getlocal_WC_0(lindex_t idx))); 1402PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_getlocal_WC_0(lindex_t idx))); 1403PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_getlocal_WC_0(lindex_t idx))); 1404PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_getlocal_WC_0(lindex_t idx))); 1405PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_getlocal_WC_0(lindex_t idx))); 1406PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_getlocal_WC_0(lindex_t idx))); 1407PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_getlocal_WC_1(lindex_t idx))); 1408PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_getlocal_WC_1(lindex_t idx))); 1409PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_getlocal_WC_1(lindex_t idx))); 1410PUREFUNC(MAYBE_UNUSED(static const char* attr_name_getlocal_WC_1(lindex_t idx))); 1411PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_getlocal_WC_1(lindex_t idx))); 1412PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_getlocal_WC_1(lindex_t idx))); 1413PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_getlocal_WC_1(lindex_t idx))); 1414PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_getlocal_WC_1(lindex_t idx))); 1415PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_getlocal_WC_1(lindex_t idx))); 1416PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_setlocal_WC_0(lindex_t idx))); 1417PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_setlocal_WC_0(lindex_t idx))); 1418PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_setlocal_WC_0(lindex_t idx))); 1419PUREFUNC(MAYBE_UNUSED(static const char* attr_name_setlocal_WC_0(lindex_t idx))); 1420PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_setlocal_WC_0(lindex_t idx))); 1421PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_setlocal_WC_0(lindex_t idx))); 1422PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_setlocal_WC_0(lindex_t idx))); 1423PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_setlocal_WC_0(lindex_t idx))); 1424PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_setlocal_WC_0(lindex_t idx))); 1425PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_setlocal_WC_1(lindex_t idx))); 1426PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_setlocal_WC_1(lindex_t idx))); 1427PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_setlocal_WC_1(lindex_t idx))); 1428PUREFUNC(MAYBE_UNUSED(static const char* attr_name_setlocal_WC_1(lindex_t idx))); 1429PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_setlocal_WC_1(lindex_t idx))); 1430PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_setlocal_WC_1(lindex_t idx))); 1431PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_setlocal_WC_1(lindex_t idx))); 1432PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_setlocal_WC_1(lindex_t idx))); 1433PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_setlocal_WC_1(lindex_t idx))); 1434PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_putobject_INT2FIX_0_(void))); 1435PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_putobject_INT2FIX_0_(void))); 1436PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_putobject_INT2FIX_0_(void))); 1437PUREFUNC(MAYBE_UNUSED(static const char* attr_name_putobject_INT2FIX_0_(void))); 1438PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_putobject_INT2FIX_0_(void))); 1439PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_putobject_INT2FIX_0_(void))); 1440PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_putobject_INT2FIX_0_(void))); 1441PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_putobject_INT2FIX_0_(void))); 1442PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_putobject_INT2FIX_0_(void))); 1443PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_putobject_INT2FIX_1_(void))); 1444PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_putobject_INT2FIX_1_(void))); 1445PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_putobject_INT2FIX_1_(void))); 1446PUREFUNC(MAYBE_UNUSED(static const char* attr_name_putobject_INT2FIX_1_(void))); 1447PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_putobject_INT2FIX_1_(void))); 1448PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_putobject_INT2FIX_1_(void))); 1449PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_putobject_INT2FIX_1_(void))); 1450PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_putobject_INT2FIX_1_(void))); 1451PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_putobject_INT2FIX_1_(void))); 1452 1453/* attr enum ruby_vminsn_type bin @ nop()()() */ 1454enum ruby_vminsn_type 1455attr_bin_nop(void) 1456{ 1457 return BIN(nop); 1458} 1459 1460/* attr bool handles_sp @ nop()()() */ 1461bool 1462attr_handles_sp_nop(void) 1463{ 1464 return false; 1465} 1466 1467/* attr bool leaf @ nop()()() */ 1468bool 1469attr_leaf_nop(void) 1470{ 1471 return true; 1472} 1473 1474/* attr const char* name @ nop()()() */ 1475const char* 1476attr_name_nop(void) 1477{ 1478 return insn_name(BIN(nop)); 1479} 1480 1481/* attr rb_num_t open @ nop()()() */ 1482rb_num_t 1483attr_open_nop(void) 1484{ 1485 return 0; 1486} 1487 1488/* attr rb_num_t popn @ nop()()() */ 1489rb_num_t 1490attr_popn_nop(void) 1491{ 1492 return 0; 1493} 1494 1495/* attr rb_num_t retn @ nop()()() */ 1496rb_num_t 1497attr_retn_nop(void) 1498{ 1499 return 0; 1500} 1501 1502/* attr rb_snum_t sp_inc @ nop()()() */ 1503rb_snum_t 1504attr_sp_inc_nop(void) 1505{ 1506 return 0; 1507} 1508 1509/* attr rb_num_t width @ nop()()() */ 1510rb_num_t 1511attr_width_nop(void) 1512{ 1513 return 1; 1514} 1515 1516/* attr enum ruby_vminsn_type bin @ getlocal(idx, level)()(val) */ 1517enum ruby_vminsn_type 1518attr_bin_getlocal( 1519 MAYBE_UNUSED(lindex_t idx), 1520 MAYBE_UNUSED(rb_num_t level) 1521) 1522{ 1523 return BIN(getlocal); 1524} 1525 1526/* attr bool handles_sp @ getlocal(idx, level)()(val) */ 1527bool 1528attr_handles_sp_getlocal( 1529 MAYBE_UNUSED(lindex_t idx), 1530 MAYBE_UNUSED(rb_num_t level) 1531) 1532{ 1533 return false; 1534} 1535 1536/* attr bool leaf @ getlocal(idx, level)()(val) */ 1537bool 1538attr_leaf_getlocal( 1539 MAYBE_UNUSED(lindex_t idx), 1540 MAYBE_UNUSED(rb_num_t level) 1541) 1542{ 1543 return true; 1544} 1545 1546/* attr const char* name @ getlocal(idx, level)()(val) */ 1547const char* 1548attr_name_getlocal( 1549 MAYBE_UNUSED(lindex_t idx), 1550 MAYBE_UNUSED(rb_num_t level) 1551) 1552{ 1553 return insn_name(BIN(getlocal)); 1554} 1555 1556/* attr rb_num_t open @ getlocal(idx, level)()(val) */ 1557rb_num_t 1558attr_open_getlocal( 1559 MAYBE_UNUSED(lindex_t idx), 1560 MAYBE_UNUSED(rb_num_t level) 1561) 1562{ 1563 return 2; 1564} 1565 1566/* attr rb_num_t popn @ getlocal(idx, level)()(val) */ 1567rb_num_t 1568attr_popn_getlocal( 1569 MAYBE_UNUSED(lindex_t idx), 1570 MAYBE_UNUSED(rb_num_t level) 1571) 1572{ 1573 return 0; 1574} 1575 1576/* attr rb_num_t retn @ getlocal(idx, level)()(val) */ 1577rb_num_t 1578attr_retn_getlocal( 1579 MAYBE_UNUSED(lindex_t idx), 1580 MAYBE_UNUSED(rb_num_t level) 1581) 1582{ 1583 return 1; 1584} 1585 1586/* attr rb_snum_t sp_inc @ getlocal(idx, level)()(val) */ 1587rb_snum_t 1588attr_sp_inc_getlocal( 1589 MAYBE_UNUSED(lindex_t idx), 1590 MAYBE_UNUSED(rb_num_t level) 1591) 1592{ 1593 return 1; 1594} 1595 1596/* attr rb_num_t width @ getlocal(idx, level)()(val) */ 1597rb_num_t 1598attr_width_getlocal( 1599 MAYBE_UNUSED(lindex_t idx), 1600 MAYBE_UNUSED(rb_num_t level) 1601) 1602{ 1603 return 3; 1604} 1605 1606/* attr enum ruby_vminsn_type bin @ setlocal(idx, level)(val)() */ 1607enum ruby_vminsn_type 1608attr_bin_setlocal( 1609 MAYBE_UNUSED(lindex_t idx), 1610 MAYBE_UNUSED(rb_num_t level) 1611) 1612{ 1613 return BIN(setlocal); 1614} 1615 1616/* attr bool handles_sp @ setlocal(idx, level)(val)() */ 1617bool 1618attr_handles_sp_setlocal( 1619 MAYBE_UNUSED(lindex_t idx), 1620 MAYBE_UNUSED(rb_num_t level) 1621) 1622{ 1623 return false; 1624} 1625 1626/* attr bool leaf @ setlocal(idx, level)(val)() */ 1627bool 1628attr_leaf_setlocal( 1629 MAYBE_UNUSED(lindex_t idx), 1630 MAYBE_UNUSED(rb_num_t level) 1631) 1632{ 1633 return true; 1634} 1635 1636/* attr const char* name @ setlocal(idx, level)(val)() */ 1637const char* 1638attr_name_setlocal( 1639 MAYBE_UNUSED(lindex_t idx), 1640 MAYBE_UNUSED(rb_num_t level) 1641) 1642{ 1643 return insn_name(BIN(setlocal)); 1644} 1645 1646/* attr rb_num_t open @ setlocal(idx, level)(val)() */ 1647rb_num_t 1648attr_open_setlocal( 1649 MAYBE_UNUSED(lindex_t idx), 1650 MAYBE_UNUSED(rb_num_t level) 1651) 1652{ 1653 return 2; 1654} 1655 1656/* attr rb_num_t popn @ setlocal(idx, level)(val)() */ 1657rb_num_t 1658attr_popn_setlocal( 1659 MAYBE_UNUSED(lindex_t idx), 1660 MAYBE_UNUSED(rb_num_t level) 1661) 1662{ 1663 return 1; 1664} 1665 1666/* attr rb_num_t retn @ setlocal(idx, level)(val)() */ 1667rb_num_t 1668attr_retn_setlocal( 1669 MAYBE_UNUSED(lindex_t idx), 1670 MAYBE_UNUSED(rb_num_t level) 1671) 1672{ 1673 return 0; 1674} 1675 1676/* attr rb_snum_t sp_inc @ setlocal(idx, level)(val)() */ 1677rb_snum_t 1678attr_sp_inc_setlocal( 1679 MAYBE_UNUSED(lindex_t idx), 1680 MAYBE_UNUSED(rb_num_t level) 1681) 1682{ 1683 return -1; 1684} 1685 1686/* attr rb_num_t width @ setlocal(idx, level)(val)() */ 1687rb_num_t 1688attr_width_setlocal( 1689 MAYBE_UNUSED(lindex_t idx), 1690 MAYBE_UNUSED(rb_num_t level) 1691) 1692{ 1693 return 3; 1694} 1695 1696/* attr enum ruby_vminsn_type bin @ getblockparam(idx, level)()(val) */ 1697enum ruby_vminsn_type 1698attr_bin_getblockparam( 1699 MAYBE_UNUSED(lindex_t idx), 1700 MAYBE_UNUSED(rb_num_t level) 1701) 1702{ 1703 return BIN(getblockparam); 1704} 1705 1706/* attr bool handles_sp @ getblockparam(idx, level)()(val) */ 1707bool 1708attr_handles_sp_getblockparam( 1709 MAYBE_UNUSED(lindex_t idx), 1710 MAYBE_UNUSED(rb_num_t level) 1711) 1712{ 1713 return false; 1714} 1715 1716/* attr bool leaf @ getblockparam(idx, level)()(val) */ 1717bool 1718attr_leaf_getblockparam( 1719 MAYBE_UNUSED(lindex_t idx), 1720 MAYBE_UNUSED(rb_num_t level) 1721) 1722{ 1723 return true; 1724} 1725 1726/* attr const char* name @ getblockparam(idx, level)()(val) */ 1727const char* 1728attr_name_getblockparam( 1729 MAYBE_UNUSED(lindex_t idx), 1730 MAYBE_UNUSED(rb_num_t level) 1731) 1732{ 1733 return insn_name(BIN(getblockparam)); 1734} 1735 1736/* attr rb_num_t open @ getblockparam(idx, level)()(val) */ 1737rb_num_t 1738attr_open_getblockparam( 1739 MAYBE_UNUSED(lindex_t idx), 1740 MAYBE_UNUSED(rb_num_t level) 1741) 1742{ 1743 return 2; 1744} 1745 1746/* attr rb_num_t popn @ getblockparam(idx, level)()(val) */ 1747rb_num_t 1748attr_popn_getblockparam( 1749 MAYBE_UNUSED(lindex_t idx), 1750 MAYBE_UNUSED(rb_num_t level) 1751) 1752{ 1753 return 0; 1754} 1755 1756/* attr rb_num_t retn @ getblockparam(idx, level)()(val) */ 1757rb_num_t 1758attr_retn_getblockparam( 1759 MAYBE_UNUSED(lindex_t idx), 1760 MAYBE_UNUSED(rb_num_t level) 1761) 1762{ 1763 return 1; 1764} 1765 1766/* attr rb_snum_t sp_inc @ getblockparam(idx, level)()(val) */ 1767rb_snum_t 1768attr_sp_inc_getblockparam( 1769 MAYBE_UNUSED(lindex_t idx), 1770 MAYBE_UNUSED(rb_num_t level) 1771) 1772{ 1773 return 1; 1774} 1775 1776/* attr rb_num_t width @ getblockparam(idx, level)()(val) */ 1777rb_num_t 1778attr_width_getblockparam( 1779 MAYBE_UNUSED(lindex_t idx), 1780 MAYBE_UNUSED(rb_num_t level) 1781) 1782{ 1783 return 3; 1784} 1785 1786/* attr enum ruby_vminsn_type bin @ setblockparam(idx, level)(val)() */ 1787enum ruby_vminsn_type 1788attr_bin_setblockparam( 1789 MAYBE_UNUSED(lindex_t idx), 1790 MAYBE_UNUSED(rb_num_t level) 1791) 1792{ 1793 return BIN(setblockparam); 1794} 1795 1796/* attr bool handles_sp @ setblockparam(idx, level)(val)() */ 1797bool 1798attr_handles_sp_setblockparam( 1799 MAYBE_UNUSED(lindex_t idx), 1800 MAYBE_UNUSED(rb_num_t level) 1801) 1802{ 1803 return false; 1804} 1805 1806/* attr bool leaf @ setblockparam(idx, level)(val)() */ 1807bool 1808attr_leaf_setblockparam( 1809 MAYBE_UNUSED(lindex_t idx), 1810 MAYBE_UNUSED(rb_num_t level) 1811) 1812{ 1813 return true; 1814} 1815 1816/* attr const char* name @ setblockparam(idx, level)(val)() */ 1817const char* 1818attr_name_setblockparam( 1819 MAYBE_UNUSED(lindex_t idx), 1820 MAYBE_UNUSED(rb_num_t level) 1821) 1822{ 1823 return insn_name(BIN(setblockparam)); 1824} 1825 1826/* attr rb_num_t open @ setblockparam(idx, level)(val)() */ 1827rb_num_t 1828attr_open_setblockparam( 1829 MAYBE_UNUSED(lindex_t idx), 1830 MAYBE_UNUSED(rb_num_t level) 1831) 1832{ 1833 return 2; 1834} 1835 1836/* attr rb_num_t popn @ setblockparam(idx, level)(val)() */ 1837rb_num_t 1838attr_popn_setblockparam( 1839 MAYBE_UNUSED(lindex_t idx), 1840 MAYBE_UNUSED(rb_num_t level) 1841) 1842{ 1843 return 1; 1844} 1845 1846/* attr rb_num_t retn @ setblockparam(idx, level)(val)() */ 1847rb_num_t 1848attr_retn_setblockparam( 1849 MAYBE_UNUSED(lindex_t idx), 1850 MAYBE_UNUSED(rb_num_t level) 1851) 1852{ 1853 return 0; 1854} 1855 1856/* attr rb_snum_t sp_inc @ setblockparam(idx, level)(val)() */ 1857rb_snum_t 1858attr_sp_inc_setblockparam( 1859 MAYBE_UNUSED(lindex_t idx), 1860 MAYBE_UNUSED(rb_num_t level) 1861) 1862{ 1863 return -1; 1864} 1865 1866/* attr rb_num_t width @ setblockparam(idx, level)(val)() */ 1867rb_num_t 1868attr_width_setblockparam( 1869 MAYBE_UNUSED(lindex_t idx), 1870 MAYBE_UNUSED(rb_num_t level) 1871) 1872{ 1873 return 3; 1874} 1875 1876/* attr enum ruby_vminsn_type bin @ getblockparamproxy(idx, level)()(val) */ 1877enum ruby_vminsn_type 1878attr_bin_getblockparamproxy( 1879 MAYBE_UNUSED(lindex_t idx), 1880 MAYBE_UNUSED(rb_num_t level) 1881) 1882{ 1883 return BIN(getblockparamproxy); 1884} 1885 1886/* attr bool handles_sp @ getblockparamproxy(idx, level)()(val) */ 1887bool 1888attr_handles_sp_getblockparamproxy( 1889 MAYBE_UNUSED(lindex_t idx), 1890 MAYBE_UNUSED(rb_num_t level) 1891) 1892{ 1893 return false; 1894} 1895 1896/* attr bool leaf @ getblockparamproxy(idx, level)()(val) */ 1897bool 1898attr_leaf_getblockparamproxy( 1899 MAYBE_UNUSED(lindex_t idx), 1900 MAYBE_UNUSED(rb_num_t level) 1901) 1902{ 1903 return true; 1904} 1905 1906/* attr const char* name @ getblockparamproxy(idx, level)()(val) */ 1907const char* 1908attr_name_getblockparamproxy( 1909 MAYBE_UNUSED(lindex_t idx), 1910 MAYBE_UNUSED(rb_num_t level) 1911) 1912{ 1913 return insn_name(BIN(getblockparamproxy)); 1914} 1915 1916/* attr rb_num_t open @ getblockparamproxy(idx, level)()(val) */ 1917rb_num_t 1918attr_open_getblockparamproxy( 1919 MAYBE_UNUSED(lindex_t idx), 1920 MAYBE_UNUSED(rb_num_t level) 1921) 1922{ 1923 return 2; 1924} 1925 1926/* attr rb_num_t popn @ getblockparamproxy(idx, level)()(val) */ 1927rb_num_t 1928attr_popn_getblockparamproxy( 1929 MAYBE_UNUSED(lindex_t idx), 1930 MAYBE_UNUSED(rb_num_t level) 1931) 1932{ 1933 return 0; 1934} 1935 1936/* attr rb_num_t retn @ getblockparamproxy(idx, level)()(val) */ 1937rb_num_t 1938attr_retn_getblockparamproxy( 1939 MAYBE_UNUSED(lindex_t idx), 1940 MAYBE_UNUSED(rb_num_t level) 1941) 1942{ 1943 return 1; 1944} 1945 1946/* attr rb_snum_t sp_inc @ getblockparamproxy(idx, level)()(val) */ 1947rb_snum_t 1948attr_sp_inc_getblockparamproxy( 1949 MAYBE_UNUSED(lindex_t idx), 1950 MAYBE_UNUSED(rb_num_t level) 1951) 1952{ 1953 return 1; 1954} 1955 1956/* attr rb_num_t width @ getblockparamproxy(idx, level)()(val) */ 1957rb_num_t 1958attr_width_getblockparamproxy( 1959 MAYBE_UNUSED(lindex_t idx), 1960 MAYBE_UNUSED(rb_num_t level) 1961) 1962{ 1963 return 3; 1964} 1965 1966/* attr enum ruby_vminsn_type bin @ getspecial(key, type)()(val) */ 1967enum ruby_vminsn_type 1968attr_bin_getspecial( 1969 MAYBE_UNUSED(rb_num_t key), 1970 MAYBE_UNUSED(rb_num_t type) 1971) 1972{ 1973 return BIN(getspecial); 1974} 1975 1976/* attr bool handles_sp @ getspecial(key, type)()(val) */ 1977bool 1978attr_handles_sp_getspecial( 1979 MAYBE_UNUSED(rb_num_t key), 1980 MAYBE_UNUSED(rb_num_t type) 1981) 1982{ 1983 return false; 1984} 1985 1986/* attr bool leaf @ getspecial(key, type)()(val) */ 1987bool 1988attr_leaf_getspecial( 1989 MAYBE_UNUSED(rb_num_t key), 1990 MAYBE_UNUSED(rb_num_t type) 1991) 1992{ 1993 return true; 1994} 1995 1996/* attr const char* name @ getspecial(key, type)()(val) */ 1997const char* 1998attr_name_getspecial( 1999 MAYBE_UNUSED(rb_num_t key), 2000 MAYBE_UNUSED(rb_num_t type) 2001) 2002{ 2003 return insn_name(BIN(getspecial)); 2004} 2005 2006/* attr rb_num_t open @ getspecial(key, type)()(val) */ 2007rb_num_t 2008attr_open_getspecial( 2009 MAYBE_UNUSED(rb_num_t key), 2010 MAYBE_UNUSED(rb_num_t type) 2011) 2012{ 2013 return 2; 2014} 2015 2016/* attr rb_num_t popn @ getspecial(key, type)()(val) */ 2017rb_num_t 2018attr_popn_getspecial( 2019 MAYBE_UNUSED(rb_num_t key), 2020 MAYBE_UNUSED(rb_num_t type) 2021) 2022{ 2023 return 0; 2024} 2025 2026/* attr rb_num_t retn @ getspecial(key, type)()(val) */ 2027rb_num_t 2028attr_retn_getspecial( 2029 MAYBE_UNUSED(rb_num_t key), 2030 MAYBE_UNUSED(rb_num_t type) 2031) 2032{ 2033 return 1; 2034} 2035 2036/* attr rb_snum_t sp_inc @ getspecial(key, type)()(val) */ 2037rb_snum_t 2038attr_sp_inc_getspecial( 2039 MAYBE_UNUSED(rb_num_t key), 2040 MAYBE_UNUSED(rb_num_t type) 2041) 2042{ 2043 return 1; 2044} 2045 2046/* attr rb_num_t width @ getspecial(key, type)()(val) */ 2047rb_num_t 2048attr_width_getspecial( 2049 MAYBE_UNUSED(rb_num_t key), 2050 MAYBE_UNUSED(rb_num_t type) 2051) 2052{ 2053 return 3; 2054} 2055 2056/* attr enum ruby_vminsn_type bin @ setspecial(key)(obj)() */ 2057enum ruby_vminsn_type 2058attr_bin_setspecial(MAYBE_UNUSED(rb_num_t key)) 2059{ 2060 return BIN(setspecial); 2061} 2062 2063/* attr bool handles_sp @ setspecial(key)(obj)() */ 2064bool 2065attr_handles_sp_setspecial(MAYBE_UNUSED(rb_num_t key)) 2066{ 2067 return false; 2068} 2069 2070/* attr bool leaf @ setspecial(key)(obj)() */ 2071bool 2072attr_leaf_setspecial(MAYBE_UNUSED(rb_num_t key)) 2073{ 2074 return true; 2075} 2076 2077/* attr const char* name @ setspecial(key)(obj)() */ 2078const char* 2079attr_name_setspecial(MAYBE_UNUSED(rb_num_t key)) 2080{ 2081 return insn_name(BIN(setspecial)); 2082} 2083 2084/* attr rb_num_t open @ setspecial(key)(obj)() */ 2085rb_num_t 2086attr_open_setspecial(MAYBE_UNUSED(rb_num_t key)) 2087{ 2088 return 1; 2089} 2090 2091/* attr rb_num_t popn @ setspecial(key)(obj)() */ 2092rb_num_t 2093attr_popn_setspecial(MAYBE_UNUSED(rb_num_t key)) 2094{ 2095 return 1; 2096} 2097 2098/* attr rb_num_t retn @ setspecial(key)(obj)() */ 2099rb_num_t 2100attr_retn_setspecial(MAYBE_UNUSED(rb_num_t key)) 2101{ 2102 return 0; 2103} 2104 2105/* attr rb_snum_t sp_inc @ setspecial(key)(obj)() */ 2106rb_snum_t 2107attr_sp_inc_setspecial(MAYBE_UNUSED(rb_num_t key)) 2108{ 2109 return -1; 2110} 2111 2112/* attr rb_num_t width @ setspecial(key)(obj)() */ 2113rb_num_t 2114attr_width_setspecial(MAYBE_UNUSED(rb_num_t key)) 2115{ 2116 return 2; 2117} 2118 2119/* attr enum ruby_vminsn_type bin @ getinstancevariable(id, ic)()(val) */ 2120enum ruby_vminsn_type 2121attr_bin_getinstancevariable( 2122 MAYBE_UNUSED(ID id), 2123 MAYBE_UNUSED(IC ic) 2124) 2125{ 2126 return BIN(getinstancevariable); 2127} 2128 2129/* attr bool handles_sp @ getinstancevariable(id, ic)()(val) */ 2130bool 2131attr_handles_sp_getinstancevariable( 2132 MAYBE_UNUSED(ID id), 2133 MAYBE_UNUSED(IC ic) 2134) 2135{ 2136 return false; 2137} 2138 2139/* attr bool leaf @ getinstancevariable(id, ic)()(val) */ 2140bool 2141attr_leaf_getinstancevariable( 2142 MAYBE_UNUSED(ID id), 2143 MAYBE_UNUSED(IC ic) 2144) 2145{ 2146 return 2147#line 212 "insns.def" 2148false; 2149#line 2150 "insns_info.inc" 2150} 2151 2152/* attr const char* name @ getinstancevariable(id, ic)()(val) */ 2153const char* 2154attr_name_getinstancevariable( 2155 MAYBE_UNUSED(ID id), 2156 MAYBE_UNUSED(IC ic) 2157) 2158{ 2159 return insn_name(BIN(getinstancevariable)); 2160} 2161 2162/* attr rb_num_t open @ getinstancevariable(id, ic)()(val) */ 2163rb_num_t 2164attr_open_getinstancevariable( 2165 MAYBE_UNUSED(ID id), 2166 MAYBE_UNUSED(IC ic) 2167) 2168{ 2169 return 2; 2170} 2171 2172/* attr rb_num_t popn @ getinstancevariable(id, ic)()(val) */ 2173rb_num_t 2174attr_popn_getinstancevariable( 2175 MAYBE_UNUSED(ID id), 2176 MAYBE_UNUSED(IC ic) 2177) 2178{ 2179 return 0; 2180} 2181 2182/* attr rb_num_t retn @ getinstancevariable(id, ic)()(val) */ 2183rb_num_t 2184attr_retn_getinstancevariable( 2185 MAYBE_UNUSED(ID id), 2186 MAYBE_UNUSED(IC ic) 2187) 2188{ 2189 return 1; 2190} 2191 2192/* attr rb_snum_t sp_inc @ getinstancevariable(id, ic)()(val) */ 2193rb_snum_t 2194attr_sp_inc_getinstancevariable( 2195 MAYBE_UNUSED(ID id), 2196 MAYBE_UNUSED(IC ic) 2197) 2198{ 2199 return 1; 2200} 2201 2202/* attr rb_num_t width @ getinstancevariable(id, ic)()(val) */ 2203rb_num_t 2204attr_width_getinstancevariable( 2205 MAYBE_UNUSED(ID id), 2206 MAYBE_UNUSED(IC ic) 2207) 2208{ 2209 return 3; 2210} 2211 2212/* attr enum ruby_vminsn_type bin @ setinstancevariable(id, ic)(val)() */ 2213enum ruby_vminsn_type 2214attr_bin_setinstancevariable( 2215 MAYBE_UNUSED(ID id), 2216 MAYBE_UNUSED(IC ic) 2217) 2218{ 2219 return BIN(setinstancevariable); 2220} 2221 2222/* attr bool handles_sp @ setinstancevariable(id, ic)(val)() */ 2223bool 2224attr_handles_sp_setinstancevariable( 2225 MAYBE_UNUSED(ID id), 2226 MAYBE_UNUSED(IC ic) 2227) 2228{ 2229 return false; 2230} 2231 2232/* attr bool leaf @ setinstancevariable(id, ic)(val)() */ 2233bool 2234attr_leaf_setinstancevariable( 2235 MAYBE_UNUSED(ID id), 2236 MAYBE_UNUSED(IC ic) 2237) 2238{ 2239 return true; 2240} 2241 2242/* attr const char* name @ setinstancevariable(id, ic)(val)() */ 2243const char* 2244attr_name_setinstancevariable( 2245 MAYBE_UNUSED(ID id), 2246 MAYBE_UNUSED(IC ic) 2247) 2248{ 2249 return insn_name(BIN(setinstancevariable)); 2250} 2251 2252/* attr rb_num_t open @ setinstancevariable(id, ic)(val)() */ 2253rb_num_t 2254attr_open_setinstancevariable( 2255 MAYBE_UNUSED(ID id), 2256 MAYBE_UNUSED(IC ic) 2257) 2258{ 2259 return 2; 2260} 2261 2262/* attr rb_num_t popn @ setinstancevariable(id, ic)(val)() */ 2263rb_num_t 2264attr_popn_setinstancevariable( 2265 MAYBE_UNUSED(ID id), 2266 MAYBE_UNUSED(IC ic) 2267) 2268{ 2269 return 1; 2270} 2271 2272/* attr rb_num_t retn @ setinstancevariable(id, ic)(val)() */ 2273rb_num_t 2274attr_retn_setinstancevariable( 2275 MAYBE_UNUSED(ID id), 2276 MAYBE_UNUSED(IC ic) 2277) 2278{ 2279 return 0; 2280} 2281 2282/* attr rb_snum_t sp_inc @ setinstancevariable(id, ic)(val)() */ 2283rb_snum_t 2284attr_sp_inc_setinstancevariable( 2285 MAYBE_UNUSED(ID id), 2286 MAYBE_UNUSED(IC ic) 2287) 2288{ 2289 return -1; 2290} 2291 2292/* attr rb_num_t width @ setinstancevariable(id, ic)(val)() */ 2293rb_num_t 2294attr_width_setinstancevariable( 2295 MAYBE_UNUSED(ID id), 2296 MAYBE_UNUSED(IC ic) 2297) 2298{ 2299 return 3; 2300} 2301 2302/* attr enum ruby_vminsn_type bin @ getclassvariable(id)()(val) */ 2303enum ruby_vminsn_type 2304attr_bin_getclassvariable(MAYBE_UNUSED(ID id)) 2305{ 2306 return BIN(getclassvariable); 2307} 2308 2309/* attr bool handles_sp @ getclassvariable(id)()(val) */ 2310bool 2311attr_handles_sp_getclassvariable(MAYBE_UNUSED(ID id)) 2312{ 2313 return false; 2314} 2315 2316/* attr bool leaf @ getclassvariable(id)()(val) */ 2317bool 2318attr_leaf_getclassvariable(MAYBE_UNUSED(ID id)) 2319{ 2320 return 2321#line 234 "insns.def" 2322false; 2323#line 2324 "insns_info.inc" 2324} 2325 2326/* attr const char* name @ getclassvariable(id)()(val) */ 2327const char* 2328attr_name_getclassvariable(MAYBE_UNUSED(ID id)) 2329{ 2330 return insn_name(BIN(getclassvariable)); 2331} 2332 2333/* attr rb_num_t open @ getclassvariable(id)()(val) */ 2334rb_num_t 2335attr_open_getclassvariable(MAYBE_UNUSED(ID id)) 2336{ 2337 return 1; 2338} 2339 2340/* attr rb_num_t popn @ getclassvariable(id)()(val) */ 2341rb_num_t 2342attr_popn_getclassvariable(MAYBE_UNUSED(ID id)) 2343{ 2344 return 0; 2345} 2346 2347/* attr rb_num_t retn @ getclassvariable(id)()(val) */ 2348rb_num_t 2349attr_retn_getclassvariable(MAYBE_UNUSED(ID id)) 2350{ 2351 return 1; 2352} 2353 2354/* attr rb_snum_t sp_inc @ getclassvariable(id)()(val) */ 2355rb_snum_t 2356attr_sp_inc_getclassvariable(MAYBE_UNUSED(ID id)) 2357{ 2358 return 1; 2359} 2360 2361/* attr rb_num_t width @ getclassvariable(id)()(val) */ 2362rb_num_t 2363attr_width_getclassvariable(MAYBE_UNUSED(ID id)) 2364{ 2365 return 2; 2366} 2367 2368/* attr enum ruby_vminsn_type bin @ setclassvariable(id)(val)() */ 2369enum ruby_vminsn_type 2370attr_bin_setclassvariable(MAYBE_UNUSED(ID id)) 2371{ 2372 return BIN(setclassvariable); 2373} 2374 2375/* attr bool handles_sp @ setclassvariable(id)(val)() */ 2376bool 2377attr_handles_sp_setclassvariable(MAYBE_UNUSED(ID id)) 2378{ 2379 return false; 2380} 2381 2382/* attr bool leaf @ setclassvariable(id)(val)() */ 2383bool 2384attr_leaf_setclassvariable(MAYBE_UNUSED(ID id)) 2385{ 2386 return 2387#line 246 "insns.def" 2388false; 2389#line 2390 "insns_info.inc" 2390} 2391 2392/* attr const char* name @ setclassvariable(id)(val)() */ 2393const char* 2394attr_name_setclassvariable(MAYBE_UNUSED(ID id)) 2395{ 2396 return insn_name(BIN(setclassvariable)); 2397} 2398 2399/* attr rb_num_t open @ setclassvariable(id)(val)() */ 2400rb_num_t 2401attr_open_setclassvariable(MAYBE_UNUSED(ID id)) 2402{ 2403 return 1; 2404} 2405 2406/* attr rb_num_t popn @ setclassvariable(id)(val)() */ 2407rb_num_t 2408attr_popn_setclassvariable(MAYBE_UNUSED(ID id)) 2409{ 2410 return 1; 2411} 2412 2413/* attr rb_num_t retn @ setclassvariable(id)(val)() */ 2414rb_num_t 2415attr_retn_setclassvariable(MAYBE_UNUSED(ID id)) 2416{ 2417 return 0; 2418} 2419 2420/* attr rb_snum_t sp_inc @ setclassvariable(id)(val)() */ 2421rb_snum_t 2422attr_sp_inc_setclassvariable(MAYBE_UNUSED(ID id)) 2423{ 2424 return -1; 2425} 2426 2427/* attr rb_num_t width @ setclassvariable(id)(val)() */ 2428rb_num_t 2429attr_width_setclassvariable(MAYBE_UNUSED(ID id)) 2430{ 2431 return 2; 2432} 2433 2434/* attr enum ruby_vminsn_type bin @ getconstant(id)(klass)(val) */ 2435enum ruby_vminsn_type 2436attr_bin_getconstant(MAYBE_UNUSED(ID id)) 2437{ 2438 return BIN(getconstant); 2439} 2440 2441/* attr bool handles_sp @ getconstant(id)(klass)(val) */ 2442bool 2443attr_handles_sp_getconstant(MAYBE_UNUSED(ID id)) 2444{ 2445 return false; 2446} 2447 2448/* attr bool leaf @ getconstant(id)(klass)(val) */ 2449bool 2450attr_leaf_getconstant(MAYBE_UNUSED(ID id)) 2451{ 2452 return 2453#line 262 "insns.def" 2454false; 2455#line 2456 "insns_info.inc" 2456} 2457 2458/* attr const char* name @ getconstant(id)(klass)(val) */ 2459const char* 2460attr_name_getconstant(MAYBE_UNUSED(ID id)) 2461{ 2462 return insn_name(BIN(getconstant)); 2463} 2464 2465/* attr rb_num_t open @ getconstant(id)(klass)(val) */ 2466rb_num_t 2467attr_open_getconstant(MAYBE_UNUSED(ID id)) 2468{ 2469 return 1; 2470} 2471 2472/* attr rb_num_t popn @ getconstant(id)(klass)(val) */ 2473rb_num_t 2474attr_popn_getconstant(MAYBE_UNUSED(ID id)) 2475{ 2476 return 1; 2477} 2478 2479/* attr rb_num_t retn @ getconstant(id)(klass)(val) */ 2480rb_num_t 2481attr_retn_getconstant(MAYBE_UNUSED(ID id)) 2482{ 2483 return 1; 2484} 2485 2486/* attr rb_snum_t sp_inc @ getconstant(id)(klass)(val) */ 2487rb_snum_t 2488attr_sp_inc_getconstant(MAYBE_UNUSED(ID id)) 2489{ 2490 return 0; 2491} 2492 2493/* attr rb_num_t width @ getconstant(id)(klass)(val) */ 2494rb_num_t 2495attr_width_getconstant(MAYBE_UNUSED(ID id)) 2496{ 2497 return 2; 2498} 2499 2500/* attr enum ruby_vminsn_type bin @ setconstant(id)(val, cbase)() */ 2501enum ruby_vminsn_type 2502attr_bin_setconstant(MAYBE_UNUSED(ID id)) 2503{ 2504 return BIN(setconstant); 2505} 2506 2507/* attr bool handles_sp @ setconstant(id)(val, cbase)() */ 2508bool 2509attr_handles_sp_setconstant(MAYBE_UNUSED(ID id)) 2510{ 2511 return false; 2512} 2513 2514/* attr bool leaf @ setconstant(id)(val, cbase)() */ 2515bool 2516attr_leaf_setconstant(MAYBE_UNUSED(ID id)) 2517{ 2518 return 2519#line 278 "insns.def" 2520false; 2521#line 2522 "insns_info.inc" 2522} 2523 2524/* attr const char* name @ setconstant(id)(val, cbase)() */ 2525const char* 2526attr_name_setconstant(MAYBE_UNUSED(ID id)) 2527{ 2528 return insn_name(BIN(setconstant)); 2529} 2530 2531/* attr rb_num_t open @ setconstant(id)(val, cbase)() */ 2532rb_num_t 2533attr_open_setconstant(MAYBE_UNUSED(ID id)) 2534{ 2535 return 1; 2536} 2537 2538/* attr rb_num_t popn @ setconstant(id)(val, cbase)() */ 2539rb_num_t 2540attr_popn_setconstant(MAYBE_UNUSED(ID id)) 2541{ 2542 return 2; 2543} 2544 2545/* attr rb_num_t retn @ setconstant(id)(val, cbase)() */ 2546rb_num_t 2547attr_retn_setconstant(MAYBE_UNUSED(ID id)) 2548{ 2549 return 0; 2550} 2551 2552/* attr rb_snum_t sp_inc @ setconstant(id)(val, cbase)() */ 2553rb_snum_t 2554attr_sp_inc_setconstant(MAYBE_UNUSED(ID id)) 2555{ 2556 return -2; 2557} 2558 2559/* attr rb_num_t width @ setconstant(id)(val, cbase)() */ 2560rb_num_t 2561attr_width_setconstant(MAYBE_UNUSED(ID id)) 2562{ 2563 return 2; 2564} 2565 2566/* attr enum ruby_vminsn_type bin @ getglobal(entry)()(val) */ 2567enum ruby_vminsn_type 2568attr_bin_getglobal(MAYBE_UNUSED(GENTRY entry)) 2569{ 2570 return BIN(getglobal); 2571} 2572 2573/* attr bool handles_sp @ getglobal(entry)()(val) */ 2574bool 2575attr_handles_sp_getglobal(MAYBE_UNUSED(GENTRY entry)) 2576{ 2577 return false; 2578} 2579 2580/* attr bool leaf @ getglobal(entry)()(val) */ 2581bool 2582attr_leaf_getglobal(MAYBE_UNUSED(GENTRY entry)) 2583{ 2584 return 2585#line 291 "insns.def" 2586leafness_of_getglobal(entry); 2587#line 2588 "insns_info.inc" 2588} 2589 2590/* attr const char* name @ getglobal(entry)()(val) */ 2591const char* 2592attr_name_getglobal(MAYBE_UNUSED(GENTRY entry)) 2593{ 2594 return insn_name(BIN(getglobal)); 2595} 2596 2597/* attr rb_num_t open @ getglobal(entry)()(val) */ 2598rb_num_t 2599attr_open_getglobal(MAYBE_UNUSED(GENTRY entry)) 2600{ 2601 return 1; 2602} 2603 2604/* attr rb_num_t popn @ getglobal(entry)()(val) */ 2605rb_num_t 2606attr_popn_getglobal(MAYBE_UNUSED(GENTRY entry)) 2607{ 2608 return 0; 2609} 2610 2611/* attr rb_num_t retn @ getglobal(entry)()(val) */ 2612rb_num_t 2613attr_retn_getglobal(MAYBE_UNUSED(GENTRY entry)) 2614{ 2615 return 1; 2616} 2617 2618/* attr rb_snum_t sp_inc @ getglobal(entry)()(val) */ 2619rb_snum_t 2620attr_sp_inc_getglobal(MAYBE_UNUSED(GENTRY entry)) 2621{ 2622 return 1; 2623} 2624 2625/* attr rb_num_t width @ getglobal(entry)()(val) */ 2626rb_num_t 2627attr_width_getglobal(MAYBE_UNUSED(GENTRY entry)) 2628{ 2629 return 2; 2630} 2631 2632/* attr enum ruby_vminsn_type bin @ setglobal(entry)(val)() */ 2633enum ruby_vminsn_type 2634attr_bin_setglobal(MAYBE_UNUSED(GENTRY entry)) 2635{ 2636 return BIN(setglobal); 2637} 2638 2639/* attr bool handles_sp @ setglobal(entry)(val)() */ 2640bool 2641attr_handles_sp_setglobal(MAYBE_UNUSED(GENTRY entry)) 2642{ 2643 return false; 2644} 2645 2646/* attr bool leaf @ setglobal(entry)(val)() */ 2647bool 2648attr_leaf_setglobal(MAYBE_UNUSED(GENTRY entry)) 2649{ 2650 return 2651#line 302 "insns.def" 2652leafness_of_setglobal(entry); 2653#line 2654 "insns_info.inc" 2654} 2655 2656/* attr const char* name @ setglobal(entry)(val)() */ 2657const char* 2658attr_name_setglobal(MAYBE_UNUSED(GENTRY entry)) 2659{ 2660 return insn_name(BIN(setglobal)); 2661} 2662 2663/* attr rb_num_t open @ setglobal(entry)(val)() */ 2664rb_num_t 2665attr_open_setglobal(MAYBE_UNUSED(GENTRY entry)) 2666{ 2667 return 1; 2668} 2669 2670/* attr rb_num_t popn @ setglobal(entry)(val)() */ 2671rb_num_t 2672attr_popn_setglobal(MAYBE_UNUSED(GENTRY entry)) 2673{ 2674 return 1; 2675} 2676 2677/* attr rb_num_t retn @ setglobal(entry)(val)() */ 2678rb_num_t 2679attr_retn_setglobal(MAYBE_UNUSED(GENTRY entry)) 2680{ 2681 return 0; 2682} 2683 2684/* attr rb_snum_t sp_inc @ setglobal(entry)(val)() */ 2685rb_snum_t 2686attr_sp_inc_setglobal(MAYBE_UNUSED(GENTRY entry)) 2687{ 2688 return -1; 2689} 2690 2691/* attr rb_num_t width @ setglobal(entry)(val)() */ 2692rb_num_t 2693attr_width_setglobal(MAYBE_UNUSED(GENTRY entry)) 2694{ 2695 return 2; 2696} 2697 2698/* attr enum ruby_vminsn_type bin @ putnil()()(val) */ 2699enum ruby_vminsn_type 2700attr_bin_putnil(void) 2701{ 2702 return BIN(putnil); 2703} 2704 2705/* attr bool handles_sp @ putnil()()(val) */ 2706bool 2707attr_handles_sp_putnil(void) 2708{ 2709 return false; 2710} 2711 2712/* attr bool leaf @ putnil()()(val) */ 2713bool 2714attr_leaf_putnil(void) 2715{ 2716 return true; 2717} 2718 2719/* attr const char* name @ putnil()()(val) */ 2720const char* 2721attr_name_putnil(void) 2722{ 2723 return insn_name(BIN(putnil)); 2724} 2725 2726/* attr rb_num_t open @ putnil()()(val) */ 2727rb_num_t 2728attr_open_putnil(void) 2729{ 2730 return 0; 2731} 2732 2733/* attr rb_num_t popn @ putnil()()(val) */ 2734rb_num_t 2735attr_popn_putnil(void) 2736{ 2737 return 0; 2738} 2739 2740/* attr rb_num_t retn @ putnil()()(val) */ 2741rb_num_t 2742attr_retn_putnil(void) 2743{ 2744 return 1; 2745} 2746 2747/* attr rb_snum_t sp_inc @ putnil()()(val) */ 2748rb_snum_t 2749attr_sp_inc_putnil(void) 2750{ 2751 return 1; 2752} 2753 2754/* attr rb_num_t width @ putnil()()(val) */ 2755rb_num_t 2756attr_width_putnil(void) 2757{ 2758 return 1; 2759} 2760 2761/* attr enum ruby_vminsn_type bin @ putself()()(val) */ 2762enum ruby_vminsn_type 2763attr_bin_putself(void) 2764{ 2765 return BIN(putself); 2766} 2767 2768/* attr bool handles_sp @ putself()()(val) */ 2769bool 2770attr_handles_sp_putself(void) 2771{ 2772 return false; 2773} 2774 2775/* attr bool leaf @ putself()()(val) */ 2776bool 2777attr_leaf_putself(void) 2778{ 2779 return true; 2780} 2781 2782/* attr const char* name @ putself()()(val) */ 2783const char* 2784attr_name_putself(void) 2785{ 2786 return insn_name(BIN(putself)); 2787} 2788 2789/* attr rb_num_t open @ putself()()(val) */ 2790rb_num_t 2791attr_open_putself(void) 2792{ 2793 return 0; 2794} 2795 2796/* attr rb_num_t popn @ putself()()(val) */ 2797rb_num_t 2798attr_popn_putself(void) 2799{ 2800 return 0; 2801} 2802 2803/* attr rb_num_t retn @ putself()()(val) */ 2804rb_num_t 2805attr_retn_putself(void) 2806{ 2807 return 1; 2808} 2809 2810/* attr rb_snum_t sp_inc @ putself()()(val) */ 2811rb_snum_t 2812attr_sp_inc_putself(void) 2813{ 2814 return 1; 2815} 2816 2817/* attr rb_num_t width @ putself()()(val) */ 2818rb_num_t 2819attr_width_putself(void) 2820{ 2821 return 1; 2822} 2823 2824/* attr enum ruby_vminsn_type bin @ putobject(val)()(val) */ 2825enum ruby_vminsn_type 2826attr_bin_putobject(MAYBE_UNUSED(VALUE val)) 2827{ 2828 return BIN(putobject); 2829} 2830 2831/* attr bool handles_sp @ putobject(val)()(val) */ 2832bool 2833attr_handles_sp_putobject(MAYBE_UNUSED(VALUE val)) 2834{ 2835 return false; 2836} 2837 2838/* attr bool leaf @ putobject(val)()(val) */ 2839bool 2840attr_leaf_putobject(MAYBE_UNUSED(VALUE val)) 2841{ 2842 return true; 2843} 2844 2845/* attr const char* name @ putobject(val)()(val) */ 2846const char* 2847attr_name_putobject(MAYBE_UNUSED(VALUE val)) 2848{ 2849 return insn_name(BIN(putobject)); 2850} 2851 2852/* attr rb_num_t open @ putobject(val)()(val) */ 2853rb_num_t 2854attr_open_putobject(MAYBE_UNUSED(VALUE val)) 2855{ 2856 return 1; 2857} 2858 2859/* attr rb_num_t popn @ putobject(val)()(val) */ 2860rb_num_t 2861attr_popn_putobject(MAYBE_UNUSED(VALUE val)) 2862{ 2863 return 0; 2864} 2865 2866/* attr rb_num_t retn @ putobject(val)()(val) */ 2867rb_num_t 2868attr_retn_putobject(MAYBE_UNUSED(VALUE val)) 2869{ 2870 return 1; 2871} 2872 2873/* attr rb_snum_t sp_inc @ putobject(val)()(val) */ 2874rb_snum_t 2875attr_sp_inc_putobject(MAYBE_UNUSED(VALUE val)) 2876{ 2877 return 1; 2878} 2879 2880/* attr rb_num_t width @ putobject(val)()(val) */ 2881rb_num_t 2882attr_width_putobject(MAYBE_UNUSED(VALUE val)) 2883{ 2884 return 2; 2885} 2886 2887/* attr enum ruby_vminsn_type bin @ putspecialobject(value_type)()(val) */ 2888enum ruby_vminsn_type 2889attr_bin_putspecialobject(MAYBE_UNUSED(rb_num_t value_type)) 2890{ 2891 return BIN(putspecialobject); 2892} 2893 2894/* attr bool handles_sp @ putspecialobject(value_type)()(val) */ 2895bool 2896attr_handles_sp_putspecialobject(MAYBE_UNUSED(rb_num_t value_type)) 2897{ 2898 return false; 2899} 2900 2901/* attr bool leaf @ putspecialobject(value_type)()(val) */ 2902bool 2903attr_leaf_putspecialobject(MAYBE_UNUSED(rb_num_t value_type)) 2904{ 2905 return true; 2906} 2907 2908/* attr const char* name @ putspecialobject(value_type)()(val) */ 2909const char* 2910attr_name_putspecialobject(MAYBE_UNUSED(rb_num_t value_type)) 2911{ 2912 return insn_name(BIN(putspecialobject)); 2913} 2914 2915/* attr rb_num_t open @ putspecialobject(value_type)()(val) */ 2916rb_num_t 2917attr_open_putspecialobject(MAYBE_UNUSED(rb_num_t value_type)) 2918{ 2919 return 1; 2920} 2921 2922/* attr rb_num_t popn @ putspecialobject(value_type)()(val) */ 2923rb_num_t 2924attr_popn_putspecialobject(MAYBE_UNUSED(rb_num_t value_type)) 2925{ 2926 return 0; 2927} 2928 2929/* attr rb_num_t retn @ putspecialobject(value_type)()(val) */ 2930rb_num_t 2931attr_retn_putspecialobject(MAYBE_UNUSED(rb_num_t value_type)) 2932{ 2933 return 1; 2934} 2935 2936/* attr rb_snum_t sp_inc @ putspecialobject(value_type)()(val) */ 2937rb_snum_t 2938attr_sp_inc_putspecialobject(MAYBE_UNUSED(rb_num_t value_type)) 2939{ 2940 return 1; 2941} 2942 2943/* attr rb_num_t width @ putspecialobject(value_type)()(val) */ 2944rb_num_t 2945attr_width_putspecialobject(MAYBE_UNUSED(rb_num_t value_type)) 2946{ 2947 return 2; 2948} 2949 2950/* attr enum ruby_vminsn_type bin @ putiseq(iseq)()(ret) */ 2951enum ruby_vminsn_type 2952attr_bin_putiseq(MAYBE_UNUSED(ISEQ iseq)) 2953{ 2954 return BIN(putiseq); 2955} 2956 2957/* attr bool handles_sp @ putiseq(iseq)()(ret) */ 2958bool 2959attr_handles_sp_putiseq(MAYBE_UNUSED(ISEQ iseq)) 2960{ 2961 return 2962#line 362 "insns.def" 2963false; 2964#line 2965 "insns_info.inc" 2965} 2966 2967/* attr bool leaf @ putiseq(iseq)()(ret) */ 2968bool 2969attr_leaf_putiseq(MAYBE_UNUSED(ISEQ iseq)) 2970{ 2971 return true; 2972} 2973 2974/* attr const char* name @ putiseq(iseq)()(ret) */ 2975const char* 2976attr_name_putiseq(MAYBE_UNUSED(ISEQ iseq)) 2977{ 2978 return insn_name(BIN(putiseq)); 2979} 2980 2981/* attr rb_num_t open @ putiseq(iseq)()(ret) */ 2982rb_num_t 2983attr_open_putiseq(MAYBE_UNUSED(ISEQ iseq)) 2984{ 2985 return 1; 2986} 2987 2988/* attr rb_num_t popn @ putiseq(iseq)()(ret) */ 2989rb_num_t 2990attr_popn_putiseq(MAYBE_UNUSED(ISEQ iseq)) 2991{ 2992 return 0; 2993} 2994 2995/* attr rb_num_t retn @ putiseq(iseq)()(ret) */ 2996rb_num_t 2997attr_retn_putiseq(MAYBE_UNUSED(ISEQ iseq)) 2998{ 2999 return 1; 3000} 3001 3002/* attr rb_snum_t sp_inc @ putiseq(iseq)()(ret) */ 3003rb_snum_t 3004attr_sp_inc_putiseq(MAYBE_UNUSED(ISEQ iseq)) 3005{ 3006 return 1; 3007} 3008 3009/* attr rb_num_t width @ putiseq(iseq)()(ret) */ 3010rb_num_t 3011attr_width_putiseq(MAYBE_UNUSED(ISEQ iseq)) 3012{ 3013 return 2; 3014} 3015 3016/* attr enum ruby_vminsn_type bin @ putstring(str)()(val) */ 3017enum ruby_vminsn_type 3018attr_bin_putstring(MAYBE_UNUSED(VALUE str)) 3019{ 3020 return BIN(putstring); 3021} 3022 3023/* attr bool handles_sp @ putstring(str)()(val) */ 3024bool 3025attr_handles_sp_putstring(MAYBE_UNUSED(VALUE str)) 3026{ 3027 return false; 3028} 3029 3030/* attr bool leaf @ putstring(str)()(val) */ 3031bool 3032attr_leaf_putstring(MAYBE_UNUSED(VALUE str)) 3033{ 3034 return true; 3035} 3036 3037/* attr const char* name @ putstring(str)()(val) */ 3038const char* 3039attr_name_putstring(MAYBE_UNUSED(VALUE str)) 3040{ 3041 return insn_name(BIN(putstring)); 3042} 3043 3044/* attr rb_num_t open @ putstring(str)()(val) */ 3045rb_num_t 3046attr_open_putstring(MAYBE_UNUSED(VALUE str)) 3047{ 3048 return 1; 3049} 3050 3051/* attr rb_num_t popn @ putstring(str)()(val) */ 3052rb_num_t 3053attr_popn_putstring(MAYBE_UNUSED(VALUE str)) 3054{ 3055 return 0; 3056} 3057 3058/* attr rb_num_t retn @ putstring(str)()(val) */ 3059rb_num_t 3060attr_retn_putstring(MAYBE_UNUSED(VALUE str)) 3061{ 3062 return 1; 3063} 3064 3065/* attr rb_snum_t sp_inc @ putstring(str)()(val) */ 3066rb_snum_t 3067attr_sp_inc_putstring(MAYBE_UNUSED(VALUE str)) 3068{ 3069 return 1; 3070} 3071 3072/* attr rb_num_t width @ putstring(str)()(val) */ 3073rb_num_t 3074attr_width_putstring(MAYBE_UNUSED(VALUE str)) 3075{ 3076 return 2; 3077} 3078 3079/* attr enum ruby_vminsn_type bin @ concatstrings(num)(...)(val) */ 3080enum ruby_vminsn_type 3081attr_bin_concatstrings(MAYBE_UNUSED(rb_num_t num)) 3082{ 3083 return BIN(concatstrings); 3084} 3085 3086/* attr bool handles_sp @ concatstrings(num)(...)(val) */ 3087bool 3088attr_handles_sp_concatstrings(MAYBE_UNUSED(rb_num_t num)) 3089{ 3090 return false; 3091} 3092 3093/* attr bool leaf @ concatstrings(num)(...)(val) */ 3094bool 3095attr_leaf_concatstrings(MAYBE_UNUSED(rb_num_t num)) 3096{ 3097 return true; 3098} 3099 3100/* attr const char* name @ concatstrings(num)(...)(val) */ 3101const char* 3102attr_name_concatstrings(MAYBE_UNUSED(rb_num_t num)) 3103{ 3104 return insn_name(BIN(concatstrings)); 3105} 3106 3107/* attr rb_num_t open @ concatstrings(num)(...)(val) */ 3108rb_num_t 3109attr_open_concatstrings(MAYBE_UNUSED(rb_num_t num)) 3110{ 3111 return 1; 3112} 3113 3114/* attr rb_num_t popn @ concatstrings(num)(...)(val) */ 3115rb_num_t 3116attr_popn_concatstrings(MAYBE_UNUSED(rb_num_t num)) 3117{ 3118 return 0; 3119} 3120 3121/* attr rb_num_t retn @ concatstrings(num)(...)(val) */ 3122rb_num_t 3123attr_retn_concatstrings(MAYBE_UNUSED(rb_num_t num)) 3124{ 3125 return 1; 3126} 3127 3128/* attr rb_snum_t sp_inc @ concatstrings(num)(...)(val) */ 3129rb_snum_t 3130attr_sp_inc_concatstrings(MAYBE_UNUSED(rb_num_t num)) 3131{ 3132 return 3133#line 383 "insns.def" 31341 - (rb_snum_t)num; 3135#line 3136 "insns_info.inc" 3136} 3137 3138/* attr rb_num_t width @ concatstrings(num)(...)(val) */ 3139rb_num_t 3140attr_width_concatstrings(MAYBE_UNUSED(rb_num_t num)) 3141{ 3142 return 2; 3143} 3144 3145/* attr enum ruby_vminsn_type bin @ tostring()(val, str)(val) */ 3146enum ruby_vminsn_type 3147attr_bin_tostring(void) 3148{ 3149 return BIN(tostring); 3150} 3151 3152/* attr bool handles_sp @ tostring()(val, str)(val) */ 3153bool 3154attr_handles_sp_tostring(void) 3155{ 3156 return false; 3157} 3158 3159/* attr bool leaf @ tostring()(val, str)(val) */ 3160bool 3161attr_leaf_tostring(void) 3162{ 3163 return true; 3164} 3165 3166/* attr const char* name @ tostring()(val, str)(val) */ 3167const char* 3168attr_name_tostring(void) 3169{ 3170 return insn_name(BIN(tostring)); 3171} 3172 3173/* attr rb_num_t open @ tostring()(val, str)(val) */ 3174rb_num_t 3175attr_open_tostring(void) 3176{ 3177 return 0; 3178} 3179 3180/* attr rb_num_t popn @ tostring()(val, str)(val) */ 3181rb_num_t 3182attr_popn_tostring(void) 3183{ 3184 return 2; 3185} 3186 3187/* attr rb_num_t retn @ tostring()(val, str)(val) */ 3188rb_num_t 3189attr_retn_tostring(void) 3190{ 3191 return 1; 3192} 3193 3194/* attr rb_snum_t sp_inc @ tostring()(val, str)(val) */ 3195rb_snum_t 3196attr_sp_inc_tostring(void) 3197{ 3198 return -1; 3199} 3200 3201/* attr rb_num_t width @ tostring()(val, str)(val) */ 3202rb_num_t 3203attr_width_tostring(void) 3204{ 3205 return 1; 3206} 3207 3208/* attr enum ruby_vminsn_type bin @ freezestring(debug_info)(str)(str) */ 3209enum ruby_vminsn_type 3210attr_bin_freezestring(MAYBE_UNUSED(VALUE debug_info)) 3211{ 3212 return BIN(freezestring); 3213} 3214 3215/* attr bool handles_sp @ freezestring(debug_info)(str)(str) */ 3216bool 3217attr_handles_sp_freezestring(MAYBE_UNUSED(VALUE debug_info)) 3218{ 3219 return false; 3220} 3221 3222/* attr bool leaf @ freezestring(debug_info)(str)(str) */ 3223bool 3224attr_leaf_freezestring(MAYBE_UNUSED(VALUE debug_info)) 3225{ 3226 return true; 3227} 3228 3229/* attr const char* name @ freezestring(debug_info)(str)(str) */ 3230const char* 3231attr_name_freezestring(MAYBE_UNUSED(VALUE debug_info)) 3232{ 3233 return insn_name(BIN(freezestring)); 3234} 3235 3236/* attr rb_num_t open @ freezestring(debug_info)(str)(str) */ 3237rb_num_t 3238attr_open_freezestring(MAYBE_UNUSED(VALUE debug_info)) 3239{ 3240 return 1; 3241} 3242 3243/* attr rb_num_t popn @ freezestring(debug_info)(str)(str) */ 3244rb_num_t 3245attr_popn_freezestring(MAYBE_UNUSED(VALUE debug_info)) 3246{ 3247 return 1; 3248} 3249 3250/* attr rb_num_t retn @ freezestring(debug_info)(str)(str) */ 3251rb_num_t 3252attr_retn_freezestring(MAYBE_UNUSED(VALUE debug_info)) 3253{ 3254 return 1; 3255} 3256 3257/* attr rb_snum_t sp_inc @ freezestring(debug_info)(str)(str) */ 3258rb_snum_t 3259attr_sp_inc_freezestring(MAYBE_UNUSED(VALUE debug_info)) 3260{ 3261 return 0; 3262} 3263 3264/* attr rb_num_t width @ freezestring(debug_info)(str)(str) */ 3265rb_num_t 3266attr_width_freezestring(MAYBE_UNUSED(VALUE debug_info)) 3267{ 3268 return 2; 3269} 3270 3271/* attr enum ruby_vminsn_type bin @ toregexp(opt, cnt)(...)(val) */ 3272enum ruby_vminsn_type 3273attr_bin_toregexp( 3274 MAYBE_UNUSED(rb_num_t opt), 3275 MAYBE_UNUSED(rb_num_t cnt) 3276) 3277{ 3278 return BIN(toregexp); 3279} 3280 3281/* attr bool handles_sp @ toregexp(opt, cnt)(...)(val) */ 3282bool 3283attr_handles_sp_toregexp( 3284 MAYBE_UNUSED(rb_num_t opt), 3285 MAYBE_UNUSED(rb_num_t cnt) 3286) 3287{ 3288 return false; 3289} 3290 3291/* attr bool leaf @ toregexp(opt, cnt)(...)(val) */ 3292bool 3293attr_leaf_toregexp( 3294 MAYBE_UNUSED(rb_num_t opt), 3295 MAYBE_UNUSED(rb_num_t cnt) 3296) 3297{ 3298 return 3299#line 418 "insns.def" 3300true; 3301#line 3302 "insns_info.inc" 3302} 3303 3304/* attr const char* name @ toregexp(opt, cnt)(...)(val) */ 3305const char* 3306attr_name_toregexp( 3307 MAYBE_UNUSED(rb_num_t opt), 3308 MAYBE_UNUSED(rb_num_t cnt) 3309) 3310{ 3311 return insn_name(BIN(toregexp)); 3312} 3313 3314/* attr rb_num_t open @ toregexp(opt, cnt)(...)(val) */ 3315rb_num_t 3316attr_open_toregexp( 3317 MAYBE_UNUSED(rb_num_t opt), 3318 MAYBE_UNUSED(rb_num_t cnt) 3319) 3320{ 3321 return 2; 3322} 3323 3324/* attr rb_num_t popn @ toregexp(opt, cnt)(...)(val) */ 3325rb_num_t 3326attr_popn_toregexp( 3327 MAYBE_UNUSED(rb_num_t opt), 3328 MAYBE_UNUSED(rb_num_t cnt) 3329) 3330{ 3331 return 0; 3332} 3333 3334/* attr rb_num_t retn @ toregexp(opt, cnt)(...)(val) */ 3335rb_num_t 3336attr_retn_toregexp( 3337 MAYBE_UNUSED(rb_num_t opt), 3338 MAYBE_UNUSED(rb_num_t cnt) 3339) 3340{ 3341 return 1; 3342} 3343 3344/* attr rb_snum_t sp_inc @ toregexp(opt, cnt)(...)(val) */ 3345rb_snum_t 3346attr_sp_inc_toregexp( 3347 MAYBE_UNUSED(rb_num_t opt), 3348 MAYBE_UNUSED(rb_num_t cnt) 3349) 3350{ 3351 return 3352#line 419 "insns.def" 33531 - (rb_snum_t)cnt; 3354#line 3355 "insns_info.inc" 3355} 3356 3357/* attr rb_num_t width @ toregexp(opt, cnt)(...)(val) */ 3358rb_num_t 3359attr_width_toregexp( 3360 MAYBE_UNUSED(rb_num_t opt), 3361 MAYBE_UNUSED(rb_num_t cnt) 3362) 3363{ 3364 return 3; 3365} 3366 3367/* attr enum ruby_vminsn_type bin @ intern()(str)(sym) */ 3368enum ruby_vminsn_type 3369attr_bin_intern(void) 3370{ 3371 return BIN(intern); 3372} 3373 3374/* attr bool handles_sp @ intern()(str)(sym) */ 3375bool 3376attr_handles_sp_intern(void) 3377{ 3378 return false; 3379} 3380 3381/* attr bool leaf @ intern()(str)(sym) */ 3382bool 3383attr_leaf_intern(void) 3384{ 3385 return true; 3386} 3387 3388/* attr const char* name @ intern()(str)(sym) */ 3389const char* 3390attr_name_intern(void) 3391{ 3392 return insn_name(BIN(intern)); 3393} 3394 3395/* attr rb_num_t open @ intern()(str)(sym) */ 3396rb_num_t 3397attr_open_intern(void) 3398{ 3399 return 0; 3400} 3401 3402/* attr rb_num_t popn @ intern()(str)(sym) */ 3403rb_num_t 3404attr_popn_intern(void) 3405{ 3406 return 1; 3407} 3408 3409/* attr rb_num_t retn @ intern()(str)(sym) */ 3410rb_num_t 3411attr_retn_intern(void) 3412{ 3413 return 1; 3414} 3415 3416/* attr rb_snum_t sp_inc @ intern()(str)(sym) */ 3417rb_snum_t 3418attr_sp_inc_intern(void) 3419{ 3420 return 0; 3421} 3422 3423/* attr rb_num_t width @ intern()(str)(sym) */ 3424rb_num_t 3425attr_width_intern(void) 3426{ 3427 return 1; 3428} 3429 3430/* attr enum ruby_vminsn_type bin @ newarray(num)(...)(val) */ 3431enum ruby_vminsn_type 3432attr_bin_newarray(MAYBE_UNUSED(rb_num_t num)) 3433{ 3434 return BIN(newarray); 3435} 3436 3437/* attr bool handles_sp @ newarray(num)(...)(val) */ 3438bool 3439attr_handles_sp_newarray(MAYBE_UNUSED(rb_num_t num)) 3440{ 3441 return false; 3442} 3443 3444/* attr bool leaf @ newarray(num)(...)(val) */ 3445bool 3446attr_leaf_newarray(MAYBE_UNUSED(rb_num_t num)) 3447{ 3448 return true; 3449} 3450 3451/* attr const char* name @ newarray(num)(...)(val) */ 3452const char* 3453attr_name_newarray(MAYBE_UNUSED(rb_num_t num)) 3454{ 3455 return insn_name(BIN(newarray)); 3456} 3457 3458/* attr rb_num_t open @ newarray(num)(...)(val) */ 3459rb_num_t 3460attr_open_newarray(MAYBE_UNUSED(rb_num_t num)) 3461{ 3462 return 1; 3463} 3464 3465/* attr rb_num_t popn @ newarray(num)(...)(val) */ 3466rb_num_t 3467attr_popn_newarray(MAYBE_UNUSED(rb_num_t num)) 3468{ 3469 return 0; 3470} 3471 3472/* attr rb_num_t retn @ newarray(num)(...)(val) */ 3473rb_num_t 3474attr_retn_newarray(MAYBE_UNUSED(rb_num_t num)) 3475{ 3476 return 1; 3477} 3478 3479/* attr rb_snum_t sp_inc @ newarray(num)(...)(val) */ 3480rb_snum_t 3481attr_sp_inc_newarray(MAYBE_UNUSED(rb_num_t num)) 3482{ 3483 return 3484#line 442 "insns.def" 34851 - (rb_snum_t)num; 3486#line 3487 "insns_info.inc" 3487} 3488 3489/* attr rb_num_t width @ newarray(num)(...)(val) */ 3490rb_num_t 3491attr_width_newarray(MAYBE_UNUSED(rb_num_t num)) 3492{ 3493 return 2; 3494} 3495 3496/* attr enum ruby_vminsn_type bin @ duparray(ary)()(val) */ 3497enum ruby_vminsn_type 3498attr_bin_duparray(MAYBE_UNUSED(VALUE ary)) 3499{ 3500 return BIN(duparray); 3501} 3502 3503/* attr bool handles_sp @ duparray(ary)()(val) */ 3504bool 3505attr_handles_sp_duparray(MAYBE_UNUSED(VALUE ary)) 3506{ 3507 return false; 3508} 3509 3510/* attr bool leaf @ duparray(ary)()(val) */ 3511bool 3512attr_leaf_duparray(MAYBE_UNUSED(VALUE ary)) 3513{ 3514 return true; 3515} 3516 3517/* attr const char* name @ duparray(ary)()(val) */ 3518const char* 3519attr_name_duparray(MAYBE_UNUSED(VALUE ary)) 3520{ 3521 return insn_name(BIN(duparray)); 3522} 3523 3524/* attr rb_num_t open @ duparray(ary)()(val) */ 3525rb_num_t 3526attr_open_duparray(MAYBE_UNUSED(VALUE ary)) 3527{ 3528 return 1; 3529} 3530 3531/* attr rb_num_t popn @ duparray(ary)()(val) */ 3532rb_num_t 3533attr_popn_duparray(MAYBE_UNUSED(VALUE ary)) 3534{ 3535 return 0; 3536} 3537 3538/* attr rb_num_t retn @ duparray(ary)()(val) */ 3539rb_num_t 3540attr_retn_duparray(MAYBE_UNUSED(VALUE ary)) 3541{ 3542 return 1; 3543} 3544 3545/* attr rb_snum_t sp_inc @ duparray(ary)()(val) */ 3546rb_snum_t 3547attr_sp_inc_duparray(MAYBE_UNUSED(VALUE ary)) 3548{ 3549 return 1; 3550} 3551 3552/* attr rb_num_t width @ duparray(ary)()(val) */ 3553rb_num_t 3554attr_width_duparray(MAYBE_UNUSED(VALUE ary)) 3555{ 3556 return 2; 3557} 3558 3559/* attr enum ruby_vminsn_type bin @ duphash(hash)()(val) */ 3560enum ruby_vminsn_type 3561attr_bin_duphash(MAYBE_UNUSED(VALUE hash)) 3562{ 3563 return BIN(duphash); 3564} 3565 3566/* attr bool handles_sp @ duphash(hash)()(val) */ 3567bool 3568attr_handles_sp_duphash(MAYBE_UNUSED(VALUE hash)) 3569{ 3570 return false; 3571} 3572 3573/* attr bool leaf @ duphash(hash)()(val) */ 3574bool 3575attr_leaf_duphash(MAYBE_UNUSED(VALUE hash)) 3576{ 3577 return true; 3578} 3579 3580/* attr const char* name @ duphash(hash)()(val) */ 3581const char* 3582attr_name_duphash(MAYBE_UNUSED(VALUE hash)) 3583{ 3584 return insn_name(BIN(duphash)); 3585} 3586 3587/* attr rb_num_t open @ duphash(hash)()(val) */ 3588rb_num_t 3589attr_open_duphash(MAYBE_UNUSED(VALUE hash)) 3590{ 3591 return 1; 3592} 3593 3594/* attr rb_num_t popn @ duphash(hash)()(val) */ 3595rb_num_t 3596attr_popn_duphash(MAYBE_UNUSED(VALUE hash)) 3597{ 3598 return 0; 3599} 3600 3601/* attr rb_num_t retn @ duphash(hash)()(val) */ 3602rb_num_t 3603attr_retn_duphash(MAYBE_UNUSED(VALUE hash)) 3604{ 3605 return 1; 3606} 3607 3608/* attr rb_snum_t sp_inc @ duphash(hash)()(val) */ 3609rb_snum_t 3610attr_sp_inc_duphash(MAYBE_UNUSED(VALUE hash)) 3611{ 3612 return 1; 3613} 3614 3615/* attr rb_num_t width @ duphash(hash)()(val) */ 3616rb_num_t 3617attr_width_duphash(MAYBE_UNUSED(VALUE hash)) 3618{ 3619 return 2; 3620} 3621 3622/* attr enum ruby_vminsn_type bin @ expandarray(num, flag)(..., ary)(...) */ 3623enum ruby_vminsn_type 3624attr_bin_expandarray( 3625 MAYBE_UNUSED(rb_num_t num), 3626 MAYBE_UNUSED(rb_num_t flag) 3627) 3628{ 3629 return BIN(expandarray); 3630} 3631 3632/* attr bool handles_sp @ expandarray(num, flag)(..., ary)(...) */ 3633bool 3634attr_handles_sp_expandarray( 3635 MAYBE_UNUSED(rb_num_t num), 3636 MAYBE_UNUSED(rb_num_t flag) 3637) 3638{ 3639 return false; 3640} 3641 3642/* attr bool leaf @ expandarray(num, flag)(..., ary)(...) */ 3643bool 3644attr_leaf_expandarray( 3645 MAYBE_UNUSED(rb_num_t num), 3646 MAYBE_UNUSED(rb_num_t flag) 3647) 3648{ 3649 return 3650#line 483 "insns.def" 3651false; 3652#line 3653 "insns_info.inc" 3653} 3654 3655/* attr const char* name @ expandarray(num, flag)(..., ary)(...) */ 3656const char* 3657attr_name_expandarray( 3658 MAYBE_UNUSED(rb_num_t num), 3659 MAYBE_UNUSED(rb_num_t flag) 3660) 3661{ 3662 return insn_name(BIN(expandarray)); 3663} 3664 3665/* attr rb_num_t open @ expandarray(num, flag)(..., ary)(...) */ 3666rb_num_t 3667attr_open_expandarray( 3668 MAYBE_UNUSED(rb_num_t num), 3669 MAYBE_UNUSED(rb_num_t flag) 3670) 3671{ 3672 return 2; 3673} 3674 3675/* attr rb_num_t popn @ expandarray(num, flag)(..., ary)(...) */ 3676rb_num_t 3677attr_popn_expandarray( 3678 MAYBE_UNUSED(rb_num_t num), 3679 MAYBE_UNUSED(rb_num_t flag) 3680) 3681{ 3682 return 1; 3683} 3684 3685/* attr rb_num_t retn @ expandarray(num, flag)(..., ary)(...) */ 3686rb_num_t 3687attr_retn_expandarray( 3688 MAYBE_UNUSED(rb_num_t num), 3689 MAYBE_UNUSED(rb_num_t flag) 3690) 3691{ 3692 return 0; 3693} 3694 3695/* attr rb_snum_t sp_inc @ expandarray(num, flag)(..., ary)(...) */ 3696rb_snum_t 3697attr_sp_inc_expandarray( 3698 MAYBE_UNUSED(rb_num_t num), 3699 MAYBE_UNUSED(rb_num_t flag) 3700) 3701{ 3702 return 3703#line 484 "insns.def" 3704(rb_snum_t)num - 1 + (flag & 1 ? 1 : 0); 3705#line 3706 "insns_info.inc" 3706} 3707 3708/* attr rb_num_t width @ expandarray(num, flag)(..., ary)(...) */ 3709rb_num_t 3710attr_width_expandarray( 3711 MAYBE_UNUSED(rb_num_t num), 3712 MAYBE_UNUSED(rb_num_t flag) 3713) 3714{ 3715 return 3; 3716} 3717 3718/* attr enum ruby_vminsn_type bin @ concatarray()(ary1, ary2)(ary) */ 3719enum ruby_vminsn_type 3720attr_bin_concatarray(void) 3721{ 3722 return BIN(concatarray); 3723} 3724 3725/* attr bool handles_sp @ concatarray()(ary1, ary2)(ary) */ 3726bool 3727attr_handles_sp_concatarray(void) 3728{ 3729 return false; 3730} 3731 3732/* attr bool leaf @ concatarray()(ary1, ary2)(ary) */ 3733bool 3734attr_leaf_concatarray(void) 3735{ 3736 return 3737#line 495 "insns.def" 3738false; 3739#line 3740 "insns_info.inc" 3740} 3741 3742/* attr const char* name @ concatarray()(ary1, ary2)(ary) */ 3743const char* 3744attr_name_concatarray(void) 3745{ 3746 return insn_name(BIN(concatarray)); 3747} 3748 3749/* attr rb_num_t open @ concatarray()(ary1, ary2)(ary) */ 3750rb_num_t 3751attr_open_concatarray(void) 3752{ 3753 return 0; 3754} 3755 3756/* attr rb_num_t popn @ concatarray()(ary1, ary2)(ary) */ 3757rb_num_t 3758attr_popn_concatarray(void) 3759{ 3760 return 2; 3761} 3762 3763/* attr rb_num_t retn @ concatarray()(ary1, ary2)(ary) */ 3764rb_num_t 3765attr_retn_concatarray(void) 3766{ 3767 return 1; 3768} 3769 3770/* attr rb_snum_t sp_inc @ concatarray()(ary1, ary2)(ary) */ 3771rb_snum_t 3772attr_sp_inc_concatarray(void) 3773{ 3774 return -1; 3775} 3776 3777/* attr rb_num_t width @ concatarray()(ary1, ary2)(ary) */ 3778rb_num_t 3779attr_width_concatarray(void) 3780{ 3781 return 1; 3782} 3783 3784/* attr enum ruby_vminsn_type bin @ splatarray(flag)(ary)(obj) */ 3785enum ruby_vminsn_type 3786attr_bin_splatarray(MAYBE_UNUSED(VALUE flag)) 3787{ 3788 return BIN(splatarray); 3789} 3790 3791/* attr bool handles_sp @ splatarray(flag)(ary)(obj) */ 3792bool 3793attr_handles_sp_splatarray(MAYBE_UNUSED(VALUE flag)) 3794{ 3795 return false; 3796} 3797 3798/* attr bool leaf @ splatarray(flag)(ary)(obj) */ 3799bool 3800attr_leaf_splatarray(MAYBE_UNUSED(VALUE flag)) 3801{ 3802 return 3803#line 506 "insns.def" 3804false; 3805#line 3806 "insns_info.inc" 3806} 3807 3808/* attr const char* name @ splatarray(flag)(ary)(obj) */ 3809const char* 3810attr_name_splatarray(MAYBE_UNUSED(VALUE flag)) 3811{ 3812 return insn_name(BIN(splatarray)); 3813} 3814 3815/* attr rb_num_t open @ splatarray(flag)(ary)(obj) */ 3816rb_num_t 3817attr_open_splatarray(MAYBE_UNUSED(VALUE flag)) 3818{ 3819 return 1; 3820} 3821 3822/* attr rb_num_t popn @ splatarray(flag)(ary)(obj) */ 3823rb_num_t 3824attr_popn_splatarray(MAYBE_UNUSED(VALUE flag)) 3825{ 3826 return 1; 3827} 3828 3829/* attr rb_num_t retn @ splatarray(flag)(ary)(obj) */ 3830rb_num_t 3831attr_retn_splatarray(MAYBE_UNUSED(VALUE flag)) 3832{ 3833 return 1; 3834} 3835 3836/* attr rb_snum_t sp_inc @ splatarray(flag)(ary)(obj) */ 3837rb_snum_t 3838attr_sp_inc_splatarray(MAYBE_UNUSED(VALUE flag)) 3839{ 3840 return 0; 3841} 3842 3843/* attr rb_num_t width @ splatarray(flag)(ary)(obj) */ 3844rb_num_t 3845attr_width_splatarray(MAYBE_UNUSED(VALUE flag)) 3846{ 3847 return 2; 3848} 3849 3850/* attr enum ruby_vminsn_type bin @ newhash(num)(...)(val) */ 3851enum ruby_vminsn_type 3852attr_bin_newhash(MAYBE_UNUSED(rb_num_t num)) 3853{ 3854 return BIN(newhash); 3855} 3856 3857/* attr bool handles_sp @ newhash(num)(...)(val) */ 3858bool 3859attr_handles_sp_newhash(MAYBE_UNUSED(rb_num_t num)) 3860{ 3861 return false; 3862} 3863 3864/* attr bool leaf @ newhash(num)(...)(val) */ 3865bool 3866attr_leaf_newhash(MAYBE_UNUSED(rb_num_t num)) 3867{ 3868 return 3869#line 517 "insns.def" 3870false; 3871#line 3872 "insns_info.inc" 3872} 3873 3874/* attr const char* name @ newhash(num)(...)(val) */ 3875const char* 3876attr_name_newhash(MAYBE_UNUSED(rb_num_t num)) 3877{ 3878 return insn_name(BIN(newhash)); 3879} 3880 3881/* attr rb_num_t open @ newhash(num)(...)(val) */ 3882rb_num_t 3883attr_open_newhash(MAYBE_UNUSED(rb_num_t num)) 3884{ 3885 return 1; 3886} 3887 3888/* attr rb_num_t popn @ newhash(num)(...)(val) */ 3889rb_num_t 3890attr_popn_newhash(MAYBE_UNUSED(rb_num_t num)) 3891{ 3892 return 0; 3893} 3894 3895/* attr rb_num_t retn @ newhash(num)(...)(val) */ 3896rb_num_t 3897attr_retn_newhash(MAYBE_UNUSED(rb_num_t num)) 3898{ 3899 return 1; 3900} 3901 3902/* attr rb_snum_t sp_inc @ newhash(num)(...)(val) */ 3903rb_snum_t 3904attr_sp_inc_newhash(MAYBE_UNUSED(rb_num_t num)) 3905{ 3906 return 3907#line 518 "insns.def" 39081 - (rb_snum_t)num; 3909#line 3910 "insns_info.inc" 3910} 3911 3912/* attr rb_num_t width @ newhash(num)(...)(val) */ 3913rb_num_t 3914attr_width_newhash(MAYBE_UNUSED(rb_num_t num)) 3915{ 3916 return 2; 3917} 3918 3919/* attr enum ruby_vminsn_type bin @ newrange(flag)(low, high)(val) */ 3920enum ruby_vminsn_type 3921attr_bin_newrange(MAYBE_UNUSED(rb_num_t flag)) 3922{ 3923 return BIN(newrange); 3924} 3925 3926/* attr bool handles_sp @ newrange(flag)(low, high)(val) */ 3927bool 3928attr_handles_sp_newrange(MAYBE_UNUSED(rb_num_t flag)) 3929{ 3930 return false; 3931} 3932 3933/* attr bool leaf @ newrange(flag)(low, high)(val) */ 3934bool 3935attr_leaf_newrange(MAYBE_UNUSED(rb_num_t flag)) 3936{ 3937 return 3938#line 536 "insns.def" 3939false; 3940#line 3941 "insns_info.inc" 3941} 3942 3943/* attr const char* name @ newrange(flag)(low, high)(val) */ 3944const char* 3945attr_name_newrange(MAYBE_UNUSED(rb_num_t flag)) 3946{ 3947 return insn_name(BIN(newrange)); 3948} 3949 3950/* attr rb_num_t open @ newrange(flag)(low, high)(val) */ 3951rb_num_t 3952attr_open_newrange(MAYBE_UNUSED(rb_num_t flag)) 3953{ 3954 return 1; 3955} 3956 3957/* attr rb_num_t popn @ newrange(flag)(low, high)(val) */ 3958rb_num_t 3959attr_popn_newrange(MAYBE_UNUSED(rb_num_t flag)) 3960{ 3961 return 2; 3962} 3963 3964/* attr rb_num_t retn @ newrange(flag)(low, high)(val) */ 3965rb_num_t 3966attr_retn_newrange(MAYBE_UNUSED(rb_num_t flag)) 3967{ 3968 return 1; 3969} 3970 3971/* attr rb_snum_t sp_inc @ newrange(flag)(low, high)(val) */ 3972rb_snum_t 3973attr_sp_inc_newrange(MAYBE_UNUSED(rb_num_t flag)) 3974{ 3975 return -1; 3976} 3977 3978/* attr rb_num_t width @ newrange(flag)(low, high)(val) */ 3979rb_num_t 3980attr_width_newrange(MAYBE_UNUSED(rb_num_t flag)) 3981{ 3982 return 2; 3983} 3984 3985/* attr enum ruby_vminsn_type bin @ pop()(val)() */ 3986enum ruby_vminsn_type 3987attr_bin_pop(void) 3988{ 3989 return BIN(pop); 3990} 3991 3992/* attr bool handles_sp @ pop()(val)() */ 3993bool 3994attr_handles_sp_pop(void) 3995{ 3996 return false; 3997} 3998 3999/* attr bool leaf @ pop()(val)() */ 4000bool 4001attr_leaf_pop(void) 4002{ 4003 return true; 4004} 4005 4006/* attr const char* name @ pop()(val)() */ 4007const char* 4008attr_name_pop(void) 4009{ 4010 return insn_name(BIN(pop)); 4011} 4012 4013/* attr rb_num_t open @ pop()(val)() */ 4014rb_num_t 4015attr_open_pop(void) 4016{ 4017 return 0; 4018} 4019 4020/* attr rb_num_t popn @ pop()(val)() */ 4021rb_num_t 4022attr_popn_pop(void) 4023{ 4024 return 1; 4025} 4026 4027/* attr rb_num_t retn @ pop()(val)() */ 4028rb_num_t 4029attr_retn_pop(void) 4030{ 4031 return 0; 4032} 4033 4034/* attr rb_snum_t sp_inc @ pop()(val)() */ 4035rb_snum_t 4036attr_sp_inc_pop(void) 4037{ 4038 return -1; 4039} 4040 4041/* attr rb_num_t width @ pop()(val)() */ 4042rb_num_t 4043attr_width_pop(void) 4044{ 4045 return 1; 4046} 4047 4048/* attr enum ruby_vminsn_type bin @ dup()(val)(val1, val2) */ 4049enum ruby_vminsn_type 4050attr_bin_dup(void) 4051{ 4052 return BIN(dup); 4053} 4054 4055/* attr bool handles_sp @ dup()(val)(val1, val2) */ 4056bool 4057attr_handles_sp_dup(void) 4058{ 4059 return false; 4060} 4061 4062/* attr bool leaf @ dup()(val)(val1, val2) */ 4063bool 4064attr_leaf_dup(void) 4065{ 4066 return true; 4067} 4068 4069/* attr const char* name @ dup()(val)(val1, val2) */ 4070const char* 4071attr_name_dup(void) 4072{ 4073 return insn_name(BIN(dup)); 4074} 4075 4076/* attr rb_num_t open @ dup()(val)(val1, val2) */ 4077rb_num_t 4078attr_open_dup(void) 4079{ 4080 return 0; 4081} 4082 4083/* attr rb_num_t popn @ dup()(val)(val1, val2) */ 4084rb_num_t 4085attr_popn_dup(void) 4086{ 4087 return 1; 4088} 4089 4090/* attr rb_num_t retn @ dup()(val)(val1, val2) */ 4091rb_num_t 4092attr_retn_dup(void) 4093{ 4094 return 2; 4095} 4096 4097/* attr rb_snum_t sp_inc @ dup()(val)(val1, val2) */ 4098rb_snum_t 4099attr_sp_inc_dup(void) 4100{ 4101 return 1; 4102} 4103 4104/* attr rb_num_t width @ dup()(val)(val1, val2) */ 4105rb_num_t 4106attr_width_dup(void) 4107{ 4108 return 1; 4109} 4110 4111/* attr enum ruby_vminsn_type bin @ dupn(n)(...)(...) */ 4112enum ruby_vminsn_type 4113attr_bin_dupn(MAYBE_UNUSED(rb_num_t n)) 4114{ 4115 return BIN(dupn); 4116} 4117 4118/* attr bool handles_sp @ dupn(n)(...)(...) */ 4119bool 4120attr_handles_sp_dupn(MAYBE_UNUSED(rb_num_t n)) 4121{ 4122 return false; 4123} 4124 4125/* attr bool leaf @ dupn(n)(...)(...) */ 4126bool 4127attr_leaf_dupn(MAYBE_UNUSED(rb_num_t n)) 4128{ 4129 return true; 4130} 4131 4132/* attr const char* name @ dupn(n)(...)(...) */ 4133const char* 4134attr_name_dupn(MAYBE_UNUSED(rb_num_t n)) 4135{ 4136 return insn_name(BIN(dupn)); 4137} 4138 4139/* attr rb_num_t open @ dupn(n)(...)(...) */ 4140rb_num_t 4141attr_open_dupn(MAYBE_UNUSED(rb_num_t n)) 4142{ 4143 return 1; 4144} 4145 4146/* attr rb_num_t popn @ dupn(n)(...)(...) */ 4147rb_num_t 4148attr_popn_dupn(MAYBE_UNUSED(rb_num_t n)) 4149{ 4150 return 0; 4151} 4152 4153/* attr rb_num_t retn @ dupn(n)(...)(...) */ 4154rb_num_t 4155attr_retn_dupn(MAYBE_UNUSED(rb_num_t n)) 4156{ 4157 return 0; 4158} 4159 4160/* attr rb_snum_t sp_inc @ dupn(n)(...)(...) */ 4161rb_snum_t 4162attr_sp_inc_dupn(MAYBE_UNUSED(rb_num_t n)) 4163{ 4164 return 4165#line 572 "insns.def" 4166n; 4167#line 4168 "insns_info.inc" 4168} 4169 4170/* attr rb_num_t width @ dupn(n)(...)(...) */ 4171rb_num_t 4172attr_width_dupn(MAYBE_UNUSED(rb_num_t n)) 4173{ 4174 return 2; 4175} 4176 4177/* attr enum ruby_vminsn_type bin @ swap()(val, obj)(obj, val) */ 4178enum ruby_vminsn_type 4179attr_bin_swap(void) 4180{ 4181 return BIN(swap); 4182} 4183 4184/* attr bool handles_sp @ swap()(val, obj)(obj, val) */ 4185bool 4186attr_handles_sp_swap(void) 4187{ 4188 return false; 4189} 4190 4191/* attr bool leaf @ swap()(val, obj)(obj, val) */ 4192bool 4193attr_leaf_swap(void) 4194{ 4195 return true; 4196} 4197 4198/* attr const char* name @ swap()(val, obj)(obj, val) */ 4199const char* 4200attr_name_swap(void) 4201{ 4202 return insn_name(BIN(swap)); 4203} 4204 4205/* attr rb_num_t open @ swap()(val, obj)(obj, val) */ 4206rb_num_t 4207attr_open_swap(void) 4208{ 4209 return 0; 4210} 4211 4212/* attr rb_num_t popn @ swap()(val, obj)(obj, val) */ 4213rb_num_t 4214attr_popn_swap(void) 4215{ 4216 return 2; 4217} 4218 4219/* attr rb_num_t retn @ swap()(val, obj)(obj, val) */ 4220rb_num_t 4221attr_retn_swap(void) 4222{ 4223 return 2; 4224} 4225 4226/* attr rb_snum_t sp_inc @ swap()(val, obj)(obj, val) */ 4227rb_snum_t 4228attr_sp_inc_swap(void) 4229{ 4230 return 0; 4231} 4232 4233/* attr rb_num_t width @ swap()(val, obj)(obj, val) */ 4234rb_num_t 4235attr_width_swap(void) 4236{ 4237 return 1; 4238} 4239 4240/* attr enum ruby_vminsn_type bin @ reverse(n)(...)(...) */ 4241enum ruby_vminsn_type 4242attr_bin_reverse(MAYBE_UNUSED(rb_num_t n)) 4243{ 4244 return BIN(reverse); 4245} 4246 4247/* attr bool handles_sp @ reverse(n)(...)(...) */ 4248bool 4249attr_handles_sp_reverse(MAYBE_UNUSED(rb_num_t n)) 4250{ 4251 return false; 4252} 4253 4254/* attr bool leaf @ reverse(n)(...)(...) */ 4255bool 4256attr_leaf_reverse(MAYBE_UNUSED(rb_num_t n)) 4257{ 4258 return true; 4259} 4260 4261/* attr const char* name @ reverse(n)(...)(...) */ 4262const char* 4263attr_name_reverse(MAYBE_UNUSED(rb_num_t n)) 4264{ 4265 return insn_name(BIN(reverse)); 4266} 4267 4268/* attr rb_num_t open @ reverse(n)(...)(...) */ 4269rb_num_t 4270attr_open_reverse(MAYBE_UNUSED(rb_num_t n)) 4271{ 4272 return 1; 4273} 4274 4275/* attr rb_num_t popn @ reverse(n)(...)(...) */ 4276rb_num_t 4277attr_popn_reverse(MAYBE_UNUSED(rb_num_t n)) 4278{ 4279 return 0; 4280} 4281 4282/* attr rb_num_t retn @ reverse(n)(...)(...) */ 4283rb_num_t 4284attr_retn_reverse(MAYBE_UNUSED(rb_num_t n)) 4285{ 4286 return 0; 4287} 4288 4289/* attr rb_snum_t sp_inc @ reverse(n)(...)(...) */ 4290rb_snum_t 4291attr_sp_inc_reverse(MAYBE_UNUSED(rb_num_t n)) 4292{ 4293 return 4294#line 596 "insns.def" 42950; 4296#line 4297 "insns_info.inc" 4297} 4298 4299/* attr rb_num_t width @ reverse(n)(...)(...) */ 4300rb_num_t 4301attr_width_reverse(MAYBE_UNUSED(rb_num_t n)) 4302{ 4303 return 2; 4304} 4305 4306/* attr enum ruby_vminsn_type bin @ reput()(..., val)(val) */ 4307enum ruby_vminsn_type 4308attr_bin_reput(void) 4309{ 4310 return BIN(reput); 4311} 4312 4313/* attr bool handles_sp @ reput()(..., val)(val) */ 4314bool 4315attr_handles_sp_reput(void) 4316{ 4317 return false; 4318} 4319 4320/* attr bool leaf @ reput()(..., val)(val) */ 4321bool 4322attr_leaf_reput(void) 4323{ 4324 return true; 4325} 4326 4327/* attr const char* name @ reput()(..., val)(val) */ 4328const char* 4329attr_name_reput(void) 4330{ 4331 return insn_name(BIN(reput)); 4332} 4333 4334/* attr rb_num_t open @ reput()(..., val)(val) */ 4335rb_num_t 4336attr_open_reput(void) 4337{ 4338 return 0; 4339} 4340 4341/* attr rb_num_t popn @ reput()(..., val)(val) */ 4342rb_num_t 4343attr_popn_reput(void) 4344{ 4345 return 1; 4346} 4347 4348/* attr rb_num_t retn @ reput()(..., val)(val) */ 4349rb_num_t 4350attr_retn_reput(void) 4351{ 4352 return 1; 4353} 4354 4355/* attr rb_snum_t sp_inc @ reput()(..., val)(val) */ 4356rb_snum_t 4357attr_sp_inc_reput(void) 4358{ 4359 return 4360#line 615 "insns.def" 43610; 4362#line 4363 "insns_info.inc" 4363} 4364 4365/* attr rb_num_t width @ reput()(..., val)(val) */ 4366rb_num_t 4367attr_width_reput(void) 4368{ 4369 return 1; 4370} 4371 4372/* attr enum ruby_vminsn_type bin @ topn(n)(...)(val) */ 4373enum ruby_vminsn_type 4374attr_bin_topn(MAYBE_UNUSED(rb_num_t n)) 4375{ 4376 return BIN(topn); 4377} 4378 4379/* attr bool handles_sp @ topn(n)(...)(val) */ 4380bool 4381attr_handles_sp_topn(MAYBE_UNUSED(rb_num_t n)) 4382{ 4383 return false; 4384} 4385 4386/* attr bool leaf @ topn(n)(...)(val) */ 4387bool 4388attr_leaf_topn(MAYBE_UNUSED(rb_num_t n)) 4389{ 4390 return true; 4391} 4392 4393/* attr const char* name @ topn(n)(...)(val) */ 4394const char* 4395attr_name_topn(MAYBE_UNUSED(rb_num_t n)) 4396{ 4397 return insn_name(BIN(topn)); 4398} 4399 4400/* attr rb_num_t open @ topn(n)(...)(val) */ 4401rb_num_t 4402attr_open_topn(MAYBE_UNUSED(rb_num_t n)) 4403{ 4404 return 1; 4405} 4406 4407/* attr rb_num_t popn @ topn(n)(...)(val) */ 4408rb_num_t 4409attr_popn_topn(MAYBE_UNUSED(rb_num_t n)) 4410{ 4411 return 0; 4412} 4413 4414/* attr rb_num_t retn @ topn(n)(...)(val) */ 4415rb_num_t 4416attr_retn_topn(MAYBE_UNUSED(rb_num_t n)) 4417{ 4418 return 1; 4419} 4420 4421/* attr rb_snum_t sp_inc @ topn(n)(...)(val) */ 4422rb_snum_t 4423attr_sp_inc_topn(MAYBE_UNUSED(rb_num_t n)) 4424{ 4425 return 4426#line 626 "insns.def" 44271; 4428#line 4429 "insns_info.inc" 4429} 4430 4431/* attr rb_num_t width @ topn(n)(...)(val) */ 4432rb_num_t 4433attr_width_topn(MAYBE_UNUSED(rb_num_t n)) 4434{ 4435 return 2; 4436} 4437 4438/* attr enum ruby_vminsn_type bin @ setn(n)(..., val)(val) */ 4439enum ruby_vminsn_type 4440attr_bin_setn(MAYBE_UNUSED(rb_num_t n)) 4441{ 4442 return BIN(setn); 4443} 4444 4445/* attr bool handles_sp @ setn(n)(..., val)(val) */ 4446bool 4447attr_handles_sp_setn(MAYBE_UNUSED(rb_num_t n)) 4448{ 4449 return false; 4450} 4451 4452/* attr bool leaf @ setn(n)(..., val)(val) */ 4453bool 4454attr_leaf_setn(MAYBE_UNUSED(rb_num_t n)) 4455{ 4456 return true; 4457} 4458 4459/* attr const char* name @ setn(n)(..., val)(val) */ 4460const char* 4461attr_name_setn(MAYBE_UNUSED(rb_num_t n)) 4462{ 4463 return insn_name(BIN(setn)); 4464} 4465 4466/* attr rb_num_t open @ setn(n)(..., val)(val) */ 4467rb_num_t 4468attr_open_setn(MAYBE_UNUSED(rb_num_t n)) 4469{ 4470 return 1; 4471} 4472 4473/* attr rb_num_t popn @ setn(n)(..., val)(val) */ 4474rb_num_t 4475attr_popn_setn(MAYBE_UNUSED(rb_num_t n)) 4476{ 4477 return 1; 4478} 4479 4480/* attr rb_num_t retn @ setn(n)(..., val)(val) */ 4481rb_num_t 4482attr_retn_setn(MAYBE_UNUSED(rb_num_t n)) 4483{ 4484 return 1; 4485} 4486 4487/* attr rb_snum_t sp_inc @ setn(n)(..., val)(val) */ 4488rb_snum_t 4489attr_sp_inc_setn(MAYBE_UNUSED(rb_num_t n)) 4490{ 4491 return 4492#line 637 "insns.def" 44930; 4494#line 4495 "insns_info.inc" 4495} 4496 4497/* attr rb_num_t width @ setn(n)(..., val)(val) */ 4498rb_num_t 4499attr_width_setn(MAYBE_UNUSED(rb_num_t n)) 4500{ 4501 return 2; 4502} 4503 4504/* attr enum ruby_vminsn_type bin @ adjuststack(n)(...)(...) */ 4505enum ruby_vminsn_type 4506attr_bin_adjuststack(MAYBE_UNUSED(rb_num_t n)) 4507{ 4508 return BIN(adjuststack); 4509} 4510 4511/* attr bool handles_sp @ adjuststack(n)(...)(...) */ 4512bool 4513attr_handles_sp_adjuststack(MAYBE_UNUSED(rb_num_t n)) 4514{ 4515 return false; 4516} 4517 4518/* attr bool leaf @ adjuststack(n)(...)(...) */ 4519bool 4520attr_leaf_adjuststack(MAYBE_UNUSED(rb_num_t n)) 4521{ 4522 return true; 4523} 4524 4525/* attr const char* name @ adjuststack(n)(...)(...) */ 4526const char* 4527attr_name_adjuststack(MAYBE_UNUSED(rb_num_t n)) 4528{ 4529 return insn_name(BIN(adjuststack)); 4530} 4531 4532/* attr rb_num_t open @ adjuststack(n)(...)(...) */ 4533rb_num_t 4534attr_open_adjuststack(MAYBE_UNUSED(rb_num_t n)) 4535{ 4536 return 1; 4537} 4538 4539/* attr rb_num_t popn @ adjuststack(n)(...)(...) */ 4540rb_num_t 4541attr_popn_adjuststack(MAYBE_UNUSED(rb_num_t n)) 4542{ 4543 return 0; 4544} 4545 4546/* attr rb_num_t retn @ adjuststack(n)(...)(...) */ 4547rb_num_t 4548attr_retn_adjuststack(MAYBE_UNUSED(rb_num_t n)) 4549{ 4550 return 0; 4551} 4552 4553/* attr rb_snum_t sp_inc @ adjuststack(n)(...)(...) */ 4554rb_snum_t 4555attr_sp_inc_adjuststack(MAYBE_UNUSED(rb_num_t n)) 4556{ 4557 return 4558#line 648 "insns.def" 4559-(rb_snum_t)n; 4560#line 4561 "insns_info.inc" 4561} 4562 4563/* attr rb_num_t width @ adjuststack(n)(...)(...) */ 4564rb_num_t 4565attr_width_adjuststack(MAYBE_UNUSED(rb_num_t n)) 4566{ 4567 return 2; 4568} 4569 4570/* attr enum ruby_vminsn_type bin @ defined(op_type, obj, needstr)(v)(val) */ 4571enum ruby_vminsn_type 4572attr_bin_defined( 4573 MAYBE_UNUSED(rb_num_t op_type), 4574 MAYBE_UNUSED(VALUE obj), 4575 MAYBE_UNUSED(VALUE needstr) 4576) 4577{ 4578 return BIN(defined); 4579} 4580 4581/* attr bool handles_sp @ defined(op_type, obj, needstr)(v)(val) */ 4582bool 4583attr_handles_sp_defined( 4584 MAYBE_UNUSED(rb_num_t op_type), 4585 MAYBE_UNUSED(VALUE obj), 4586 MAYBE_UNUSED(VALUE needstr) 4587) 4588{ 4589 return false; 4590} 4591 4592/* attr bool leaf @ defined(op_type, obj, needstr)(v)(val) */ 4593bool 4594attr_leaf_defined( 4595 MAYBE_UNUSED(rb_num_t op_type), 4596 MAYBE_UNUSED(VALUE obj), 4597 MAYBE_UNUSED(VALUE needstr) 4598) 4599{ 4600 return 4601#line 663 "insns.def" 4602leafness_of_defined(op_type); 4603#line 4604 "insns_info.inc" 4604} 4605 4606/* attr const char* name @ defined(op_type, obj, needstr)(v)(val) */ 4607const char* 4608attr_name_defined( 4609 MAYBE_UNUSED(rb_num_t op_type), 4610 MAYBE_UNUSED(VALUE obj), 4611 MAYBE_UNUSED(VALUE needstr) 4612) 4613{ 4614 return insn_name(BIN(defined)); 4615} 4616 4617/* attr rb_num_t open @ defined(op_type, obj, needstr)(v)(val) */ 4618rb_num_t 4619attr_open_defined( 4620 MAYBE_UNUSED(rb_num_t op_type), 4621 MAYBE_UNUSED(VALUE obj), 4622 MAYBE_UNUSED(VALUE needstr) 4623) 4624{ 4625 return 3; 4626} 4627 4628/* attr rb_num_t popn @ defined(op_type, obj, needstr)(v)(val) */ 4629rb_num_t 4630attr_popn_defined( 4631 MAYBE_UNUSED(rb_num_t op_type), 4632 MAYBE_UNUSED(VALUE obj), 4633 MAYBE_UNUSED(VALUE needstr) 4634) 4635{ 4636 return 1; 4637} 4638 4639/* attr rb_num_t retn @ defined(op_type, obj, needstr)(v)(val) */ 4640rb_num_t 4641attr_retn_defined( 4642 MAYBE_UNUSED(rb_num_t op_type), 4643 MAYBE_UNUSED(VALUE obj), 4644 MAYBE_UNUSED(VALUE needstr) 4645) 4646{ 4647 return 1; 4648} 4649 4650/* attr rb_snum_t sp_inc @ defined(op_type, obj, needstr)(v)(val) */ 4651rb_snum_t 4652attr_sp_inc_defined( 4653 MAYBE_UNUSED(rb_num_t op_type), 4654 MAYBE_UNUSED(VALUE obj), 4655 MAYBE_UNUSED(VALUE needstr) 4656) 4657{ 4658 return 0; 4659} 4660 4661/* attr rb_num_t width @ defined(op_type, obj, needstr)(v)(val) */ 4662rb_num_t 4663attr_width_defined( 4664 MAYBE_UNUSED(rb_num_t op_type), 4665 MAYBE_UNUSED(VALUE obj), 4666 MAYBE_UNUSED(VALUE needstr) 4667) 4668{ 4669 return 4; 4670} 4671 4672/* attr enum ruby_vminsn_type bin @ checkmatch(flag)(target, pattern)(result) */ 4673enum ruby_vminsn_type 4674attr_bin_checkmatch(MAYBE_UNUSED(rb_num_t flag)) 4675{ 4676 return BIN(checkmatch); 4677} 4678 4679/* attr bool handles_sp @ checkmatch(flag)(target, pattern)(result) */ 4680bool 4681attr_handles_sp_checkmatch(MAYBE_UNUSED(rb_num_t flag)) 4682{ 4683 return false; 4684} 4685 4686/* attr bool leaf @ checkmatch(flag)(target, pattern)(result) */ 4687bool 4688attr_leaf_checkmatch(MAYBE_UNUSED(rb_num_t flag)) 4689{ 4690 return 4691#line 680 "insns.def" 4692leafness_of_checkmatch(flag); 4693#line 4694 "insns_info.inc" 4694} 4695 4696/* attr const char* name @ checkmatch(flag)(target, pattern)(result) */ 4697const char* 4698attr_name_checkmatch(MAYBE_UNUSED(rb_num_t flag)) 4699{ 4700 return insn_name(BIN(checkmatch)); 4701} 4702 4703/* attr rb_num_t open @ checkmatch(flag)(target, pattern)(result) */ 4704rb_num_t 4705attr_open_checkmatch(MAYBE_UNUSED(rb_num_t flag)) 4706{ 4707 return 1; 4708} 4709 4710/* attr rb_num_t popn @ checkmatch(flag)(target, pattern)(result) */ 4711rb_num_t 4712attr_popn_checkmatch(MAYBE_UNUSED(rb_num_t flag)) 4713{ 4714 return 2; 4715} 4716 4717/* attr rb_num_t retn @ checkmatch(flag)(target, pattern)(result) */ 4718rb_num_t 4719attr_retn_checkmatch(MAYBE_UNUSED(rb_num_t flag)) 4720{ 4721 return 1; 4722} 4723 4724/* attr rb_snum_t sp_inc @ checkmatch(flag)(target, pattern)(result) */ 4725rb_snum_t 4726attr_sp_inc_checkmatch(MAYBE_UNUSED(rb_num_t flag)) 4727{ 4728 return -1; 4729} 4730 4731/* attr rb_num_t width @ checkmatch(flag)(target, pattern)(result) */ 4732rb_num_t 4733attr_width_checkmatch(MAYBE_UNUSED(rb_num_t flag)) 4734{ 4735 return 2; 4736} 4737 4738/* attr enum ruby_vminsn_type bin @ checkkeyword(kw_bits_index, keyword_index)()(ret) */ 4739enum ruby_vminsn_type 4740attr_bin_checkkeyword( 4741 MAYBE_UNUSED(lindex_t kw_bits_index), 4742 MAYBE_UNUSED(lindex_t keyword_index) 4743) 4744{ 4745 return BIN(checkkeyword); 4746} 4747 4748/* attr bool handles_sp @ checkkeyword(kw_bits_index, keyword_index)()(ret) */ 4749bool 4750attr_handles_sp_checkkeyword( 4751 MAYBE_UNUSED(lindex_t kw_bits_index), 4752 MAYBE_UNUSED(lindex_t keyword_index) 4753) 4754{ 4755 return false; 4756} 4757 4758/* attr bool leaf @ checkkeyword(kw_bits_index, keyword_index)()(ret) */ 4759bool 4760attr_leaf_checkkeyword( 4761 MAYBE_UNUSED(lindex_t kw_bits_index), 4762 MAYBE_UNUSED(lindex_t keyword_index) 4763) 4764{ 4765 return true; 4766} 4767 4768/* attr const char* name @ checkkeyword(kw_bits_index, keyword_index)()(ret) */ 4769const char* 4770attr_name_checkkeyword( 4771 MAYBE_UNUSED(lindex_t kw_bits_index), 4772 MAYBE_UNUSED(lindex_t keyword_index) 4773) 4774{ 4775 return insn_name(BIN(checkkeyword)); 4776} 4777 4778/* attr rb_num_t open @ checkkeyword(kw_bits_index, keyword_index)()(ret) */ 4779rb_num_t 4780attr_open_checkkeyword( 4781 MAYBE_UNUSED(lindex_t kw_bits_index), 4782 MAYBE_UNUSED(lindex_t keyword_index) 4783) 4784{ 4785 return 2; 4786} 4787 4788/* attr rb_num_t popn @ checkkeyword(kw_bits_index, keyword_index)()(ret) */ 4789rb_num_t 4790attr_popn_checkkeyword( 4791 MAYBE_UNUSED(lindex_t kw_bits_index), 4792 MAYBE_UNUSED(lindex_t keyword_index) 4793) 4794{ 4795 return 0; 4796} 4797 4798/* attr rb_num_t retn @ checkkeyword(kw_bits_index, keyword_index)()(ret) */ 4799rb_num_t 4800attr_retn_checkkeyword( 4801 MAYBE_UNUSED(lindex_t kw_bits_index), 4802 MAYBE_UNUSED(lindex_t keyword_index) 4803) 4804{ 4805 return 1; 4806} 4807 4808/* attr rb_snum_t sp_inc @ checkkeyword(kw_bits_index, keyword_index)()(ret) */ 4809rb_snum_t 4810attr_sp_inc_checkkeyword( 4811 MAYBE_UNUSED(lindex_t kw_bits_index), 4812 MAYBE_UNUSED(lindex_t keyword_index) 4813) 4814{ 4815 return 1; 4816} 4817 4818/* attr rb_num_t width @ checkkeyword(kw_bits_index, keyword_index)()(ret) */ 4819rb_num_t 4820attr_width_checkkeyword( 4821 MAYBE_UNUSED(lindex_t kw_bits_index), 4822 MAYBE_UNUSED(lindex_t keyword_index) 4823) 4824{ 4825 return 3; 4826} 4827 4828/* attr enum ruby_vminsn_type bin @ checktype(type)(val)(ret) */ 4829enum ruby_vminsn_type 4830attr_bin_checktype(MAYBE_UNUSED(rb_num_t type)) 4831{ 4832 return BIN(checktype); 4833} 4834 4835/* attr bool handles_sp @ checktype(type)(val)(ret) */ 4836bool 4837attr_handles_sp_checktype(MAYBE_UNUSED(rb_num_t type)) 4838{ 4839 return false; 4840} 4841 4842/* attr bool leaf @ checktype(type)(val)(ret) */ 4843bool 4844attr_leaf_checktype(MAYBE_UNUSED(rb_num_t type)) 4845{ 4846 return true; 4847} 4848 4849/* attr const char* name @ checktype(type)(val)(ret) */ 4850const char* 4851attr_name_checktype(MAYBE_UNUSED(rb_num_t type)) 4852{ 4853 return insn_name(BIN(checktype)); 4854} 4855 4856/* attr rb_num_t open @ checktype(type)(val)(ret) */ 4857rb_num_t 4858attr_open_checktype(MAYBE_UNUSED(rb_num_t type)) 4859{ 4860 return 1; 4861} 4862 4863/* attr rb_num_t popn @ checktype(type)(val)(ret) */ 4864rb_num_t 4865attr_popn_checktype(MAYBE_UNUSED(rb_num_t type)) 4866{ 4867 return 1; 4868} 4869 4870/* attr rb_num_t retn @ checktype(type)(val)(ret) */ 4871rb_num_t 4872attr_retn_checktype(MAYBE_UNUSED(rb_num_t type)) 4873{ 4874 return 1; 4875} 4876 4877/* attr rb_snum_t sp_inc @ checktype(type)(val)(ret) */ 4878rb_snum_t 4879attr_sp_inc_checktype(MAYBE_UNUSED(rb_num_t type)) 4880{ 4881 return 0; 4882} 4883 4884/* attr rb_num_t width @ checktype(type)(val)(ret) */ 4885rb_num_t 4886attr_width_checktype(MAYBE_UNUSED(rb_num_t type)) 4887{ 4888 return 2; 4889} 4890 4891/* attr enum ruby_vminsn_type bin @ defineclass(id, class_iseq, flags)(cbase, super)(val) */ 4892enum ruby_vminsn_type 4893attr_bin_defineclass( 4894 MAYBE_UNUSED(ID id), 4895 MAYBE_UNUSED(ISEQ class_iseq), 4896 MAYBE_UNUSED(rb_num_t flags) 4897) 4898{ 4899 return BIN(defineclass); 4900} 4901 4902/* attr bool handles_sp @ defineclass(id, class_iseq, flags)(cbase, super)(val) */ 4903bool 4904attr_handles_sp_defineclass( 4905 MAYBE_UNUSED(ID id), 4906 MAYBE_UNUSED(ISEQ class_iseq), 4907 MAYBE_UNUSED(rb_num_t flags) 4908) 4909{ 4910 return true; 4911} 4912 4913/* attr bool leaf @ defineclass(id, class_iseq, flags)(cbase, super)(val) */ 4914bool 4915attr_leaf_defineclass( 4916 MAYBE_UNUSED(ID id), 4917 MAYBE_UNUSED(ISEQ class_iseq), 4918 MAYBE_UNUSED(rb_num_t flags) 4919) 4920{ 4921 return false; 4922} 4923 4924/* attr const char* name @ defineclass(id, class_iseq, flags)(cbase, super)(val) */ 4925const char* 4926attr_name_defineclass( 4927 MAYBE_UNUSED(ID id), 4928 MAYBE_UNUSED(ISEQ class_iseq), 4929 MAYBE_UNUSED(rb_num_t flags) 4930) 4931{ 4932 return insn_name(BIN(defineclass)); 4933} 4934 4935/* attr rb_num_t open @ defineclass(id, class_iseq, flags)(cbase, super)(val) */ 4936rb_num_t 4937attr_open_defineclass( 4938 MAYBE_UNUSED(ID id), 4939 MAYBE_UNUSED(ISEQ class_iseq), 4940 MAYBE_UNUSED(rb_num_t flags) 4941) 4942{ 4943 return 3; 4944} 4945 4946/* attr rb_num_t popn @ defineclass(id, class_iseq, flags)(cbase, super)(val) */ 4947rb_num_t 4948attr_popn_defineclass( 4949 MAYBE_UNUSED(ID id), 4950 MAYBE_UNUSED(ISEQ class_iseq), 4951 MAYBE_UNUSED(rb_num_t flags) 4952) 4953{ 4954 return 2; 4955} 4956 4957/* attr rb_num_t retn @ defineclass(id, class_iseq, flags)(cbase, super)(val) */ 4958rb_num_t 4959attr_retn_defineclass( 4960 MAYBE_UNUSED(ID id), 4961 MAYBE_UNUSED(ISEQ class_iseq), 4962 MAYBE_UNUSED(rb_num_t flags) 4963) 4964{ 4965 return 1; 4966} 4967 4968/* attr rb_snum_t sp_inc @ defineclass(id, class_iseq, flags)(cbase, super)(val) */ 4969rb_snum_t 4970attr_sp_inc_defineclass( 4971 MAYBE_UNUSED(ID id), 4972 MAYBE_UNUSED(ISEQ class_iseq), 4973 MAYBE_UNUSED(rb_num_t flags) 4974) 4975{ 4976 return -1; 4977} 4978 4979/* attr rb_num_t width @ defineclass(id, class_iseq, flags)(cbase, super)(val) */ 4980rb_num_t 4981attr_width_defineclass( 4982 MAYBE_UNUSED(ID id), 4983 MAYBE_UNUSED(ISEQ class_iseq), 4984 MAYBE_UNUSED(rb_num_t flags) 4985) 4986{ 4987 return 4; 4988} 4989 4990/* attr enum ruby_vminsn_type bin @ send(ci, cc, blockiseq)(...)(val) */ 4991enum ruby_vminsn_type 4992attr_bin_send( 4993 MAYBE_UNUSED(CALL_INFO ci), 4994 MAYBE_UNUSED(CALL_CACHE cc), 4995 MAYBE_UNUSED(ISEQ blockiseq) 4996) 4997{ 4998 return BIN(send); 4999} 5000 5001/* attr bool handles_sp @ send(ci, cc, blockiseq)(...)(val) */ 5002bool 5003attr_handles_sp_send( 5004 MAYBE_UNUSED(CALL_INFO ci), 5005 MAYBE_UNUSED(CALL_CACHE cc), 5006 MAYBE_UNUSED(ISEQ blockiseq) 5007) 5008{ 5009 return true; 5010} 5011 5012/* attr bool leaf @ send(ci, cc, blockiseq)(...)(val) */ 5013bool 5014attr_leaf_send( 5015 MAYBE_UNUSED(CALL_INFO ci), 5016 MAYBE_UNUSED(CALL_CACHE cc), 5017 MAYBE_UNUSED(ISEQ blockiseq) 5018) 5019{ 5020 return false; 5021} 5022 5023/* attr const char* name @ send(ci, cc, blockiseq)(...)(val) */ 5024const char* 5025attr_name_send( 5026 MAYBE_UNUSED(CALL_INFO ci), 5027 MAYBE_UNUSED(CALL_CACHE cc), 5028 MAYBE_UNUSED(ISEQ blockiseq) 5029) 5030{ 5031 return insn_name(BIN(send)); 5032} 5033 5034/* attr rb_num_t open @ send(ci, cc, blockiseq)(...)(val) */ 5035rb_num_t 5036attr_open_send( 5037 MAYBE_UNUSED(CALL_INFO ci), 5038 MAYBE_UNUSED(CALL_CACHE cc), 5039 MAYBE_UNUSED(ISEQ blockiseq) 5040) 5041{ 5042 return 3; 5043} 5044 5045/* attr rb_num_t popn @ send(ci, cc, blockiseq)(...)(val) */ 5046rb_num_t 5047attr_popn_send( 5048 MAYBE_UNUSED(CALL_INFO ci), 5049 MAYBE_UNUSED(CALL_CACHE cc), 5050 MAYBE_UNUSED(ISEQ blockiseq) 5051) 5052{ 5053 return 0; 5054} 5055 5056/* attr rb_num_t retn @ send(ci, cc, blockiseq)(...)(val) */ 5057rb_num_t 5058attr_retn_send( 5059 MAYBE_UNUSED(CALL_INFO ci), 5060 MAYBE_UNUSED(CALL_CACHE cc), 5061 MAYBE_UNUSED(ISEQ blockiseq) 5062) 5063{ 5064 return 1; 5065} 5066 5067/* attr rb_snum_t sp_inc @ send(ci, cc, blockiseq)(...)(val) */ 5068rb_snum_t 5069attr_sp_inc_send( 5070 MAYBE_UNUSED(CALL_INFO ci), 5071 MAYBE_UNUSED(CALL_CACHE cc), 5072 MAYBE_UNUSED(ISEQ blockiseq) 5073) 5074{ 5075 return 5076#line 743 "insns.def" 5077- (int)(ci->orig_argc + ((ci->flag & VM_CALL_ARGS_BLOCKARG) ? 1 : 0)); 5078#line 5079 "insns_info.inc" 5079} 5080 5081/* attr rb_num_t width @ send(ci, cc, blockiseq)(...)(val) */ 5082rb_num_t 5083attr_width_send( 5084 MAYBE_UNUSED(CALL_INFO ci), 5085 MAYBE_UNUSED(CALL_CACHE cc), 5086 MAYBE_UNUSED(ISEQ blockiseq) 5087) 5088{ 5089 return 4; 5090} 5091 5092/* attr enum ruby_vminsn_type bin @ opt_send_without_block(ci, cc)(...)(val) */ 5093enum ruby_vminsn_type 5094attr_bin_opt_send_without_block( 5095 MAYBE_UNUSED(CALL_INFO ci), 5096 MAYBE_UNUSED(CALL_CACHE cc) 5097) 5098{ 5099 return BIN(opt_send_without_block); 5100} 5101 5102/* attr bool handles_sp @ opt_send_without_block(ci, cc)(...)(val) */ 5103bool 5104attr_handles_sp_opt_send_without_block( 5105 MAYBE_UNUSED(CALL_INFO ci), 5106 MAYBE_UNUSED(CALL_CACHE cc) 5107) 5108{ 5109 return 5110#line 759 "insns.def" 5111true; 5112#line 5113 "insns_info.inc" 5113} 5114 5115/* attr bool leaf @ opt_send_without_block(ci, cc)(...)(val) */ 5116bool 5117attr_leaf_opt_send_without_block( 5118 MAYBE_UNUSED(CALL_INFO ci), 5119 MAYBE_UNUSED(CALL_CACHE cc) 5120) 5121{ 5122 return ! attr_handles_sp_opt_send_without_block(ci, cc); 5123} 5124 5125/* attr const char* name @ opt_send_without_block(ci, cc)(...)(val) */ 5126const char* 5127attr_name_opt_send_without_block( 5128 MAYBE_UNUSED(CALL_INFO ci), 5129 MAYBE_UNUSED(CALL_CACHE cc) 5130) 5131{ 5132 return insn_name(BIN(opt_send_without_block)); 5133} 5134 5135/* attr rb_num_t open @ opt_send_without_block(ci, cc)(...)(val) */ 5136rb_num_t 5137attr_open_opt_send_without_block( 5138 MAYBE_UNUSED(CALL_INFO ci), 5139 MAYBE_UNUSED(CALL_CACHE cc) 5140) 5141{ 5142 return 2; 5143} 5144 5145/* attr rb_num_t popn @ opt_send_without_block(ci, cc)(...)(val) */ 5146rb_num_t 5147attr_popn_opt_send_without_block( 5148 MAYBE_UNUSED(CALL_INFO ci), 5149 MAYBE_UNUSED(CALL_CACHE cc) 5150) 5151{ 5152 return 0; 5153} 5154 5155/* attr rb_num_t retn @ opt_send_without_block(ci, cc)(...)(val) */ 5156rb_num_t 5157attr_retn_opt_send_without_block( 5158 MAYBE_UNUSED(CALL_INFO ci), 5159 MAYBE_UNUSED(CALL_CACHE cc) 5160) 5161{ 5162 return 1; 5163} 5164 5165/* attr rb_snum_t sp_inc @ opt_send_without_block(ci, cc)(...)(val) */ 5166rb_snum_t 5167attr_sp_inc_opt_send_without_block( 5168 MAYBE_UNUSED(CALL_INFO ci), 5169 MAYBE_UNUSED(CALL_CACHE cc) 5170) 5171{ 5172 return 5173#line 760 "insns.def" 5174-ci->orig_argc; 5175#line 5176 "insns_info.inc" 5176} 5177 5178/* attr rb_num_t width @ opt_send_without_block(ci, cc)(...)(val) */ 5179rb_num_t 5180attr_width_opt_send_without_block( 5181 MAYBE_UNUSED(CALL_INFO ci), 5182 MAYBE_UNUSED(CALL_CACHE cc) 5183) 5184{ 5185 return 3; 5186} 5187 5188/* attr enum ruby_vminsn_type bin @ opt_str_freeze(str, ci, cc)()(val) */ 5189enum ruby_vminsn_type 5190attr_bin_opt_str_freeze( 5191 MAYBE_UNUSED(VALUE str), 5192 MAYBE_UNUSED(CALL_INFO ci), 5193 MAYBE_UNUSED(CALL_CACHE cc) 5194) 5195{ 5196 return BIN(opt_str_freeze); 5197} 5198 5199/* attr bool handles_sp @ opt_str_freeze(str, ci, cc)()(val) */ 5200bool 5201attr_handles_sp_opt_str_freeze( 5202 MAYBE_UNUSED(VALUE str), 5203 MAYBE_UNUSED(CALL_INFO ci), 5204 MAYBE_UNUSED(CALL_CACHE cc) 5205) 5206{ 5207 return false; 5208} 5209 5210/* attr bool leaf @ opt_str_freeze(str, ci, cc)()(val) */ 5211bool 5212attr_leaf_opt_str_freeze( 5213 MAYBE_UNUSED(VALUE str), 5214 MAYBE_UNUSED(CALL_INFO ci), 5215 MAYBE_UNUSED(CALL_CACHE cc) 5216) 5217{ 5218 return true; 5219} 5220 5221/* attr const char* name @ opt_str_freeze(str, ci, cc)()(val) */ 5222const char* 5223attr_name_opt_str_freeze( 5224 MAYBE_UNUSED(VALUE str), 5225 MAYBE_UNUSED(CALL_INFO ci), 5226 MAYBE_UNUSED(CALL_CACHE cc) 5227) 5228{ 5229 return insn_name(BIN(opt_str_freeze)); 5230} 5231 5232/* attr rb_num_t open @ opt_str_freeze(str, ci, cc)()(val) */ 5233rb_num_t 5234attr_open_opt_str_freeze( 5235 MAYBE_UNUSED(VALUE str), 5236 MAYBE_UNUSED(CALL_INFO ci), 5237 MAYBE_UNUSED(CALL_CACHE cc) 5238) 5239{ 5240 return 3; 5241} 5242 5243/* attr rb_num_t popn @ opt_str_freeze(str, ci, cc)()(val) */ 5244rb_num_t 5245attr_popn_opt_str_freeze( 5246 MAYBE_UNUSED(VALUE str), 5247 MAYBE_UNUSED(CALL_INFO ci), 5248 MAYBE_UNUSED(CALL_CACHE cc) 5249) 5250{ 5251 return 0; 5252} 5253 5254/* attr rb_num_t retn @ opt_str_freeze(str, ci, cc)()(val) */ 5255rb_num_t 5256attr_retn_opt_str_freeze( 5257 MAYBE_UNUSED(VALUE str), 5258 MAYBE_UNUSED(CALL_INFO ci), 5259 MAYBE_UNUSED(CALL_CACHE cc) 5260) 5261{ 5262 return 1; 5263} 5264 5265/* attr rb_snum_t sp_inc @ opt_str_freeze(str, ci, cc)()(val) */ 5266rb_snum_t 5267attr_sp_inc_opt_str_freeze( 5268 MAYBE_UNUSED(VALUE str), 5269 MAYBE_UNUSED(CALL_INFO ci), 5270 MAYBE_UNUSED(CALL_CACHE cc) 5271) 5272{ 5273 return 1; 5274} 5275 5276/* attr rb_num_t width @ opt_str_freeze(str, ci, cc)()(val) */ 5277rb_num_t 5278attr_width_opt_str_freeze( 5279 MAYBE_UNUSED(VALUE str), 5280 MAYBE_UNUSED(CALL_INFO ci), 5281 MAYBE_UNUSED(CALL_CACHE cc) 5282) 5283{ 5284 return 4; 5285} 5286 5287/* attr enum ruby_vminsn_type bin @ opt_str_uminus(str, ci, cc)()(val) */ 5288enum ruby_vminsn_type 5289attr_bin_opt_str_uminus( 5290 MAYBE_UNUSED(VALUE str), 5291 MAYBE_UNUSED(CALL_INFO ci), 5292 MAYBE_UNUSED(CALL_CACHE cc) 5293) 5294{ 5295 return BIN(opt_str_uminus); 5296} 5297 5298/* attr bool handles_sp @ opt_str_uminus(str, ci, cc)()(val) */ 5299bool 5300attr_handles_sp_opt_str_uminus( 5301 MAYBE_UNUSED(VALUE str), 5302 MAYBE_UNUSED(CALL_INFO ci), 5303 MAYBE_UNUSED(CALL_CACHE cc) 5304) 5305{ 5306 return false; 5307} 5308 5309/* attr bool leaf @ opt_str_uminus(str, ci, cc)()(val) */ 5310bool 5311attr_leaf_opt_str_uminus( 5312 MAYBE_UNUSED(VALUE str), 5313 MAYBE_UNUSED(CALL_INFO ci), 5314 MAYBE_UNUSED(CALL_CACHE cc) 5315) 5316{ 5317 return true; 5318} 5319 5320/* attr const char* name @ opt_str_uminus(str, ci, cc)()(val) */ 5321const char* 5322attr_name_opt_str_uminus( 5323 MAYBE_UNUSED(VALUE str), 5324 MAYBE_UNUSED(CALL_INFO ci), 5325 MAYBE_UNUSED(CALL_CACHE cc) 5326) 5327{ 5328 return insn_name(BIN(opt_str_uminus)); 5329} 5330 5331/* attr rb_num_t open @ opt_str_uminus(str, ci, cc)()(val) */ 5332rb_num_t 5333attr_open_opt_str_uminus( 5334 MAYBE_UNUSED(VALUE str), 5335 MAYBE_UNUSED(CALL_INFO ci), 5336 MAYBE_UNUSED(CALL_CACHE cc) 5337) 5338{ 5339 return 3; 5340} 5341 5342/* attr rb_num_t popn @ opt_str_uminus(str, ci, cc)()(val) */ 5343rb_num_t 5344attr_popn_opt_str_uminus( 5345 MAYBE_UNUSED(VALUE str), 5346 MAYBE_UNUSED(CALL_INFO ci), 5347 MAYBE_UNUSED(CALL_CACHE cc) 5348) 5349{ 5350 return 0; 5351} 5352 5353/* attr rb_num_t retn @ opt_str_uminus(str, ci, cc)()(val) */ 5354rb_num_t 5355attr_retn_opt_str_uminus( 5356 MAYBE_UNUSED(VALUE str), 5357 MAYBE_UNUSED(CALL_INFO ci), 5358 MAYBE_UNUSED(CALL_CACHE cc) 5359) 5360{ 5361 return 1; 5362} 5363 5364/* attr rb_snum_t sp_inc @ opt_str_uminus(str, ci, cc)()(val) */ 5365rb_snum_t 5366attr_sp_inc_opt_str_uminus( 5367 MAYBE_UNUSED(VALUE str), 5368 MAYBE_UNUSED(CALL_INFO ci), 5369 MAYBE_UNUSED(CALL_CACHE cc) 5370) 5371{ 5372 return 1; 5373} 5374 5375/* attr rb_num_t width @ opt_str_uminus(str, ci, cc)()(val) */ 5376rb_num_t 5377attr_width_opt_str_uminus( 5378 MAYBE_UNUSED(VALUE str), 5379 MAYBE_UNUSED(CALL_INFO ci), 5380 MAYBE_UNUSED(CALL_CACHE cc) 5381) 5382{ 5383 return 4; 5384} 5385 5386/* attr enum ruby_vminsn_type bin @ opt_newarray_max(num)(...)(val) */ 5387enum ruby_vminsn_type 5388attr_bin_opt_newarray_max(MAYBE_UNUSED(rb_num_t num)) 5389{ 5390 return BIN(opt_newarray_max); 5391} 5392 5393/* attr bool handles_sp @ opt_newarray_max(num)(...)(val) */ 5394bool 5395attr_handles_sp_opt_newarray_max(MAYBE_UNUSED(rb_num_t num)) 5396{ 5397 return false; 5398} 5399 5400/* attr bool leaf @ opt_newarray_max(num)(...)(val) */ 5401bool 5402attr_leaf_opt_newarray_max(MAYBE_UNUSED(rb_num_t num)) 5403{ 5404 return 5405#line 805 "insns.def" 5406false; 5407#line 5408 "insns_info.inc" 5408} 5409 5410/* attr const char* name @ opt_newarray_max(num)(...)(val) */ 5411const char* 5412attr_name_opt_newarray_max(MAYBE_UNUSED(rb_num_t num)) 5413{ 5414 return insn_name(BIN(opt_newarray_max)); 5415} 5416 5417/* attr rb_num_t open @ opt_newarray_max(num)(...)(val) */ 5418rb_num_t 5419attr_open_opt_newarray_max(MAYBE_UNUSED(rb_num_t num)) 5420{ 5421 return 1; 5422} 5423 5424/* attr rb_num_t popn @ opt_newarray_max(num)(...)(val) */ 5425rb_num_t 5426attr_popn_opt_newarray_max(MAYBE_UNUSED(rb_num_t num)) 5427{ 5428 return 0; 5429} 5430 5431/* attr rb_num_t retn @ opt_newarray_max(num)(...)(val) */ 5432rb_num_t 5433attr_retn_opt_newarray_max(MAYBE_UNUSED(rb_num_t num)) 5434{ 5435 return 1; 5436} 5437 5438/* attr rb_snum_t sp_inc @ opt_newarray_max(num)(...)(val) */ 5439rb_snum_t 5440attr_sp_inc_opt_newarray_max(MAYBE_UNUSED(rb_num_t num)) 5441{ 5442 return 5443#line 806 "insns.def" 54441 - (rb_snum_t)num; 5445#line 5446 "insns_info.inc" 5446} 5447 5448/* attr rb_num_t width @ opt_newarray_max(num)(...)(val) */ 5449rb_num_t 5450attr_width_opt_newarray_max(MAYBE_UNUSED(rb_num_t num)) 5451{ 5452 return 2; 5453} 5454 5455/* attr enum ruby_vminsn_type bin @ opt_newarray_min(num)(...)(val) */ 5456enum ruby_vminsn_type 5457attr_bin_opt_newarray_min(MAYBE_UNUSED(rb_num_t num)) 5458{ 5459 return BIN(opt_newarray_min); 5460} 5461 5462/* attr bool handles_sp @ opt_newarray_min(num)(...)(val) */ 5463bool 5464attr_handles_sp_opt_newarray_min(MAYBE_UNUSED(rb_num_t num)) 5465{ 5466 return false; 5467} 5468 5469/* attr bool leaf @ opt_newarray_min(num)(...)(val) */ 5470bool 5471attr_leaf_opt_newarray_min(MAYBE_UNUSED(rb_num_t num)) 5472{ 5473 return 5474#line 817 "insns.def" 5475false; 5476#line 5477 "insns_info.inc" 5477} 5478 5479/* attr const char* name @ opt_newarray_min(num)(...)(val) */ 5480const char* 5481attr_name_opt_newarray_min(MAYBE_UNUSED(rb_num_t num)) 5482{ 5483 return insn_name(BIN(opt_newarray_min)); 5484} 5485 5486/* attr rb_num_t open @ opt_newarray_min(num)(...)(val) */ 5487rb_num_t 5488attr_open_opt_newarray_min(MAYBE_UNUSED(rb_num_t num)) 5489{ 5490 return 1; 5491} 5492 5493/* attr rb_num_t popn @ opt_newarray_min(num)(...)(val) */ 5494rb_num_t 5495attr_popn_opt_newarray_min(MAYBE_UNUSED(rb_num_t num)) 5496{ 5497 return 0; 5498} 5499 5500/* attr rb_num_t retn @ opt_newarray_min(num)(...)(val) */ 5501rb_num_t 5502attr_retn_opt_newarray_min(MAYBE_UNUSED(rb_num_t num)) 5503{ 5504 return 1; 5505} 5506 5507/* attr rb_snum_t sp_inc @ opt_newarray_min(num)(...)(val) */ 5508rb_snum_t 5509attr_sp_inc_opt_newarray_min(MAYBE_UNUSED(rb_num_t num)) 5510{ 5511 return 5512#line 818 "insns.def" 55131 - (rb_snum_t)num; 5514#line 5515 "insns_info.inc" 5515} 5516 5517/* attr rb_num_t width @ opt_newarray_min(num)(...)(val) */ 5518rb_num_t 5519attr_width_opt_newarray_min(MAYBE_UNUSED(rb_num_t num)) 5520{ 5521 return 2; 5522} 5523 5524/* attr enum ruby_vminsn_type bin @ invokesuper(ci, cc, blockiseq)(...)(val) */ 5525enum ruby_vminsn_type 5526attr_bin_invokesuper( 5527 MAYBE_UNUSED(CALL_INFO ci), 5528 MAYBE_UNUSED(CALL_CACHE cc), 5529 MAYBE_UNUSED(ISEQ blockiseq) 5530) 5531{ 5532 return BIN(invokesuper); 5533} 5534 5535/* attr bool handles_sp @ invokesuper(ci, cc, blockiseq)(...)(val) */ 5536bool 5537attr_handles_sp_invokesuper( 5538 MAYBE_UNUSED(CALL_INFO ci), 5539 MAYBE_UNUSED(CALL_CACHE cc), 5540 MAYBE_UNUSED(ISEQ blockiseq) 5541) 5542{ 5543 return true; 5544} 5545 5546/* attr bool leaf @ invokesuper(ci, cc, blockiseq)(...)(val) */ 5547bool 5548attr_leaf_invokesuper( 5549 MAYBE_UNUSED(CALL_INFO ci), 5550 MAYBE_UNUSED(CALL_CACHE cc), 5551 MAYBE_UNUSED(ISEQ blockiseq) 5552) 5553{ 5554 return false; 5555} 5556 5557/* attr const char* name @ invokesuper(ci, cc, blockiseq)(...)(val) */ 5558const char* 5559attr_name_invokesuper( 5560 MAYBE_UNUSED(CALL_INFO ci), 5561 MAYBE_UNUSED(CALL_CACHE cc), 5562 MAYBE_UNUSED(ISEQ blockiseq) 5563) 5564{ 5565 return insn_name(BIN(invokesuper)); 5566} 5567 5568/* attr rb_num_t open @ invokesuper(ci, cc, blockiseq)(...)(val) */ 5569rb_num_t 5570attr_open_invokesuper( 5571 MAYBE_UNUSED(CALL_INFO ci), 5572 MAYBE_UNUSED(CALL_CACHE cc), 5573 MAYBE_UNUSED(ISEQ blockiseq) 5574) 5575{ 5576 return 3; 5577} 5578 5579/* attr rb_num_t popn @ invokesuper(ci, cc, blockiseq)(...)(val) */ 5580rb_num_t 5581attr_popn_invokesuper( 5582 MAYBE_UNUSED(CALL_INFO ci), 5583 MAYBE_UNUSED(CALL_CACHE cc), 5584 MAYBE_UNUSED(ISEQ blockiseq) 5585) 5586{ 5587 return 0; 5588} 5589 5590/* attr rb_num_t retn @ invokesuper(ci, cc, blockiseq)(...)(val) */ 5591rb_num_t 5592attr_retn_invokesuper( 5593 MAYBE_UNUSED(CALL_INFO ci), 5594 MAYBE_UNUSED(CALL_CACHE cc), 5595 MAYBE_UNUSED(ISEQ blockiseq) 5596) 5597{ 5598 return 1; 5599} 5600 5601/* attr rb_snum_t sp_inc @ invokesuper(ci, cc, blockiseq)(...)(val) */ 5602rb_snum_t 5603attr_sp_inc_invokesuper( 5604 MAYBE_UNUSED(CALL_INFO ci), 5605 MAYBE_UNUSED(CALL_CACHE cc), 5606 MAYBE_UNUSED(ISEQ blockiseq) 5607) 5608{ 5609 return 5610#line 829 "insns.def" 5611- (int)(ci->orig_argc + ((ci->flag & VM_CALL_ARGS_BLOCKARG) ? 1 : 0)); 5612#line 5613 "insns_info.inc" 5613} 5614 5615/* attr rb_num_t width @ invokesuper(ci, cc, blockiseq)(...)(val) */ 5616rb_num_t 5617attr_width_invokesuper( 5618 MAYBE_UNUSED(CALL_INFO ci), 5619 MAYBE_UNUSED(CALL_CACHE cc), 5620 MAYBE_UNUSED(ISEQ blockiseq) 5621) 5622{ 5623 return 4; 5624} 5625 5626/* attr enum ruby_vminsn_type bin @ invokeblock(ci)(...)(val) */ 5627enum ruby_vminsn_type 5628attr_bin_invokeblock(MAYBE_UNUSED(CALL_INFO ci)) 5629{ 5630 return BIN(invokeblock); 5631} 5632 5633/* attr bool handles_sp @ invokeblock(ci)(...)(val) */ 5634bool 5635attr_handles_sp_invokeblock(MAYBE_UNUSED(CALL_INFO ci)) 5636{ 5637 return 5638#line 845 "insns.def" 5639true; 5640#line 5641 "insns_info.inc" 5641} 5642 5643/* attr bool leaf @ invokeblock(ci)(...)(val) */ 5644bool 5645attr_leaf_invokeblock(MAYBE_UNUSED(CALL_INFO ci)) 5646{ 5647 return ! attr_handles_sp_invokeblock(ci); 5648} 5649 5650/* attr const char* name @ invokeblock(ci)(...)(val) */ 5651const char* 5652attr_name_invokeblock(MAYBE_UNUSED(CALL_INFO ci)) 5653{ 5654 return insn_name(BIN(invokeblock)); 5655} 5656 5657/* attr rb_num_t open @ invokeblock(ci)(...)(val) */ 5658rb_num_t 5659attr_open_invokeblock(MAYBE_UNUSED(CALL_INFO ci)) 5660{ 5661 return 1; 5662} 5663 5664/* attr rb_num_t popn @ invokeblock(ci)(...)(val) */ 5665rb_num_t 5666attr_popn_invokeblock(MAYBE_UNUSED(CALL_INFO ci)) 5667{ 5668 return 0; 5669} 5670 5671/* attr rb_num_t retn @ invokeblock(ci)(...)(val) */ 5672rb_num_t 5673attr_retn_invokeblock(MAYBE_UNUSED(CALL_INFO ci)) 5674{ 5675 return 1; 5676} 5677 5678/* attr rb_snum_t sp_inc @ invokeblock(ci)(...)(val) */ 5679rb_snum_t 5680attr_sp_inc_invokeblock(MAYBE_UNUSED(CALL_INFO ci)) 5681{ 5682 return 5683#line 846 "insns.def" 56841 - ci->orig_argc; 5685#line 5686 "insns_info.inc" 5686} 5687 5688/* attr rb_num_t width @ invokeblock(ci)(...)(val) */ 5689rb_num_t 5690attr_width_invokeblock(MAYBE_UNUSED(CALL_INFO ci)) 5691{ 5692 return 2; 5693} 5694 5695/* attr enum ruby_vminsn_type bin @ leave()(val)(val) */ 5696enum ruby_vminsn_type 5697attr_bin_leave(void) 5698{ 5699 return BIN(leave); 5700} 5701 5702/* attr bool handles_sp @ leave()(val)(val) */ 5703bool 5704attr_handles_sp_leave(void) 5705{ 5706 return 5707#line 876 "insns.def" 5708true; 5709#line 5710 "insns_info.inc" 5710} 5711 5712/* attr bool leaf @ leave()(val)(val) */ 5713bool 5714attr_leaf_leave(void) 5715{ 5716 return 5717#line 875 "insns.def" 5718false; 5719#line 5720 "insns_info.inc" 5720} 5721 5722/* attr const char* name @ leave()(val)(val) */ 5723const char* 5724attr_name_leave(void) 5725{ 5726 return insn_name(BIN(leave)); 5727} 5728 5729/* attr rb_num_t open @ leave()(val)(val) */ 5730rb_num_t 5731attr_open_leave(void) 5732{ 5733 return 0; 5734} 5735 5736/* attr rb_num_t popn @ leave()(val)(val) */ 5737rb_num_t 5738attr_popn_leave(void) 5739{ 5740 return 1; 5741} 5742 5743/* attr rb_num_t retn @ leave()(val)(val) */ 5744rb_num_t 5745attr_retn_leave(void) 5746{ 5747 return 1; 5748} 5749 5750/* attr rb_snum_t sp_inc @ leave()(val)(val) */ 5751rb_snum_t 5752attr_sp_inc_leave(void) 5753{ 5754 return 0; 5755} 5756 5757/* attr rb_num_t width @ leave()(val)(val) */ 5758rb_num_t 5759attr_width_leave(void) 5760{ 5761 return 1; 5762} 5763 5764/* attr enum ruby_vminsn_type bin @ throw(throw_state)(throwobj)(val) */ 5765enum ruby_vminsn_type 5766attr_bin_throw(MAYBE_UNUSED(rb_num_t throw_state)) 5767{ 5768 return BIN(throw); 5769} 5770 5771/* attr bool handles_sp @ throw(throw_state)(throwobj)(val) */ 5772bool 5773attr_handles_sp_throw(MAYBE_UNUSED(rb_num_t throw_state)) 5774{ 5775 return false; 5776} 5777 5778/* attr bool leaf @ throw(throw_state)(throwobj)(val) */ 5779bool 5780attr_leaf_throw(MAYBE_UNUSED(rb_num_t throw_state)) 5781{ 5782 return 5783#line 911 "insns.def" 5784false; 5785#line 5786 "insns_info.inc" 5786} 5787 5788/* attr const char* name @ throw(throw_state)(throwobj)(val) */ 5789const char* 5790attr_name_throw(MAYBE_UNUSED(rb_num_t throw_state)) 5791{ 5792 return insn_name(BIN(throw)); 5793} 5794 5795/* attr rb_num_t open @ throw(throw_state)(throwobj)(val) */ 5796rb_num_t 5797attr_open_throw(MAYBE_UNUSED(rb_num_t throw_state)) 5798{ 5799 return 1; 5800} 5801 5802/* attr rb_num_t popn @ throw(throw_state)(throwobj)(val) */ 5803rb_num_t 5804attr_popn_throw(MAYBE_UNUSED(rb_num_t throw_state)) 5805{ 5806 return 1; 5807} 5808 5809/* attr rb_num_t retn @ throw(throw_state)(throwobj)(val) */ 5810rb_num_t 5811attr_retn_throw(MAYBE_UNUSED(rb_num_t throw_state)) 5812{ 5813 return 1; 5814} 5815 5816/* attr rb_snum_t sp_inc @ throw(throw_state)(throwobj)(val) */ 5817rb_snum_t 5818attr_sp_inc_throw(MAYBE_UNUSED(rb_num_t throw_state)) 5819{ 5820 return 0; 5821} 5822 5823/* attr rb_num_t width @ throw(throw_state)(throwobj)(val) */ 5824rb_num_t 5825attr_width_throw(MAYBE_UNUSED(rb_num_t throw_state)) 5826{ 5827 return 2; 5828} 5829 5830/* attr enum ruby_vminsn_type bin @ jump(dst)()() */ 5831enum ruby_vminsn_type 5832attr_bin_jump(MAYBE_UNUSED(OFFSET dst)) 5833{ 5834 return BIN(jump); 5835} 5836 5837/* attr bool handles_sp @ jump(dst)()() */ 5838bool 5839attr_handles_sp_jump(MAYBE_UNUSED(OFFSET dst)) 5840{ 5841 return false; 5842} 5843 5844/* attr bool leaf @ jump(dst)()() */ 5845bool 5846attr_leaf_jump(MAYBE_UNUSED(OFFSET dst)) 5847{ 5848 return 5849#line 930 "insns.def" 5850false; 5851#line 5852 "insns_info.inc" 5852} 5853 5854/* attr const char* name @ jump(dst)()() */ 5855const char* 5856attr_name_jump(MAYBE_UNUSED(OFFSET dst)) 5857{ 5858 return insn_name(BIN(jump)); 5859} 5860 5861/* attr rb_num_t open @ jump(dst)()() */ 5862rb_num_t 5863attr_open_jump(MAYBE_UNUSED(OFFSET dst)) 5864{ 5865 return 1; 5866} 5867 5868/* attr rb_num_t popn @ jump(dst)()() */ 5869rb_num_t 5870attr_popn_jump(MAYBE_UNUSED(OFFSET dst)) 5871{ 5872 return 0; 5873} 5874 5875/* attr rb_num_t retn @ jump(dst)()() */ 5876rb_num_t 5877attr_retn_jump(MAYBE_UNUSED(OFFSET dst)) 5878{ 5879 return 0; 5880} 5881 5882/* attr rb_snum_t sp_inc @ jump(dst)()() */ 5883rb_snum_t 5884attr_sp_inc_jump(MAYBE_UNUSED(OFFSET dst)) 5885{ 5886 return 0; 5887} 5888 5889/* attr rb_num_t width @ jump(dst)()() */ 5890rb_num_t 5891attr_width_jump(MAYBE_UNUSED(OFFSET dst)) 5892{ 5893 return 2; 5894} 5895 5896/* attr enum ruby_vminsn_type bin @ branchif(dst)(val)() */ 5897enum ruby_vminsn_type 5898attr_bin_branchif(MAYBE_UNUSED(OFFSET dst)) 5899{ 5900 return BIN(branchif); 5901} 5902 5903/* attr bool handles_sp @ branchif(dst)(val)() */ 5904bool 5905attr_handles_sp_branchif(MAYBE_UNUSED(OFFSET dst)) 5906{ 5907 return false; 5908} 5909 5910/* attr bool leaf @ branchif(dst)(val)() */ 5911bool 5912attr_leaf_branchif(MAYBE_UNUSED(OFFSET dst)) 5913{ 5914 return 5915#line 943 "insns.def" 5916false; 5917#line 5918 "insns_info.inc" 5918} 5919 5920/* attr const char* name @ branchif(dst)(val)() */ 5921const char* 5922attr_name_branchif(MAYBE_UNUSED(OFFSET dst)) 5923{ 5924 return insn_name(BIN(branchif)); 5925} 5926 5927/* attr rb_num_t open @ branchif(dst)(val)() */ 5928rb_num_t 5929attr_open_branchif(MAYBE_UNUSED(OFFSET dst)) 5930{ 5931 return 1; 5932} 5933 5934/* attr rb_num_t popn @ branchif(dst)(val)() */ 5935rb_num_t 5936attr_popn_branchif(MAYBE_UNUSED(OFFSET dst)) 5937{ 5938 return 1; 5939} 5940 5941/* attr rb_num_t retn @ branchif(dst)(val)() */ 5942rb_num_t 5943attr_retn_branchif(MAYBE_UNUSED(OFFSET dst)) 5944{ 5945 return 0; 5946} 5947 5948/* attr rb_snum_t sp_inc @ branchif(dst)(val)() */ 5949rb_snum_t 5950attr_sp_inc_branchif(MAYBE_UNUSED(OFFSET dst)) 5951{ 5952 return -1; 5953} 5954 5955/* attr rb_num_t width @ branchif(dst)(val)() */ 5956rb_num_t 5957attr_width_branchif(MAYBE_UNUSED(OFFSET dst)) 5958{ 5959 return 2; 5960} 5961 5962/* attr enum ruby_vminsn_type bin @ branchunless(dst)(val)() */ 5963enum ruby_vminsn_type 5964attr_bin_branchunless(MAYBE_UNUSED(OFFSET dst)) 5965{ 5966 return BIN(branchunless); 5967} 5968 5969/* attr bool handles_sp @ branchunless(dst)(val)() */ 5970bool 5971attr_handles_sp_branchunless(MAYBE_UNUSED(OFFSET dst)) 5972{ 5973 return false; 5974} 5975 5976/* attr bool leaf @ branchunless(dst)(val)() */ 5977bool 5978attr_leaf_branchunless(MAYBE_UNUSED(OFFSET dst)) 5979{ 5980 return 5981#line 958 "insns.def" 5982false; 5983#line 5984 "insns_info.inc" 5984} 5985 5986/* attr const char* name @ branchunless(dst)(val)() */ 5987const char* 5988attr_name_branchunless(MAYBE_UNUSED(OFFSET dst)) 5989{ 5990 return insn_name(BIN(branchunless)); 5991} 5992 5993/* attr rb_num_t open @ branchunless(dst)(val)() */ 5994rb_num_t 5995attr_open_branchunless(MAYBE_UNUSED(OFFSET dst)) 5996{ 5997 return 1; 5998} 5999 6000/* attr rb_num_t popn @ branchunless(dst)(val)() */ 6001rb_num_t 6002attr_popn_branchunless(MAYBE_UNUSED(OFFSET dst)) 6003{ 6004 return 1; 6005} 6006 6007/* attr rb_num_t retn @ branchunless(dst)(val)() */ 6008rb_num_t 6009attr_retn_branchunless(MAYBE_UNUSED(OFFSET dst)) 6010{ 6011 return 0; 6012} 6013 6014/* attr rb_snum_t sp_inc @ branchunless(dst)(val)() */ 6015rb_snum_t 6016attr_sp_inc_branchunless(MAYBE_UNUSED(OFFSET dst)) 6017{ 6018 return -1; 6019} 6020 6021/* attr rb_num_t width @ branchunless(dst)(val)() */ 6022rb_num_t 6023attr_width_branchunless(MAYBE_UNUSED(OFFSET dst)) 6024{ 6025 return 2; 6026} 6027 6028/* attr enum ruby_vminsn_type bin @ branchnil(dst)(val)() */ 6029enum ruby_vminsn_type 6030attr_bin_branchnil(MAYBE_UNUSED(OFFSET dst)) 6031{ 6032 return BIN(branchnil); 6033} 6034 6035/* attr bool handles_sp @ branchnil(dst)(val)() */ 6036bool 6037attr_handles_sp_branchnil(MAYBE_UNUSED(OFFSET dst)) 6038{ 6039 return false; 6040} 6041 6042/* attr bool leaf @ branchnil(dst)(val)() */ 6043bool 6044attr_leaf_branchnil(MAYBE_UNUSED(OFFSET dst)) 6045{ 6046 return 6047#line 973 "insns.def" 6048false; 6049#line 6050 "insns_info.inc" 6050} 6051 6052/* attr const char* name @ branchnil(dst)(val)() */ 6053const char* 6054attr_name_branchnil(MAYBE_UNUSED(OFFSET dst)) 6055{ 6056 return insn_name(BIN(branchnil)); 6057} 6058 6059/* attr rb_num_t open @ branchnil(dst)(val)() */ 6060rb_num_t 6061attr_open_branchnil(MAYBE_UNUSED(OFFSET dst)) 6062{ 6063 return 1; 6064} 6065 6066/* attr rb_num_t popn @ branchnil(dst)(val)() */ 6067rb_num_t 6068attr_popn_branchnil(MAYBE_UNUSED(OFFSET dst)) 6069{ 6070 return 1; 6071} 6072 6073/* attr rb_num_t retn @ branchnil(dst)(val)() */ 6074rb_num_t 6075attr_retn_branchnil(MAYBE_UNUSED(OFFSET dst)) 6076{ 6077 return 0; 6078} 6079 6080/* attr rb_snum_t sp_inc @ branchnil(dst)(val)() */ 6081rb_snum_t 6082attr_sp_inc_branchnil(MAYBE_UNUSED(OFFSET dst)) 6083{ 6084 return -1; 6085} 6086 6087/* attr rb_num_t width @ branchnil(dst)(val)() */ 6088rb_num_t 6089attr_width_branchnil(MAYBE_UNUSED(OFFSET dst)) 6090{ 6091 return 2; 6092} 6093 6094/* attr enum ruby_vminsn_type bin @ opt_getinlinecache(dst, ic)()(val) */ 6095enum ruby_vminsn_type 6096attr_bin_opt_getinlinecache( 6097 MAYBE_UNUSED(OFFSET dst), 6098 MAYBE_UNUSED(IC ic) 6099) 6100{ 6101 return BIN(opt_getinlinecache); 6102} 6103 6104/* attr bool handles_sp @ opt_getinlinecache(dst, ic)()(val) */ 6105bool 6106attr_handles_sp_opt_getinlinecache( 6107 MAYBE_UNUSED(OFFSET dst), 6108 MAYBE_UNUSED(IC ic) 6109) 6110{ 6111 return false; 6112} 6113 6114/* attr bool leaf @ opt_getinlinecache(dst, ic)()(val) */ 6115bool 6116attr_leaf_opt_getinlinecache( 6117 MAYBE_UNUSED(OFFSET dst), 6118 MAYBE_UNUSED(IC ic) 6119) 6120{ 6121 return true; 6122} 6123 6124/* attr const char* name @ opt_getinlinecache(dst, ic)()(val) */ 6125const char* 6126attr_name_opt_getinlinecache( 6127 MAYBE_UNUSED(OFFSET dst), 6128 MAYBE_UNUSED(IC ic) 6129) 6130{ 6131 return insn_name(BIN(opt_getinlinecache)); 6132} 6133 6134/* attr rb_num_t open @ opt_getinlinecache(dst, ic)()(val) */ 6135rb_num_t 6136attr_open_opt_getinlinecache( 6137 MAYBE_UNUSED(OFFSET dst), 6138 MAYBE_UNUSED(IC ic) 6139) 6140{ 6141 return 2; 6142} 6143 6144/* attr rb_num_t popn @ opt_getinlinecache(dst, ic)()(val) */ 6145rb_num_t 6146attr_popn_opt_getinlinecache( 6147 MAYBE_UNUSED(OFFSET dst), 6148 MAYBE_UNUSED(IC ic) 6149) 6150{ 6151 return 0; 6152} 6153 6154/* attr rb_num_t retn @ opt_getinlinecache(dst, ic)()(val) */ 6155rb_num_t 6156attr_retn_opt_getinlinecache( 6157 MAYBE_UNUSED(OFFSET dst), 6158 MAYBE_UNUSED(IC ic) 6159) 6160{ 6161 return 1; 6162} 6163 6164/* attr rb_snum_t sp_inc @ opt_getinlinecache(dst, ic)()(val) */ 6165rb_snum_t 6166attr_sp_inc_opt_getinlinecache( 6167 MAYBE_UNUSED(OFFSET dst), 6168 MAYBE_UNUSED(IC ic) 6169) 6170{ 6171 return 1; 6172} 6173 6174/* attr rb_num_t width @ opt_getinlinecache(dst, ic)()(val) */ 6175rb_num_t 6176attr_width_opt_getinlinecache( 6177 MAYBE_UNUSED(OFFSET dst), 6178 MAYBE_UNUSED(IC ic) 6179) 6180{ 6181 return 3; 6182} 6183 6184/* attr enum ruby_vminsn_type bin @ opt_setinlinecache(ic)(val)(val) */ 6185enum ruby_vminsn_type 6186attr_bin_opt_setinlinecache(MAYBE_UNUSED(IC ic)) 6187{ 6188 return BIN(opt_setinlinecache); 6189} 6190 6191/* attr bool handles_sp @ opt_setinlinecache(ic)(val)(val) */ 6192bool 6193attr_handles_sp_opt_setinlinecache(MAYBE_UNUSED(IC ic)) 6194{ 6195 return false; 6196} 6197 6198/* attr bool leaf @ opt_setinlinecache(ic)(val)(val) */ 6199bool 6200attr_leaf_opt_setinlinecache(MAYBE_UNUSED(IC ic)) 6201{ 6202 return true; 6203} 6204 6205/* attr const char* name @ opt_setinlinecache(ic)(val)(val) */ 6206const char* 6207attr_name_opt_setinlinecache(MAYBE_UNUSED(IC ic)) 6208{ 6209 return insn_name(BIN(opt_setinlinecache)); 6210} 6211 6212/* attr rb_num_t open @ opt_setinlinecache(ic)(val)(val) */ 6213rb_num_t 6214attr_open_opt_setinlinecache(MAYBE_UNUSED(IC ic)) 6215{ 6216 return 1; 6217} 6218 6219/* attr rb_num_t popn @ opt_setinlinecache(ic)(val)(val) */ 6220rb_num_t 6221attr_popn_opt_setinlinecache(MAYBE_UNUSED(IC ic)) 6222{ 6223 return 1; 6224} 6225 6226/* attr rb_num_t retn @ opt_setinlinecache(ic)(val)(val) */ 6227rb_num_t 6228attr_retn_opt_setinlinecache(MAYBE_UNUSED(IC ic)) 6229{ 6230 return 1; 6231} 6232 6233/* attr rb_snum_t sp_inc @ opt_setinlinecache(ic)(val)(val) */ 6234rb_snum_t 6235attr_sp_inc_opt_setinlinecache(MAYBE_UNUSED(IC ic)) 6236{ 6237 return 0; 6238} 6239 6240/* attr rb_num_t width @ opt_setinlinecache(ic)(val)(val) */ 6241rb_num_t 6242attr_width_opt_setinlinecache(MAYBE_UNUSED(IC ic)) 6243{ 6244 return 2; 6245} 6246 6247/* attr enum ruby_vminsn_type bin @ once(iseq, ise)()(val) */ 6248enum ruby_vminsn_type 6249attr_bin_once( 6250 MAYBE_UNUSED(ISEQ iseq), 6251 MAYBE_UNUSED(ISE ise) 6252) 6253{ 6254 return BIN(once); 6255} 6256 6257/* attr bool handles_sp @ once(iseq, ise)()(val) */ 6258bool 6259attr_handles_sp_once( 6260 MAYBE_UNUSED(ISEQ iseq), 6261 MAYBE_UNUSED(ISE ise) 6262) 6263{ 6264 return true; 6265} 6266 6267/* attr bool leaf @ once(iseq, ise)()(val) */ 6268bool 6269attr_leaf_once( 6270 MAYBE_UNUSED(ISEQ iseq), 6271 MAYBE_UNUSED(ISE ise) 6272) 6273{ 6274 return false; 6275} 6276 6277/* attr const char* name @ once(iseq, ise)()(val) */ 6278const char* 6279attr_name_once( 6280 MAYBE_UNUSED(ISEQ iseq), 6281 MAYBE_UNUSED(ISE ise) 6282) 6283{ 6284 return insn_name(BIN(once)); 6285} 6286 6287/* attr rb_num_t open @ once(iseq, ise)()(val) */ 6288rb_num_t 6289attr_open_once( 6290 MAYBE_UNUSED(ISEQ iseq), 6291 MAYBE_UNUSED(ISE ise) 6292) 6293{ 6294 return 2; 6295} 6296 6297/* attr rb_num_t popn @ once(iseq, ise)()(val) */ 6298rb_num_t 6299attr_popn_once( 6300 MAYBE_UNUSED(ISEQ iseq), 6301 MAYBE_UNUSED(ISE ise) 6302) 6303{ 6304 return 0; 6305} 6306 6307/* attr rb_num_t retn @ once(iseq, ise)()(val) */ 6308rb_num_t 6309attr_retn_once( 6310 MAYBE_UNUSED(ISEQ iseq), 6311 MAYBE_UNUSED(ISE ise) 6312) 6313{ 6314 return 1; 6315} 6316 6317/* attr rb_snum_t sp_inc @ once(iseq, ise)()(val) */ 6318rb_snum_t 6319attr_sp_inc_once( 6320 MAYBE_UNUSED(ISEQ iseq), 6321 MAYBE_UNUSED(ISE ise) 6322) 6323{ 6324 return 1; 6325} 6326 6327/* attr rb_num_t width @ once(iseq, ise)()(val) */ 6328rb_num_t 6329attr_width_once( 6330 MAYBE_UNUSED(ISEQ iseq), 6331 MAYBE_UNUSED(ISE ise) 6332) 6333{ 6334 return 3; 6335} 6336 6337/* attr enum ruby_vminsn_type bin @ opt_case_dispatch(hash, else_offset)(..., key)() */ 6338enum ruby_vminsn_type 6339attr_bin_opt_case_dispatch( 6340 MAYBE_UNUSED(CDHASH hash), 6341 MAYBE_UNUSED(OFFSET else_offset) 6342) 6343{ 6344 return BIN(opt_case_dispatch); 6345} 6346 6347/* attr bool handles_sp @ opt_case_dispatch(hash, else_offset)(..., key)() */ 6348bool 6349attr_handles_sp_opt_case_dispatch( 6350 MAYBE_UNUSED(CDHASH hash), 6351 MAYBE_UNUSED(OFFSET else_offset) 6352) 6353{ 6354 return false; 6355} 6356 6357/* attr bool leaf @ opt_case_dispatch(hash, else_offset)(..., key)() */ 6358bool 6359attr_leaf_opt_case_dispatch( 6360 MAYBE_UNUSED(CDHASH hash), 6361 MAYBE_UNUSED(OFFSET else_offset) 6362) 6363{ 6364 return true; 6365} 6366 6367/* attr const char* name @ opt_case_dispatch(hash, else_offset)(..., key)() */ 6368const char* 6369attr_name_opt_case_dispatch( 6370 MAYBE_UNUSED(CDHASH hash), 6371 MAYBE_UNUSED(OFFSET else_offset) 6372) 6373{ 6374 return insn_name(BIN(opt_case_dispatch)); 6375} 6376 6377/* attr rb_num_t open @ opt_case_dispatch(hash, else_offset)(..., key)() */ 6378rb_num_t 6379attr_open_opt_case_dispatch( 6380 MAYBE_UNUSED(CDHASH hash), 6381 MAYBE_UNUSED(OFFSET else_offset) 6382) 6383{ 6384 return 2; 6385} 6386 6387/* attr rb_num_t popn @ opt_case_dispatch(hash, else_offset)(..., key)() */ 6388rb_num_t 6389attr_popn_opt_case_dispatch( 6390 MAYBE_UNUSED(CDHASH hash), 6391 MAYBE_UNUSED(OFFSET else_offset) 6392) 6393{ 6394 return 1; 6395} 6396 6397/* attr rb_num_t retn @ opt_case_dispatch(hash, else_offset)(..., key)() */ 6398rb_num_t 6399attr_retn_opt_case_dispatch( 6400 MAYBE_UNUSED(CDHASH hash), 6401 MAYBE_UNUSED(OFFSET else_offset) 6402) 6403{ 6404 return 0; 6405} 6406 6407/* attr rb_snum_t sp_inc @ opt_case_dispatch(hash, else_offset)(..., key)() */ 6408rb_snum_t 6409attr_sp_inc_opt_case_dispatch( 6410 MAYBE_UNUSED(CDHASH hash), 6411 MAYBE_UNUSED(OFFSET else_offset) 6412) 6413{ 6414 return 6415#line 1027 "insns.def" 6416-1; 6417#line 6418 "insns_info.inc" 6418} 6419 6420/* attr rb_num_t width @ opt_case_dispatch(hash, else_offset)(..., key)() */ 6421rb_num_t 6422attr_width_opt_case_dispatch( 6423 MAYBE_UNUSED(CDHASH hash), 6424 MAYBE_UNUSED(OFFSET else_offset) 6425) 6426{ 6427 return 3; 6428} 6429 6430/* attr enum ruby_vminsn_type bin @ opt_plus(ci, cc)(recv, obj)(val) */ 6431enum ruby_vminsn_type 6432attr_bin_opt_plus( 6433 MAYBE_UNUSED(CALL_INFO ci), 6434 MAYBE_UNUSED(CALL_CACHE cc) 6435) 6436{ 6437 return BIN(opt_plus); 6438} 6439 6440/* attr bool handles_sp @ opt_plus(ci, cc)(recv, obj)(val) */ 6441bool 6442attr_handles_sp_opt_plus( 6443 MAYBE_UNUSED(CALL_INFO ci), 6444 MAYBE_UNUSED(CALL_CACHE cc) 6445) 6446{ 6447 return false; 6448} 6449 6450/* attr bool leaf @ opt_plus(ci, cc)(recv, obj)(val) */ 6451bool 6452attr_leaf_opt_plus( 6453 MAYBE_UNUSED(CALL_INFO ci), 6454 MAYBE_UNUSED(CALL_CACHE cc) 6455) 6456{ 6457 return 6458#line 1046 "insns.def" 6459false; 6460#line 6461 "insns_info.inc" 6461} 6462 6463/* attr const char* name @ opt_plus(ci, cc)(recv, obj)(val) */ 6464const char* 6465attr_name_opt_plus( 6466 MAYBE_UNUSED(CALL_INFO ci), 6467 MAYBE_UNUSED(CALL_CACHE cc) 6468) 6469{ 6470 return insn_name(BIN(opt_plus)); 6471} 6472 6473/* attr rb_num_t open @ opt_plus(ci, cc)(recv, obj)(val) */ 6474rb_num_t 6475attr_open_opt_plus( 6476 MAYBE_UNUSED(CALL_INFO ci), 6477 MAYBE_UNUSED(CALL_CACHE cc) 6478) 6479{ 6480 return 2; 6481} 6482 6483/* attr rb_num_t popn @ opt_plus(ci, cc)(recv, obj)(val) */ 6484rb_num_t 6485attr_popn_opt_plus( 6486 MAYBE_UNUSED(CALL_INFO ci), 6487 MAYBE_UNUSED(CALL_CACHE cc) 6488) 6489{ 6490 return 2; 6491} 6492 6493/* attr rb_num_t retn @ opt_plus(ci, cc)(recv, obj)(val) */ 6494rb_num_t 6495attr_retn_opt_plus( 6496 MAYBE_UNUSED(CALL_INFO ci), 6497 MAYBE_UNUSED(CALL_CACHE cc) 6498) 6499{ 6500 return 1; 6501} 6502 6503/* attr rb_snum_t sp_inc @ opt_plus(ci, cc)(recv, obj)(val) */ 6504rb_snum_t 6505attr_sp_inc_opt_plus( 6506 MAYBE_UNUSED(CALL_INFO ci), 6507 MAYBE_UNUSED(CALL_CACHE cc) 6508) 6509{ 6510 return -1; 6511} 6512 6513/* attr rb_num_t width @ opt_plus(ci, cc)(recv, obj)(val) */ 6514rb_num_t 6515attr_width_opt_plus( 6516 MAYBE_UNUSED(CALL_INFO ci), 6517 MAYBE_UNUSED(CALL_CACHE cc) 6518) 6519{ 6520 return 3; 6521} 6522 6523/* attr enum ruby_vminsn_type bin @ opt_minus(ci, cc)(recv, obj)(val) */ 6524enum ruby_vminsn_type 6525attr_bin_opt_minus( 6526 MAYBE_UNUSED(CALL_INFO ci), 6527 MAYBE_UNUSED(CALL_CACHE cc) 6528) 6529{ 6530 return BIN(opt_minus); 6531} 6532 6533/* attr bool handles_sp @ opt_minus(ci, cc)(recv, obj)(val) */ 6534bool 6535attr_handles_sp_opt_minus( 6536 MAYBE_UNUSED(CALL_INFO ci), 6537 MAYBE_UNUSED(CALL_CACHE cc) 6538) 6539{ 6540 return false; 6541} 6542 6543/* attr bool leaf @ opt_minus(ci, cc)(recv, obj)(val) */ 6544bool 6545attr_leaf_opt_minus( 6546 MAYBE_UNUSED(CALL_INFO ci), 6547 MAYBE_UNUSED(CALL_CACHE cc) 6548) 6549{ 6550 return true; 6551} 6552 6553/* attr const char* name @ opt_minus(ci, cc)(recv, obj)(val) */ 6554const char* 6555attr_name_opt_minus( 6556 MAYBE_UNUSED(CALL_INFO ci), 6557 MAYBE_UNUSED(CALL_CACHE cc) 6558) 6559{ 6560 return insn_name(BIN(opt_minus)); 6561} 6562 6563/* attr rb_num_t open @ opt_minus(ci, cc)(recv, obj)(val) */ 6564rb_num_t 6565attr_open_opt_minus( 6566 MAYBE_UNUSED(CALL_INFO ci), 6567 MAYBE_UNUSED(CALL_CACHE cc) 6568) 6569{ 6570 return 2; 6571} 6572 6573/* attr rb_num_t popn @ opt_minus(ci, cc)(recv, obj)(val) */ 6574rb_num_t 6575attr_popn_opt_minus( 6576 MAYBE_UNUSED(CALL_INFO ci), 6577 MAYBE_UNUSED(CALL_CACHE cc) 6578) 6579{ 6580 return 2; 6581} 6582 6583/* attr rb_num_t retn @ opt_minus(ci, cc)(recv, obj)(val) */ 6584rb_num_t 6585attr_retn_opt_minus( 6586 MAYBE_UNUSED(CALL_INFO ci), 6587 MAYBE_UNUSED(CALL_CACHE cc) 6588) 6589{ 6590 return 1; 6591} 6592 6593/* attr rb_snum_t sp_inc @ opt_minus(ci, cc)(recv, obj)(val) */ 6594rb_snum_t 6595attr_sp_inc_opt_minus( 6596 MAYBE_UNUSED(CALL_INFO ci), 6597 MAYBE_UNUSED(CALL_CACHE cc) 6598) 6599{ 6600 return -1; 6601} 6602 6603/* attr rb_num_t width @ opt_minus(ci, cc)(recv, obj)(val) */ 6604rb_num_t 6605attr_width_opt_minus( 6606 MAYBE_UNUSED(CALL_INFO ci), 6607 MAYBE_UNUSED(CALL_CACHE cc) 6608) 6609{ 6610 return 3; 6611} 6612 6613/* attr enum ruby_vminsn_type bin @ opt_mult(ci, cc)(recv, obj)(val) */ 6614enum ruby_vminsn_type 6615attr_bin_opt_mult( 6616 MAYBE_UNUSED(CALL_INFO ci), 6617 MAYBE_UNUSED(CALL_CACHE cc) 6618) 6619{ 6620 return BIN(opt_mult); 6621} 6622 6623/* attr bool handles_sp @ opt_mult(ci, cc)(recv, obj)(val) */ 6624bool 6625attr_handles_sp_opt_mult( 6626 MAYBE_UNUSED(CALL_INFO ci), 6627 MAYBE_UNUSED(CALL_CACHE cc) 6628) 6629{ 6630 return false; 6631} 6632 6633/* attr bool leaf @ opt_mult(ci, cc)(recv, obj)(val) */ 6634bool 6635attr_leaf_opt_mult( 6636 MAYBE_UNUSED(CALL_INFO ci), 6637 MAYBE_UNUSED(CALL_CACHE cc) 6638) 6639{ 6640 return true; 6641} 6642 6643/* attr const char* name @ opt_mult(ci, cc)(recv, obj)(val) */ 6644const char* 6645attr_name_opt_mult( 6646 MAYBE_UNUSED(CALL_INFO ci), 6647 MAYBE_UNUSED(CALL_CACHE cc) 6648) 6649{ 6650 return insn_name(BIN(opt_mult)); 6651} 6652 6653/* attr rb_num_t open @ opt_mult(ci, cc)(recv, obj)(val) */ 6654rb_num_t 6655attr_open_opt_mult( 6656 MAYBE_UNUSED(CALL_INFO ci), 6657 MAYBE_UNUSED(CALL_CACHE cc) 6658) 6659{ 6660 return 2; 6661} 6662 6663/* attr rb_num_t popn @ opt_mult(ci, cc)(recv, obj)(val) */ 6664rb_num_t 6665attr_popn_opt_mult( 6666 MAYBE_UNUSED(CALL_INFO ci), 6667 MAYBE_UNUSED(CALL_CACHE cc) 6668) 6669{ 6670 return 2; 6671} 6672 6673/* attr rb_num_t retn @ opt_mult(ci, cc)(recv, obj)(val) */ 6674rb_num_t 6675attr_retn_opt_mult( 6676 MAYBE_UNUSED(CALL_INFO ci), 6677 MAYBE_UNUSED(CALL_CACHE cc) 6678) 6679{ 6680 return 1; 6681} 6682 6683/* attr rb_snum_t sp_inc @ opt_mult(ci, cc)(recv, obj)(val) */ 6684rb_snum_t 6685attr_sp_inc_opt_mult( 6686 MAYBE_UNUSED(CALL_INFO ci), 6687 MAYBE_UNUSED(CALL_CACHE cc) 6688) 6689{ 6690 return -1; 6691} 6692 6693/* attr rb_num_t width @ opt_mult(ci, cc)(recv, obj)(val) */ 6694rb_num_t 6695attr_width_opt_mult( 6696 MAYBE_UNUSED(CALL_INFO ci), 6697 MAYBE_UNUSED(CALL_CACHE cc) 6698) 6699{ 6700 return 3; 6701} 6702 6703/* attr enum ruby_vminsn_type bin @ opt_div(ci, cc)(recv, obj)(val) */ 6704enum ruby_vminsn_type 6705attr_bin_opt_div( 6706 MAYBE_UNUSED(CALL_INFO ci), 6707 MAYBE_UNUSED(CALL_CACHE cc) 6708) 6709{ 6710 return BIN(opt_div); 6711} 6712 6713/* attr bool handles_sp @ opt_div(ci, cc)(recv, obj)(val) */ 6714bool 6715attr_handles_sp_opt_div( 6716 MAYBE_UNUSED(CALL_INFO ci), 6717 MAYBE_UNUSED(CALL_CACHE cc) 6718) 6719{ 6720 return false; 6721} 6722 6723/* attr bool leaf @ opt_div(ci, cc)(recv, obj)(val) */ 6724bool 6725attr_leaf_opt_div( 6726 MAYBE_UNUSED(CALL_INFO ci), 6727 MAYBE_UNUSED(CALL_CACHE cc) 6728) 6729{ 6730 return true; 6731} 6732 6733/* attr const char* name @ opt_div(ci, cc)(recv, obj)(val) */ 6734const char* 6735attr_name_opt_div( 6736 MAYBE_UNUSED(CALL_INFO ci), 6737 MAYBE_UNUSED(CALL_CACHE cc) 6738) 6739{ 6740 return insn_name(BIN(opt_div)); 6741} 6742 6743/* attr rb_num_t open @ opt_div(ci, cc)(recv, obj)(val) */ 6744rb_num_t 6745attr_open_opt_div( 6746 MAYBE_UNUSED(CALL_INFO ci), 6747 MAYBE_UNUSED(CALL_CACHE cc) 6748) 6749{ 6750 return 2; 6751} 6752 6753/* attr rb_num_t popn @ opt_div(ci, cc)(recv, obj)(val) */ 6754rb_num_t 6755attr_popn_opt_div( 6756 MAYBE_UNUSED(CALL_INFO ci), 6757 MAYBE_UNUSED(CALL_CACHE cc) 6758) 6759{ 6760 return 2; 6761} 6762 6763/* attr rb_num_t retn @ opt_div(ci, cc)(recv, obj)(val) */ 6764rb_num_t 6765attr_retn_opt_div( 6766 MAYBE_UNUSED(CALL_INFO ci), 6767 MAYBE_UNUSED(CALL_CACHE cc) 6768) 6769{ 6770 return 1; 6771} 6772 6773/* attr rb_snum_t sp_inc @ opt_div(ci, cc)(recv, obj)(val) */ 6774rb_snum_t 6775attr_sp_inc_opt_div( 6776 MAYBE_UNUSED(CALL_INFO ci), 6777 MAYBE_UNUSED(CALL_CACHE cc) 6778) 6779{ 6780 return -1; 6781} 6782 6783/* attr rb_num_t width @ opt_div(ci, cc)(recv, obj)(val) */ 6784rb_num_t 6785attr_width_opt_div( 6786 MAYBE_UNUSED(CALL_INFO ci), 6787 MAYBE_UNUSED(CALL_CACHE cc) 6788) 6789{ 6790 return 3; 6791} 6792 6793/* attr enum ruby_vminsn_type bin @ opt_mod(ci, cc)(recv, obj)(val) */ 6794enum ruby_vminsn_type 6795attr_bin_opt_mod( 6796 MAYBE_UNUSED(CALL_INFO ci), 6797 MAYBE_UNUSED(CALL_CACHE cc) 6798) 6799{ 6800 return BIN(opt_mod); 6801} 6802 6803/* attr bool handles_sp @ opt_mod(ci, cc)(recv, obj)(val) */ 6804bool 6805attr_handles_sp_opt_mod( 6806 MAYBE_UNUSED(CALL_INFO ci), 6807 MAYBE_UNUSED(CALL_CACHE cc) 6808) 6809{ 6810 return false; 6811} 6812 6813/* attr bool leaf @ opt_mod(ci, cc)(recv, obj)(val) */ 6814bool 6815attr_leaf_opt_mod( 6816 MAYBE_UNUSED(CALL_INFO ci), 6817 MAYBE_UNUSED(CALL_CACHE cc) 6818) 6819{ 6820 return true; 6821} 6822 6823/* attr const char* name @ opt_mod(ci, cc)(recv, obj)(val) */ 6824const char* 6825attr_name_opt_mod( 6826 MAYBE_UNUSED(CALL_INFO ci), 6827 MAYBE_UNUSED(CALL_CACHE cc) 6828) 6829{ 6830 return insn_name(BIN(opt_mod)); 6831} 6832 6833/* attr rb_num_t open @ opt_mod(ci, cc)(recv, obj)(val) */ 6834rb_num_t 6835attr_open_opt_mod( 6836 MAYBE_UNUSED(CALL_INFO ci), 6837 MAYBE_UNUSED(CALL_CACHE cc) 6838) 6839{ 6840 return 2; 6841} 6842 6843/* attr rb_num_t popn @ opt_mod(ci, cc)(recv, obj)(val) */ 6844rb_num_t 6845attr_popn_opt_mod( 6846 MAYBE_UNUSED(CALL_INFO ci), 6847 MAYBE_UNUSED(CALL_CACHE cc) 6848) 6849{ 6850 return 2; 6851} 6852 6853/* attr rb_num_t retn @ opt_mod(ci, cc)(recv, obj)(val) */ 6854rb_num_t 6855attr_retn_opt_mod( 6856 MAYBE_UNUSED(CALL_INFO ci), 6857 MAYBE_UNUSED(CALL_CACHE cc) 6858) 6859{ 6860 return 1; 6861} 6862 6863/* attr rb_snum_t sp_inc @ opt_mod(ci, cc)(recv, obj)(val) */ 6864rb_snum_t 6865attr_sp_inc_opt_mod( 6866 MAYBE_UNUSED(CALL_INFO ci), 6867 MAYBE_UNUSED(CALL_CACHE cc) 6868) 6869{ 6870 return -1; 6871} 6872 6873/* attr rb_num_t width @ opt_mod(ci, cc)(recv, obj)(val) */ 6874rb_num_t 6875attr_width_opt_mod( 6876 MAYBE_UNUSED(CALL_INFO ci), 6877 MAYBE_UNUSED(CALL_CACHE cc) 6878) 6879{ 6880 return 3; 6881} 6882 6883/* attr enum ruby_vminsn_type bin @ opt_eq(ci, cc)(recv, obj)(val) */ 6884enum ruby_vminsn_type 6885attr_bin_opt_eq( 6886 MAYBE_UNUSED(CALL_INFO ci), 6887 MAYBE_UNUSED(CALL_CACHE cc) 6888) 6889{ 6890 return BIN(opt_eq); 6891} 6892 6893/* attr bool handles_sp @ opt_eq(ci, cc)(recv, obj)(val) */ 6894bool 6895attr_handles_sp_opt_eq( 6896 MAYBE_UNUSED(CALL_INFO ci), 6897 MAYBE_UNUSED(CALL_CACHE cc) 6898) 6899{ 6900 return false; 6901} 6902 6903/* attr bool leaf @ opt_eq(ci, cc)(recv, obj)(val) */ 6904bool 6905attr_leaf_opt_eq( 6906 MAYBE_UNUSED(CALL_INFO ci), 6907 MAYBE_UNUSED(CALL_CACHE cc) 6908) 6909{ 6910 return 6911#line 1120 "insns.def" 6912false; 6913#line 6914 "insns_info.inc" 6914} 6915 6916/* attr const char* name @ opt_eq(ci, cc)(recv, obj)(val) */ 6917const char* 6918attr_name_opt_eq( 6919 MAYBE_UNUSED(CALL_INFO ci), 6920 MAYBE_UNUSED(CALL_CACHE cc) 6921) 6922{ 6923 return insn_name(BIN(opt_eq)); 6924} 6925 6926/* attr rb_num_t open @ opt_eq(ci, cc)(recv, obj)(val) */ 6927rb_num_t 6928attr_open_opt_eq( 6929 MAYBE_UNUSED(CALL_INFO ci), 6930 MAYBE_UNUSED(CALL_CACHE cc) 6931) 6932{ 6933 return 2; 6934} 6935 6936/* attr rb_num_t popn @ opt_eq(ci, cc)(recv, obj)(val) */ 6937rb_num_t 6938attr_popn_opt_eq( 6939 MAYBE_UNUSED(CALL_INFO ci), 6940 MAYBE_UNUSED(CALL_CACHE cc) 6941) 6942{ 6943 return 2; 6944} 6945 6946/* attr rb_num_t retn @ opt_eq(ci, cc)(recv, obj)(val) */ 6947rb_num_t 6948attr_retn_opt_eq( 6949 MAYBE_UNUSED(CALL_INFO ci), 6950 MAYBE_UNUSED(CALL_CACHE cc) 6951) 6952{ 6953 return 1; 6954} 6955 6956/* attr rb_snum_t sp_inc @ opt_eq(ci, cc)(recv, obj)(val) */ 6957rb_snum_t 6958attr_sp_inc_opt_eq( 6959 MAYBE_UNUSED(CALL_INFO ci), 6960 MAYBE_UNUSED(CALL_CACHE cc) 6961) 6962{ 6963 return -1; 6964} 6965 6966/* attr rb_num_t width @ opt_eq(ci, cc)(recv, obj)(val) */ 6967rb_num_t 6968attr_width_opt_eq( 6969 MAYBE_UNUSED(CALL_INFO ci), 6970 MAYBE_UNUSED(CALL_CACHE cc) 6971) 6972{ 6973 return 3; 6974} 6975 6976/* attr enum ruby_vminsn_type bin @ opt_neq(ci_eq, cc_eq, ci, cc)(recv, obj)(val) */ 6977enum ruby_vminsn_type 6978attr_bin_opt_neq( 6979 MAYBE_UNUSED(CALL_INFO ci_eq), 6980 MAYBE_UNUSED(CALL_CACHE cc_eq), 6981 MAYBE_UNUSED(CALL_INFO ci), 6982 MAYBE_UNUSED(CALL_CACHE cc) 6983) 6984{ 6985 return BIN(opt_neq); 6986} 6987 6988/* attr bool handles_sp @ opt_neq(ci_eq, cc_eq, ci, cc)(recv, obj)(val) */ 6989bool 6990attr_handles_sp_opt_neq( 6991 MAYBE_UNUSED(CALL_INFO ci_eq), 6992 MAYBE_UNUSED(CALL_CACHE cc_eq), 6993 MAYBE_UNUSED(CALL_INFO ci), 6994 MAYBE_UNUSED(CALL_CACHE cc) 6995) 6996{ 6997 return false; 6998} 6999 7000/* attr bool leaf @ opt_neq(ci_eq, cc_eq, ci, cc)(recv, obj)(val) */ 7001bool 7002attr_leaf_opt_neq( 7003 MAYBE_UNUSED(CALL_INFO ci_eq), 7004 MAYBE_UNUSED(CALL_CACHE cc_eq), 7005 MAYBE_UNUSED(CALL_INFO ci), 7006 MAYBE_UNUSED(CALL_CACHE cc) 7007) 7008{ 7009 return 7010#line 1136 "insns.def" 7011false; 7012#line 7013 "insns_info.inc" 7013} 7014 7015/* attr const char* name @ opt_neq(ci_eq, cc_eq, ci, cc)(recv, obj)(val) */ 7016const char* 7017attr_name_opt_neq( 7018 MAYBE_UNUSED(CALL_INFO ci_eq), 7019 MAYBE_UNUSED(CALL_CACHE cc_eq), 7020 MAYBE_UNUSED(CALL_INFO ci), 7021 MAYBE_UNUSED(CALL_CACHE cc) 7022) 7023{ 7024 return insn_name(BIN(opt_neq)); 7025} 7026 7027/* attr rb_num_t open @ opt_neq(ci_eq, cc_eq, ci, cc)(recv, obj)(val) */ 7028rb_num_t 7029attr_open_opt_neq( 7030 MAYBE_UNUSED(CALL_INFO ci_eq), 7031 MAYBE_UNUSED(CALL_CACHE cc_eq), 7032 MAYBE_UNUSED(CALL_INFO ci), 7033 MAYBE_UNUSED(CALL_CACHE cc) 7034) 7035{ 7036 return 4; 7037} 7038 7039/* attr rb_num_t popn @ opt_neq(ci_eq, cc_eq, ci, cc)(recv, obj)(val) */ 7040rb_num_t 7041attr_popn_opt_neq( 7042 MAYBE_UNUSED(CALL_INFO ci_eq), 7043 MAYBE_UNUSED(CALL_CACHE cc_eq), 7044 MAYBE_UNUSED(CALL_INFO ci), 7045 MAYBE_UNUSED(CALL_CACHE cc) 7046) 7047{ 7048 return 2; 7049} 7050 7051/* attr rb_num_t retn @ opt_neq(ci_eq, cc_eq, ci, cc)(recv, obj)(val) */ 7052rb_num_t 7053attr_retn_opt_neq( 7054 MAYBE_UNUSED(CALL_INFO ci_eq), 7055 MAYBE_UNUSED(CALL_CACHE cc_eq), 7056 MAYBE_UNUSED(CALL_INFO ci), 7057 MAYBE_UNUSED(CALL_CACHE cc) 7058) 7059{ 7060 return 1; 7061} 7062 7063/* attr rb_snum_t sp_inc @ opt_neq(ci_eq, cc_eq, ci, cc)(recv, obj)(val) */ 7064rb_snum_t 7065attr_sp_inc_opt_neq( 7066 MAYBE_UNUSED(CALL_INFO ci_eq), 7067 MAYBE_UNUSED(CALL_CACHE cc_eq), 7068 MAYBE_UNUSED(CALL_INFO ci), 7069 MAYBE_UNUSED(CALL_CACHE cc) 7070) 7071{ 7072 return -1; 7073} 7074 7075/* attr rb_num_t width @ opt_neq(ci_eq, cc_eq, ci, cc)(recv, obj)(val) */ 7076rb_num_t 7077attr_width_opt_neq( 7078 MAYBE_UNUSED(CALL_INFO ci_eq), 7079 MAYBE_UNUSED(CALL_CACHE cc_eq), 7080 MAYBE_UNUSED(CALL_INFO ci), 7081 MAYBE_UNUSED(CALL_CACHE cc) 7082) 7083{ 7084 return 5; 7085} 7086 7087/* attr enum ruby_vminsn_type bin @ opt_lt(ci, cc)(recv, obj)(val) */ 7088enum ruby_vminsn_type 7089attr_bin_opt_lt( 7090 MAYBE_UNUSED(CALL_INFO ci), 7091 MAYBE_UNUSED(CALL_CACHE cc) 7092) 7093{ 7094 return BIN(opt_lt); 7095} 7096 7097/* attr bool handles_sp @ opt_lt(ci, cc)(recv, obj)(val) */ 7098bool 7099attr_handles_sp_opt_lt( 7100 MAYBE_UNUSED(CALL_INFO ci), 7101 MAYBE_UNUSED(CALL_CACHE cc) 7102) 7103{ 7104 return false; 7105} 7106 7107/* attr bool leaf @ opt_lt(ci, cc)(recv, obj)(val) */ 7108bool 7109attr_leaf_opt_lt( 7110 MAYBE_UNUSED(CALL_INFO ci), 7111 MAYBE_UNUSED(CALL_CACHE cc) 7112) 7113{ 7114 return true; 7115} 7116 7117/* attr const char* name @ opt_lt(ci, cc)(recv, obj)(val) */ 7118const char* 7119attr_name_opt_lt( 7120 MAYBE_UNUSED(CALL_INFO ci), 7121 MAYBE_UNUSED(CALL_CACHE cc) 7122) 7123{ 7124 return insn_name(BIN(opt_lt)); 7125} 7126 7127/* attr rb_num_t open @ opt_lt(ci, cc)(recv, obj)(val) */ 7128rb_num_t 7129attr_open_opt_lt( 7130 MAYBE_UNUSED(CALL_INFO ci), 7131 MAYBE_UNUSED(CALL_CACHE cc) 7132) 7133{ 7134 return 2; 7135} 7136 7137/* attr rb_num_t popn @ opt_lt(ci, cc)(recv, obj)(val) */ 7138rb_num_t 7139attr_popn_opt_lt( 7140 MAYBE_UNUSED(CALL_INFO ci), 7141 MAYBE_UNUSED(CALL_CACHE cc) 7142) 7143{ 7144 return 2; 7145} 7146 7147/* attr rb_num_t retn @ opt_lt(ci, cc)(recv, obj)(val) */ 7148rb_num_t 7149attr_retn_opt_lt( 7150 MAYBE_UNUSED(CALL_INFO ci), 7151 MAYBE_UNUSED(CALL_CACHE cc) 7152) 7153{ 7154 return 1; 7155} 7156 7157/* attr rb_snum_t sp_inc @ opt_lt(ci, cc)(recv, obj)(val) */ 7158rb_snum_t 7159attr_sp_inc_opt_lt( 7160 MAYBE_UNUSED(CALL_INFO ci), 7161 MAYBE_UNUSED(CALL_CACHE cc) 7162) 7163{ 7164 return -1; 7165} 7166 7167/* attr rb_num_t width @ opt_lt(ci, cc)(recv, obj)(val) */ 7168rb_num_t 7169attr_width_opt_lt( 7170 MAYBE_UNUSED(CALL_INFO ci), 7171 MAYBE_UNUSED(CALL_CACHE cc) 7172) 7173{ 7174 return 3; 7175} 7176 7177/* attr enum ruby_vminsn_type bin @ opt_le(ci, cc)(recv, obj)(val) */ 7178enum ruby_vminsn_type 7179attr_bin_opt_le( 7180 MAYBE_UNUSED(CALL_INFO ci), 7181 MAYBE_UNUSED(CALL_CACHE cc) 7182) 7183{ 7184 return BIN(opt_le); 7185} 7186 7187/* attr bool handles_sp @ opt_le(ci, cc)(recv, obj)(val) */ 7188bool 7189attr_handles_sp_opt_le( 7190 MAYBE_UNUSED(CALL_INFO ci), 7191 MAYBE_UNUSED(CALL_CACHE cc) 7192) 7193{ 7194 return false; 7195} 7196 7197/* attr bool leaf @ opt_le(ci, cc)(recv, obj)(val) */ 7198bool 7199attr_leaf_opt_le( 7200 MAYBE_UNUSED(CALL_INFO ci), 7201 MAYBE_UNUSED(CALL_CACHE cc) 7202) 7203{ 7204 return true; 7205} 7206 7207/* attr const char* name @ opt_le(ci, cc)(recv, obj)(val) */ 7208const char* 7209attr_name_opt_le( 7210 MAYBE_UNUSED(CALL_INFO ci), 7211 MAYBE_UNUSED(CALL_CACHE cc) 7212) 7213{ 7214 return insn_name(BIN(opt_le)); 7215} 7216 7217/* attr rb_num_t open @ opt_le(ci, cc)(recv, obj)(val) */ 7218rb_num_t 7219attr_open_opt_le( 7220 MAYBE_UNUSED(CALL_INFO ci), 7221 MAYBE_UNUSED(CALL_CACHE cc) 7222) 7223{ 7224 return 2; 7225} 7226 7227/* attr rb_num_t popn @ opt_le(ci, cc)(recv, obj)(val) */ 7228rb_num_t 7229attr_popn_opt_le( 7230 MAYBE_UNUSED(CALL_INFO ci), 7231 MAYBE_UNUSED(CALL_CACHE cc) 7232) 7233{ 7234 return 2; 7235} 7236 7237/* attr rb_num_t retn @ opt_le(ci, cc)(recv, obj)(val) */ 7238rb_num_t 7239attr_retn_opt_le( 7240 MAYBE_UNUSED(CALL_INFO ci), 7241 MAYBE_UNUSED(CALL_CACHE cc) 7242) 7243{ 7244 return 1; 7245} 7246 7247/* attr rb_snum_t sp_inc @ opt_le(ci, cc)(recv, obj)(val) */ 7248rb_snum_t 7249attr_sp_inc_opt_le( 7250 MAYBE_UNUSED(CALL_INFO ci), 7251 MAYBE_UNUSED(CALL_CACHE cc) 7252) 7253{ 7254 return -1; 7255} 7256 7257/* attr rb_num_t width @ opt_le(ci, cc)(recv, obj)(val) */ 7258rb_num_t 7259attr_width_opt_le( 7260 MAYBE_UNUSED(CALL_INFO ci), 7261 MAYBE_UNUSED(CALL_CACHE cc) 7262) 7263{ 7264 return 3; 7265} 7266 7267/* attr enum ruby_vminsn_type bin @ opt_gt(ci, cc)(recv, obj)(val) */ 7268enum ruby_vminsn_type 7269attr_bin_opt_gt( 7270 MAYBE_UNUSED(CALL_INFO ci), 7271 MAYBE_UNUSED(CALL_CACHE cc) 7272) 7273{ 7274 return BIN(opt_gt); 7275} 7276 7277/* attr bool handles_sp @ opt_gt(ci, cc)(recv, obj)(val) */ 7278bool 7279attr_handles_sp_opt_gt( 7280 MAYBE_UNUSED(CALL_INFO ci), 7281 MAYBE_UNUSED(CALL_CACHE cc) 7282) 7283{ 7284 return false; 7285} 7286 7287/* attr bool leaf @ opt_gt(ci, cc)(recv, obj)(val) */ 7288bool 7289attr_leaf_opt_gt( 7290 MAYBE_UNUSED(CALL_INFO ci), 7291 MAYBE_UNUSED(CALL_CACHE cc) 7292) 7293{ 7294 return true; 7295} 7296 7297/* attr const char* name @ opt_gt(ci, cc)(recv, obj)(val) */ 7298const char* 7299attr_name_opt_gt( 7300 MAYBE_UNUSED(CALL_INFO ci), 7301 MAYBE_UNUSED(CALL_CACHE cc) 7302) 7303{ 7304 return insn_name(BIN(opt_gt)); 7305} 7306 7307/* attr rb_num_t open @ opt_gt(ci, cc)(recv, obj)(val) */ 7308rb_num_t 7309attr_open_opt_gt( 7310 MAYBE_UNUSED(CALL_INFO ci), 7311 MAYBE_UNUSED(CALL_CACHE cc) 7312) 7313{ 7314 return 2; 7315} 7316 7317/* attr rb_num_t popn @ opt_gt(ci, cc)(recv, obj)(val) */ 7318rb_num_t 7319attr_popn_opt_gt( 7320 MAYBE_UNUSED(CALL_INFO ci), 7321 MAYBE_UNUSED(CALL_CACHE cc) 7322) 7323{ 7324 return 2; 7325} 7326 7327/* attr rb_num_t retn @ opt_gt(ci, cc)(recv, obj)(val) */ 7328rb_num_t 7329attr_retn_opt_gt( 7330 MAYBE_UNUSED(CALL_INFO ci), 7331 MAYBE_UNUSED(CALL_CACHE cc) 7332) 7333{ 7334 return 1; 7335} 7336 7337/* attr rb_snum_t sp_inc @ opt_gt(ci, cc)(recv, obj)(val) */ 7338rb_snum_t 7339attr_sp_inc_opt_gt( 7340 MAYBE_UNUSED(CALL_INFO ci), 7341 MAYBE_UNUSED(CALL_CACHE cc) 7342) 7343{ 7344 return -1; 7345} 7346 7347/* attr rb_num_t width @ opt_gt(ci, cc)(recv, obj)(val) */ 7348rb_num_t 7349attr_width_opt_gt( 7350 MAYBE_UNUSED(CALL_INFO ci), 7351 MAYBE_UNUSED(CALL_CACHE cc) 7352) 7353{ 7354 return 3; 7355} 7356 7357/* attr enum ruby_vminsn_type bin @ opt_ge(ci, cc)(recv, obj)(val) */ 7358enum ruby_vminsn_type 7359attr_bin_opt_ge( 7360 MAYBE_UNUSED(CALL_INFO ci), 7361 MAYBE_UNUSED(CALL_CACHE cc) 7362) 7363{ 7364 return BIN(opt_ge); 7365} 7366 7367/* attr bool handles_sp @ opt_ge(ci, cc)(recv, obj)(val) */ 7368bool 7369attr_handles_sp_opt_ge( 7370 MAYBE_UNUSED(CALL_INFO ci), 7371 MAYBE_UNUSED(CALL_CACHE cc) 7372) 7373{ 7374 return false; 7375} 7376 7377/* attr bool leaf @ opt_ge(ci, cc)(recv, obj)(val) */ 7378bool 7379attr_leaf_opt_ge( 7380 MAYBE_UNUSED(CALL_INFO ci), 7381 MAYBE_UNUSED(CALL_CACHE cc) 7382) 7383{ 7384 return true; 7385} 7386 7387/* attr const char* name @ opt_ge(ci, cc)(recv, obj)(val) */ 7388const char* 7389attr_name_opt_ge( 7390 MAYBE_UNUSED(CALL_INFO ci), 7391 MAYBE_UNUSED(CALL_CACHE cc) 7392) 7393{ 7394 return insn_name(BIN(opt_ge)); 7395} 7396 7397/* attr rb_num_t open @ opt_ge(ci, cc)(recv, obj)(val) */ 7398rb_num_t 7399attr_open_opt_ge( 7400 MAYBE_UNUSED(CALL_INFO ci), 7401 MAYBE_UNUSED(CALL_CACHE cc) 7402) 7403{ 7404 return 2; 7405} 7406 7407/* attr rb_num_t popn @ opt_ge(ci, cc)(recv, obj)(val) */ 7408rb_num_t 7409attr_popn_opt_ge( 7410 MAYBE_UNUSED(CALL_INFO ci), 7411 MAYBE_UNUSED(CALL_CACHE cc) 7412) 7413{ 7414 return 2; 7415} 7416 7417/* attr rb_num_t retn @ opt_ge(ci, cc)(recv, obj)(val) */ 7418rb_num_t 7419attr_retn_opt_ge( 7420 MAYBE_UNUSED(CALL_INFO ci), 7421 MAYBE_UNUSED(CALL_CACHE cc) 7422) 7423{ 7424 return 1; 7425} 7426 7427/* attr rb_snum_t sp_inc @ opt_ge(ci, cc)(recv, obj)(val) */ 7428rb_snum_t 7429attr_sp_inc_opt_ge( 7430 MAYBE_UNUSED(CALL_INFO ci), 7431 MAYBE_UNUSED(CALL_CACHE cc) 7432) 7433{ 7434 return -1; 7435} 7436 7437/* attr rb_num_t width @ opt_ge(ci, cc)(recv, obj)(val) */ 7438rb_num_t 7439attr_width_opt_ge( 7440 MAYBE_UNUSED(CALL_INFO ci), 7441 MAYBE_UNUSED(CALL_CACHE cc) 7442) 7443{ 7444 return 3; 7445} 7446 7447/* attr enum ruby_vminsn_type bin @ opt_ltlt(ci, cc)(recv, obj)(val) */ 7448enum ruby_vminsn_type 7449attr_bin_opt_ltlt( 7450 MAYBE_UNUSED(CALL_INFO ci), 7451 MAYBE_UNUSED(CALL_CACHE cc) 7452) 7453{ 7454 return BIN(opt_ltlt); 7455} 7456 7457/* attr bool handles_sp @ opt_ltlt(ci, cc)(recv, obj)(val) */ 7458bool 7459attr_handles_sp_opt_ltlt( 7460 MAYBE_UNUSED(CALL_INFO ci), 7461 MAYBE_UNUSED(CALL_CACHE cc) 7462) 7463{ 7464 return false; 7465} 7466 7467/* attr bool leaf @ opt_ltlt(ci, cc)(recv, obj)(val) */ 7468bool 7469attr_leaf_opt_ltlt( 7470 MAYBE_UNUSED(CALL_INFO ci), 7471 MAYBE_UNUSED(CALL_CACHE cc) 7472) 7473{ 7474 return true; 7475} 7476 7477/* attr const char* name @ opt_ltlt(ci, cc)(recv, obj)(val) */ 7478const char* 7479attr_name_opt_ltlt( 7480 MAYBE_UNUSED(CALL_INFO ci), 7481 MAYBE_UNUSED(CALL_CACHE cc) 7482) 7483{ 7484 return insn_name(BIN(opt_ltlt)); 7485} 7486 7487/* attr rb_num_t open @ opt_ltlt(ci, cc)(recv, obj)(val) */ 7488rb_num_t 7489attr_open_opt_ltlt( 7490 MAYBE_UNUSED(CALL_INFO ci), 7491 MAYBE_UNUSED(CALL_CACHE cc) 7492) 7493{ 7494 return 2; 7495} 7496 7497/* attr rb_num_t popn @ opt_ltlt(ci, cc)(recv, obj)(val) */ 7498rb_num_t 7499attr_popn_opt_ltlt( 7500 MAYBE_UNUSED(CALL_INFO ci), 7501 MAYBE_UNUSED(CALL_CACHE cc) 7502) 7503{ 7504 return 2; 7505} 7506 7507/* attr rb_num_t retn @ opt_ltlt(ci, cc)(recv, obj)(val) */ 7508rb_num_t 7509attr_retn_opt_ltlt( 7510 MAYBE_UNUSED(CALL_INFO ci), 7511 MAYBE_UNUSED(CALL_CACHE cc) 7512) 7513{ 7514 return 1; 7515} 7516 7517/* attr rb_snum_t sp_inc @ opt_ltlt(ci, cc)(recv, obj)(val) */ 7518rb_snum_t 7519attr_sp_inc_opt_ltlt( 7520 MAYBE_UNUSED(CALL_INFO ci), 7521 MAYBE_UNUSED(CALL_CACHE cc) 7522) 7523{ 7524 return -1; 7525} 7526 7527/* attr rb_num_t width @ opt_ltlt(ci, cc)(recv, obj)(val) */ 7528rb_num_t 7529attr_width_opt_ltlt( 7530 MAYBE_UNUSED(CALL_INFO ci), 7531 MAYBE_UNUSED(CALL_CACHE cc) 7532) 7533{ 7534 return 3; 7535} 7536 7537/* attr enum ruby_vminsn_type bin @ opt_and(ci, cc)(recv, obj)(val) */ 7538enum ruby_vminsn_type 7539attr_bin_opt_and( 7540 MAYBE_UNUSED(CALL_INFO ci), 7541 MAYBE_UNUSED(CALL_CACHE cc) 7542) 7543{ 7544 return BIN(opt_and); 7545} 7546 7547/* attr bool handles_sp @ opt_and(ci, cc)(recv, obj)(val) */ 7548bool 7549attr_handles_sp_opt_and( 7550 MAYBE_UNUSED(CALL_INFO ci), 7551 MAYBE_UNUSED(CALL_CACHE cc) 7552) 7553{ 7554 return false; 7555} 7556 7557/* attr bool leaf @ opt_and(ci, cc)(recv, obj)(val) */ 7558bool 7559attr_leaf_opt_and( 7560 MAYBE_UNUSED(CALL_INFO ci), 7561 MAYBE_UNUSED(CALL_CACHE cc) 7562) 7563{ 7564 return true; 7565} 7566 7567/* attr const char* name @ opt_and(ci, cc)(recv, obj)(val) */ 7568const char* 7569attr_name_opt_and( 7570 MAYBE_UNUSED(CALL_INFO ci), 7571 MAYBE_UNUSED(CALL_CACHE cc) 7572) 7573{ 7574 return insn_name(BIN(opt_and)); 7575} 7576 7577/* attr rb_num_t open @ opt_and(ci, cc)(recv, obj)(val) */ 7578rb_num_t 7579attr_open_opt_and( 7580 MAYBE_UNUSED(CALL_INFO ci), 7581 MAYBE_UNUSED(CALL_CACHE cc) 7582) 7583{ 7584 return 2; 7585} 7586 7587/* attr rb_num_t popn @ opt_and(ci, cc)(recv, obj)(val) */ 7588rb_num_t 7589attr_popn_opt_and( 7590 MAYBE_UNUSED(CALL_INFO ci), 7591 MAYBE_UNUSED(CALL_CACHE cc) 7592) 7593{ 7594 return 2; 7595} 7596 7597/* attr rb_num_t retn @ opt_and(ci, cc)(recv, obj)(val) */ 7598rb_num_t 7599attr_retn_opt_and( 7600 MAYBE_UNUSED(CALL_INFO ci), 7601 MAYBE_UNUSED(CALL_CACHE cc) 7602) 7603{ 7604 return 1; 7605} 7606 7607/* attr rb_snum_t sp_inc @ opt_and(ci, cc)(recv, obj)(val) */ 7608rb_snum_t 7609attr_sp_inc_opt_and( 7610 MAYBE_UNUSED(CALL_INFO ci), 7611 MAYBE_UNUSED(CALL_CACHE cc) 7612) 7613{ 7614 return -1; 7615} 7616 7617/* attr rb_num_t width @ opt_and(ci, cc)(recv, obj)(val) */ 7618rb_num_t 7619attr_width_opt_and( 7620 MAYBE_UNUSED(CALL_INFO ci), 7621 MAYBE_UNUSED(CALL_CACHE cc) 7622) 7623{ 7624 return 3; 7625} 7626 7627/* attr enum ruby_vminsn_type bin @ opt_or(ci, cc)(recv, obj)(val) */ 7628enum ruby_vminsn_type 7629attr_bin_opt_or( 7630 MAYBE_UNUSED(CALL_INFO ci), 7631 MAYBE_UNUSED(CALL_CACHE cc) 7632) 7633{ 7634 return BIN(opt_or); 7635} 7636 7637/* attr bool handles_sp @ opt_or(ci, cc)(recv, obj)(val) */ 7638bool 7639attr_handles_sp_opt_or( 7640 MAYBE_UNUSED(CALL_INFO ci), 7641 MAYBE_UNUSED(CALL_CACHE cc) 7642) 7643{ 7644 return false; 7645} 7646 7647/* attr bool leaf @ opt_or(ci, cc)(recv, obj)(val) */ 7648bool 7649attr_leaf_opt_or( 7650 MAYBE_UNUSED(CALL_INFO ci), 7651 MAYBE_UNUSED(CALL_CACHE cc) 7652) 7653{ 7654 return true; 7655} 7656 7657/* attr const char* name @ opt_or(ci, cc)(recv, obj)(val) */ 7658const char* 7659attr_name_opt_or( 7660 MAYBE_UNUSED(CALL_INFO ci), 7661 MAYBE_UNUSED(CALL_CACHE cc) 7662) 7663{ 7664 return insn_name(BIN(opt_or)); 7665} 7666 7667/* attr rb_num_t open @ opt_or(ci, cc)(recv, obj)(val) */ 7668rb_num_t 7669attr_open_opt_or( 7670 MAYBE_UNUSED(CALL_INFO ci), 7671 MAYBE_UNUSED(CALL_CACHE cc) 7672) 7673{ 7674 return 2; 7675} 7676 7677/* attr rb_num_t popn @ opt_or(ci, cc)(recv, obj)(val) */ 7678rb_num_t 7679attr_popn_opt_or( 7680 MAYBE_UNUSED(CALL_INFO ci), 7681 MAYBE_UNUSED(CALL_CACHE cc) 7682) 7683{ 7684 return 2; 7685} 7686 7687/* attr rb_num_t retn @ opt_or(ci, cc)(recv, obj)(val) */ 7688rb_num_t 7689attr_retn_opt_or( 7690 MAYBE_UNUSED(CALL_INFO ci), 7691 MAYBE_UNUSED(CALL_CACHE cc) 7692) 7693{ 7694 return 1; 7695} 7696 7697/* attr rb_snum_t sp_inc @ opt_or(ci, cc)(recv, obj)(val) */ 7698rb_snum_t 7699attr_sp_inc_opt_or( 7700 MAYBE_UNUSED(CALL_INFO ci), 7701 MAYBE_UNUSED(CALL_CACHE cc) 7702) 7703{ 7704 return -1; 7705} 7706 7707/* attr rb_num_t width @ opt_or(ci, cc)(recv, obj)(val) */ 7708rb_num_t 7709attr_width_opt_or( 7710 MAYBE_UNUSED(CALL_INFO ci), 7711 MAYBE_UNUSED(CALL_CACHE cc) 7712) 7713{ 7714 return 3; 7715} 7716 7717/* attr enum ruby_vminsn_type bin @ opt_aref(ci, cc)(recv, obj)(val) */ 7718enum ruby_vminsn_type 7719attr_bin_opt_aref( 7720 MAYBE_UNUSED(CALL_INFO ci), 7721 MAYBE_UNUSED(CALL_CACHE cc) 7722) 7723{ 7724 return BIN(opt_aref); 7725} 7726 7727/* attr bool handles_sp @ opt_aref(ci, cc)(recv, obj)(val) */ 7728bool 7729attr_handles_sp_opt_aref( 7730 MAYBE_UNUSED(CALL_INFO ci), 7731 MAYBE_UNUSED(CALL_CACHE cc) 7732) 7733{ 7734 return false; 7735} 7736 7737/* attr bool leaf @ opt_aref(ci, cc)(recv, obj)(val) */ 7738bool 7739attr_leaf_opt_aref( 7740 MAYBE_UNUSED(CALL_INFO ci), 7741 MAYBE_UNUSED(CALL_CACHE cc) 7742) 7743{ 7744 return 7745#line 1253 "insns.def" 7746false; 7747#line 7748 "insns_info.inc" 7748} 7749 7750/* attr const char* name @ opt_aref(ci, cc)(recv, obj)(val) */ 7751const char* 7752attr_name_opt_aref( 7753 MAYBE_UNUSED(CALL_INFO ci), 7754 MAYBE_UNUSED(CALL_CACHE cc) 7755) 7756{ 7757 return insn_name(BIN(opt_aref)); 7758} 7759 7760/* attr rb_num_t open @ opt_aref(ci, cc)(recv, obj)(val) */ 7761rb_num_t 7762attr_open_opt_aref( 7763 MAYBE_UNUSED(CALL_INFO ci), 7764 MAYBE_UNUSED(CALL_CACHE cc) 7765) 7766{ 7767 return 2; 7768} 7769 7770/* attr rb_num_t popn @ opt_aref(ci, cc)(recv, obj)(val) */ 7771rb_num_t 7772attr_popn_opt_aref( 7773 MAYBE_UNUSED(CALL_INFO ci), 7774 MAYBE_UNUSED(CALL_CACHE cc) 7775) 7776{ 7777 return 2; 7778} 7779 7780/* attr rb_num_t retn @ opt_aref(ci, cc)(recv, obj)(val) */ 7781rb_num_t 7782attr_retn_opt_aref( 7783 MAYBE_UNUSED(CALL_INFO ci), 7784 MAYBE_UNUSED(CALL_CACHE cc) 7785) 7786{ 7787 return 1; 7788} 7789 7790/* attr rb_snum_t sp_inc @ opt_aref(ci, cc)(recv, obj)(val) */ 7791rb_snum_t 7792attr_sp_inc_opt_aref( 7793 MAYBE_UNUSED(CALL_INFO ci), 7794 MAYBE_UNUSED(CALL_CACHE cc) 7795) 7796{ 7797 return -1; 7798} 7799 7800/* attr rb_num_t width @ opt_aref(ci, cc)(recv, obj)(val) */ 7801rb_num_t 7802attr_width_opt_aref( 7803 MAYBE_UNUSED(CALL_INFO ci), 7804 MAYBE_UNUSED(CALL_CACHE cc) 7805) 7806{ 7807 return 3; 7808} 7809 7810/* attr enum ruby_vminsn_type bin @ opt_aset(ci, cc)(recv, obj, set)(val) */ 7811enum ruby_vminsn_type 7812attr_bin_opt_aset( 7813 MAYBE_UNUSED(CALL_INFO ci), 7814 MAYBE_UNUSED(CALL_CACHE cc) 7815) 7816{ 7817 return BIN(opt_aset); 7818} 7819 7820/* attr bool handles_sp @ opt_aset(ci, cc)(recv, obj, set)(val) */ 7821bool 7822attr_handles_sp_opt_aset( 7823 MAYBE_UNUSED(CALL_INFO ci), 7824 MAYBE_UNUSED(CALL_CACHE cc) 7825) 7826{ 7827 return false; 7828} 7829 7830/* attr bool leaf @ opt_aset(ci, cc)(recv, obj, set)(val) */ 7831bool 7832attr_leaf_opt_aset( 7833 MAYBE_UNUSED(CALL_INFO ci), 7834 MAYBE_UNUSED(CALL_CACHE cc) 7835) 7836{ 7837 return 7838#line 1270 "insns.def" 7839false; 7840#line 7841 "insns_info.inc" 7841} 7842 7843/* attr const char* name @ opt_aset(ci, cc)(recv, obj, set)(val) */ 7844const char* 7845attr_name_opt_aset( 7846 MAYBE_UNUSED(CALL_INFO ci), 7847 MAYBE_UNUSED(CALL_CACHE cc) 7848) 7849{ 7850 return insn_name(BIN(opt_aset)); 7851} 7852 7853/* attr rb_num_t open @ opt_aset(ci, cc)(recv, obj, set)(val) */ 7854rb_num_t 7855attr_open_opt_aset( 7856 MAYBE_UNUSED(CALL_INFO ci), 7857 MAYBE_UNUSED(CALL_CACHE cc) 7858) 7859{ 7860 return 2; 7861} 7862 7863/* attr rb_num_t popn @ opt_aset(ci, cc)(recv, obj, set)(val) */ 7864rb_num_t 7865attr_popn_opt_aset( 7866 MAYBE_UNUSED(CALL_INFO ci), 7867 MAYBE_UNUSED(CALL_CACHE cc) 7868) 7869{ 7870 return 3; 7871} 7872 7873/* attr rb_num_t retn @ opt_aset(ci, cc)(recv, obj, set)(val) */ 7874rb_num_t 7875attr_retn_opt_aset( 7876 MAYBE_UNUSED(CALL_INFO ci), 7877 MAYBE_UNUSED(CALL_CACHE cc) 7878) 7879{ 7880 return 1; 7881} 7882 7883/* attr rb_snum_t sp_inc @ opt_aset(ci, cc)(recv, obj, set)(val) */ 7884rb_snum_t 7885attr_sp_inc_opt_aset( 7886 MAYBE_UNUSED(CALL_INFO ci), 7887 MAYBE_UNUSED(CALL_CACHE cc) 7888) 7889{ 7890 return -2; 7891} 7892 7893/* attr rb_num_t width @ opt_aset(ci, cc)(recv, obj, set)(val) */ 7894rb_num_t 7895attr_width_opt_aset( 7896 MAYBE_UNUSED(CALL_INFO ci), 7897 MAYBE_UNUSED(CALL_CACHE cc) 7898) 7899{ 7900 return 3; 7901} 7902 7903/* attr enum ruby_vminsn_type bin @ opt_aset_with(key, ci, cc)(recv, val)(val) */ 7904enum ruby_vminsn_type 7905attr_bin_opt_aset_with( 7906 MAYBE_UNUSED(VALUE key), 7907 MAYBE_UNUSED(CALL_INFO ci), 7908 MAYBE_UNUSED(CALL_CACHE cc) 7909) 7910{ 7911 return BIN(opt_aset_with); 7912} 7913 7914/* attr bool handles_sp @ opt_aset_with(key, ci, cc)(recv, val)(val) */ 7915bool 7916attr_handles_sp_opt_aset_with( 7917 MAYBE_UNUSED(VALUE key), 7918 MAYBE_UNUSED(CALL_INFO ci), 7919 MAYBE_UNUSED(CALL_CACHE cc) 7920) 7921{ 7922 return false; 7923} 7924 7925/* attr bool leaf @ opt_aset_with(key, ci, cc)(recv, val)(val) */ 7926bool 7927attr_leaf_opt_aset_with( 7928 MAYBE_UNUSED(VALUE key), 7929 MAYBE_UNUSED(CALL_INFO ci), 7930 MAYBE_UNUSED(CALL_CACHE cc) 7931) 7932{ 7933 return 7934#line 1286 "insns.def" 7935false; 7936#line 7937 "insns_info.inc" 7937} 7938 7939/* attr const char* name @ opt_aset_with(key, ci, cc)(recv, val)(val) */ 7940const char* 7941attr_name_opt_aset_with( 7942 MAYBE_UNUSED(VALUE key), 7943 MAYBE_UNUSED(CALL_INFO ci), 7944 MAYBE_UNUSED(CALL_CACHE cc) 7945) 7946{ 7947 return insn_name(BIN(opt_aset_with)); 7948} 7949 7950/* attr rb_num_t open @ opt_aset_with(key, ci, cc)(recv, val)(val) */ 7951rb_num_t 7952attr_open_opt_aset_with( 7953 MAYBE_UNUSED(VALUE key), 7954 MAYBE_UNUSED(CALL_INFO ci), 7955 MAYBE_UNUSED(CALL_CACHE cc) 7956) 7957{ 7958 return 3; 7959} 7960 7961/* attr rb_num_t popn @ opt_aset_with(key, ci, cc)(recv, val)(val) */ 7962rb_num_t 7963attr_popn_opt_aset_with( 7964 MAYBE_UNUSED(VALUE key), 7965 MAYBE_UNUSED(CALL_INFO ci), 7966 MAYBE_UNUSED(CALL_CACHE cc) 7967) 7968{ 7969 return 2; 7970} 7971 7972/* attr rb_num_t retn @ opt_aset_with(key, ci, cc)(recv, val)(val) */ 7973rb_num_t 7974attr_retn_opt_aset_with( 7975 MAYBE_UNUSED(VALUE key), 7976 MAYBE_UNUSED(CALL_INFO ci), 7977 MAYBE_UNUSED(CALL_CACHE cc) 7978) 7979{ 7980 return 1; 7981} 7982 7983/* attr rb_snum_t sp_inc @ opt_aset_with(key, ci, cc)(recv, val)(val) */ 7984rb_snum_t 7985attr_sp_inc_opt_aset_with( 7986 MAYBE_UNUSED(VALUE key), 7987 MAYBE_UNUSED(CALL_INFO ci), 7988 MAYBE_UNUSED(CALL_CACHE cc) 7989) 7990{ 7991 return -1; 7992} 7993 7994/* attr rb_num_t width @ opt_aset_with(key, ci, cc)(recv, val)(val) */ 7995rb_num_t 7996attr_width_opt_aset_with( 7997 MAYBE_UNUSED(VALUE key), 7998 MAYBE_UNUSED(CALL_INFO ci), 7999 MAYBE_UNUSED(CALL_CACHE cc) 8000) 8001{ 8002 return 4; 8003} 8004 8005/* attr enum ruby_vminsn_type bin @ opt_aref_with(key, ci, cc)(recv)(val) */ 8006enum ruby_vminsn_type 8007attr_bin_opt_aref_with( 8008 MAYBE_UNUSED(VALUE key), 8009 MAYBE_UNUSED(CALL_INFO ci), 8010 MAYBE_UNUSED(CALL_CACHE cc) 8011) 8012{ 8013 return BIN(opt_aref_with); 8014} 8015 8016/* attr bool handles_sp @ opt_aref_with(key, ci, cc)(recv)(val) */ 8017bool 8018attr_handles_sp_opt_aref_with( 8019 MAYBE_UNUSED(VALUE key), 8020 MAYBE_UNUSED(CALL_INFO ci), 8021 MAYBE_UNUSED(CALL_CACHE cc) 8022) 8023{ 8024 return false; 8025} 8026 8027/* attr bool leaf @ opt_aref_with(key, ci, cc)(recv)(val) */ 8028bool 8029attr_leaf_opt_aref_with( 8030 MAYBE_UNUSED(VALUE key), 8031 MAYBE_UNUSED(CALL_INFO ci), 8032 MAYBE_UNUSED(CALL_CACHE cc) 8033) 8034{ 8035 return 8036#line 1309 "insns.def" 8037false; 8038#line 8039 "insns_info.inc" 8039} 8040 8041/* attr const char* name @ opt_aref_with(key, ci, cc)(recv)(val) */ 8042const char* 8043attr_name_opt_aref_with( 8044 MAYBE_UNUSED(VALUE key), 8045 MAYBE_UNUSED(CALL_INFO ci), 8046 MAYBE_UNUSED(CALL_CACHE cc) 8047) 8048{ 8049 return insn_name(BIN(opt_aref_with)); 8050} 8051 8052/* attr rb_num_t open @ opt_aref_with(key, ci, cc)(recv)(val) */ 8053rb_num_t 8054attr_open_opt_aref_with( 8055 MAYBE_UNUSED(VALUE key), 8056 MAYBE_UNUSED(CALL_INFO ci), 8057 MAYBE_UNUSED(CALL_CACHE cc) 8058) 8059{ 8060 return 3; 8061} 8062 8063/* attr rb_num_t popn @ opt_aref_with(key, ci, cc)(recv)(val) */ 8064rb_num_t 8065attr_popn_opt_aref_with( 8066 MAYBE_UNUSED(VALUE key), 8067 MAYBE_UNUSED(CALL_INFO ci), 8068 MAYBE_UNUSED(CALL_CACHE cc) 8069) 8070{ 8071 return 1; 8072} 8073 8074/* attr rb_num_t retn @ opt_aref_with(key, ci, cc)(recv)(val) */ 8075rb_num_t 8076attr_retn_opt_aref_with( 8077 MAYBE_UNUSED(VALUE key), 8078 MAYBE_UNUSED(CALL_INFO ci), 8079 MAYBE_UNUSED(CALL_CACHE cc) 8080) 8081{ 8082 return 1; 8083} 8084 8085/* attr rb_snum_t sp_inc @ opt_aref_with(key, ci, cc)(recv)(val) */ 8086rb_snum_t 8087attr_sp_inc_opt_aref_with( 8088 MAYBE_UNUSED(VALUE key), 8089 MAYBE_UNUSED(CALL_INFO ci), 8090 MAYBE_UNUSED(CALL_CACHE cc) 8091) 8092{ 8093 return 0; 8094} 8095 8096/* attr rb_num_t width @ opt_aref_with(key, ci, cc)(recv)(val) */ 8097rb_num_t 8098attr_width_opt_aref_with( 8099 MAYBE_UNUSED(VALUE key), 8100 MAYBE_UNUSED(CALL_INFO ci), 8101 MAYBE_UNUSED(CALL_CACHE cc) 8102) 8103{ 8104 return 4; 8105} 8106 8107/* attr enum ruby_vminsn_type bin @ opt_length(ci, cc)(recv)(val) */ 8108enum ruby_vminsn_type 8109attr_bin_opt_length( 8110 MAYBE_UNUSED(CALL_INFO ci), 8111 MAYBE_UNUSED(CALL_CACHE cc) 8112) 8113{ 8114 return BIN(opt_length); 8115} 8116 8117/* attr bool handles_sp @ opt_length(ci, cc)(recv)(val) */ 8118bool 8119attr_handles_sp_opt_length( 8120 MAYBE_UNUSED(CALL_INFO ci), 8121 MAYBE_UNUSED(CALL_CACHE cc) 8122) 8123{ 8124 return false; 8125} 8126 8127/* attr bool leaf @ opt_length(ci, cc)(recv)(val) */ 8128bool 8129attr_leaf_opt_length( 8130 MAYBE_UNUSED(CALL_INFO ci), 8131 MAYBE_UNUSED(CALL_CACHE cc) 8132) 8133{ 8134 return true; 8135} 8136 8137/* attr const char* name @ opt_length(ci, cc)(recv)(val) */ 8138const char* 8139attr_name_opt_length( 8140 MAYBE_UNUSED(CALL_INFO ci), 8141 MAYBE_UNUSED(CALL_CACHE cc) 8142) 8143{ 8144 return insn_name(BIN(opt_length)); 8145} 8146 8147/* attr rb_num_t open @ opt_length(ci, cc)(recv)(val) */ 8148rb_num_t 8149attr_open_opt_length( 8150 MAYBE_UNUSED(CALL_INFO ci), 8151 MAYBE_UNUSED(CALL_CACHE cc) 8152) 8153{ 8154 return 2; 8155} 8156 8157/* attr rb_num_t popn @ opt_length(ci, cc)(recv)(val) */ 8158rb_num_t 8159attr_popn_opt_length( 8160 MAYBE_UNUSED(CALL_INFO ci), 8161 MAYBE_UNUSED(CALL_CACHE cc) 8162) 8163{ 8164 return 1; 8165} 8166 8167/* attr rb_num_t retn @ opt_length(ci, cc)(recv)(val) */ 8168rb_num_t 8169attr_retn_opt_length( 8170 MAYBE_UNUSED(CALL_INFO ci), 8171 MAYBE_UNUSED(CALL_CACHE cc) 8172) 8173{ 8174 return 1; 8175} 8176 8177/* attr rb_snum_t sp_inc @ opt_length(ci, cc)(recv)(val) */ 8178rb_snum_t 8179attr_sp_inc_opt_length( 8180 MAYBE_UNUSED(CALL_INFO ci), 8181 MAYBE_UNUSED(CALL_CACHE cc) 8182) 8183{ 8184 return 0; 8185} 8186 8187/* attr rb_num_t width @ opt_length(ci, cc)(recv)(val) */ 8188rb_num_t 8189attr_width_opt_length( 8190 MAYBE_UNUSED(CALL_INFO ci), 8191 MAYBE_UNUSED(CALL_CACHE cc) 8192) 8193{ 8194 return 3; 8195} 8196 8197/* attr enum ruby_vminsn_type bin @ opt_size(ci, cc)(recv)(val) */ 8198enum ruby_vminsn_type 8199attr_bin_opt_size( 8200 MAYBE_UNUSED(CALL_INFO ci), 8201 MAYBE_UNUSED(CALL_CACHE cc) 8202) 8203{ 8204 return BIN(opt_size); 8205} 8206 8207/* attr bool handles_sp @ opt_size(ci, cc)(recv)(val) */ 8208bool 8209attr_handles_sp_opt_size( 8210 MAYBE_UNUSED(CALL_INFO ci), 8211 MAYBE_UNUSED(CALL_CACHE cc) 8212) 8213{ 8214 return false; 8215} 8216 8217/* attr bool leaf @ opt_size(ci, cc)(recv)(val) */ 8218bool 8219attr_leaf_opt_size( 8220 MAYBE_UNUSED(CALL_INFO ci), 8221 MAYBE_UNUSED(CALL_CACHE cc) 8222) 8223{ 8224 return true; 8225} 8226 8227/* attr const char* name @ opt_size(ci, cc)(recv)(val) */ 8228const char* 8229attr_name_opt_size( 8230 MAYBE_UNUSED(CALL_INFO ci), 8231 MAYBE_UNUSED(CALL_CACHE cc) 8232) 8233{ 8234 return insn_name(BIN(opt_size)); 8235} 8236 8237/* attr rb_num_t open @ opt_size(ci, cc)(recv)(val) */ 8238rb_num_t 8239attr_open_opt_size( 8240 MAYBE_UNUSED(CALL_INFO ci), 8241 MAYBE_UNUSED(CALL_CACHE cc) 8242) 8243{ 8244 return 2; 8245} 8246 8247/* attr rb_num_t popn @ opt_size(ci, cc)(recv)(val) */ 8248rb_num_t 8249attr_popn_opt_size( 8250 MAYBE_UNUSED(CALL_INFO ci), 8251 MAYBE_UNUSED(CALL_CACHE cc) 8252) 8253{ 8254 return 1; 8255} 8256 8257/* attr rb_num_t retn @ opt_size(ci, cc)(recv)(val) */ 8258rb_num_t 8259attr_retn_opt_size( 8260 MAYBE_UNUSED(CALL_INFO ci), 8261 MAYBE_UNUSED(CALL_CACHE cc) 8262) 8263{ 8264 return 1; 8265} 8266 8267/* attr rb_snum_t sp_inc @ opt_size(ci, cc)(recv)(val) */ 8268rb_snum_t 8269attr_sp_inc_opt_size( 8270 MAYBE_UNUSED(CALL_INFO ci), 8271 MAYBE_UNUSED(CALL_CACHE cc) 8272) 8273{ 8274 return 0; 8275} 8276 8277/* attr rb_num_t width @ opt_size(ci, cc)(recv)(val) */ 8278rb_num_t 8279attr_width_opt_size( 8280 MAYBE_UNUSED(CALL_INFO ci), 8281 MAYBE_UNUSED(CALL_CACHE cc) 8282) 8283{ 8284 return 3; 8285} 8286 8287/* attr enum ruby_vminsn_type bin @ opt_empty_p(ci, cc)(recv)(val) */ 8288enum ruby_vminsn_type 8289attr_bin_opt_empty_p( 8290 MAYBE_UNUSED(CALL_INFO ci), 8291 MAYBE_UNUSED(CALL_CACHE cc) 8292) 8293{ 8294 return BIN(opt_empty_p); 8295} 8296 8297/* attr bool handles_sp @ opt_empty_p(ci, cc)(recv)(val) */ 8298bool 8299attr_handles_sp_opt_empty_p( 8300 MAYBE_UNUSED(CALL_INFO ci), 8301 MAYBE_UNUSED(CALL_CACHE cc) 8302) 8303{ 8304 return false; 8305} 8306 8307/* attr bool leaf @ opt_empty_p(ci, cc)(recv)(val) */ 8308bool 8309attr_leaf_opt_empty_p( 8310 MAYBE_UNUSED(CALL_INFO ci), 8311 MAYBE_UNUSED(CALL_CACHE cc) 8312) 8313{ 8314 return true; 8315} 8316 8317/* attr const char* name @ opt_empty_p(ci, cc)(recv)(val) */ 8318const char* 8319attr_name_opt_empty_p( 8320 MAYBE_UNUSED(CALL_INFO ci), 8321 MAYBE_UNUSED(CALL_CACHE cc) 8322) 8323{ 8324 return insn_name(BIN(opt_empty_p)); 8325} 8326 8327/* attr rb_num_t open @ opt_empty_p(ci, cc)(recv)(val) */ 8328rb_num_t 8329attr_open_opt_empty_p( 8330 MAYBE_UNUSED(CALL_INFO ci), 8331 MAYBE_UNUSED(CALL_CACHE cc) 8332) 8333{ 8334 return 2; 8335} 8336 8337/* attr rb_num_t popn @ opt_empty_p(ci, cc)(recv)(val) */ 8338rb_num_t 8339attr_popn_opt_empty_p( 8340 MAYBE_UNUSED(CALL_INFO ci), 8341 MAYBE_UNUSED(CALL_CACHE cc) 8342) 8343{ 8344 return 1; 8345} 8346 8347/* attr rb_num_t retn @ opt_empty_p(ci, cc)(recv)(val) */ 8348rb_num_t 8349attr_retn_opt_empty_p( 8350 MAYBE_UNUSED(CALL_INFO ci), 8351 MAYBE_UNUSED(CALL_CACHE cc) 8352) 8353{ 8354 return 1; 8355} 8356 8357/* attr rb_snum_t sp_inc @ opt_empty_p(ci, cc)(recv)(val) */ 8358rb_snum_t 8359attr_sp_inc_opt_empty_p( 8360 MAYBE_UNUSED(CALL_INFO ci), 8361 MAYBE_UNUSED(CALL_CACHE cc) 8362) 8363{ 8364 return 0; 8365} 8366 8367/* attr rb_num_t width @ opt_empty_p(ci, cc)(recv)(val) */ 8368rb_num_t 8369attr_width_opt_empty_p( 8370 MAYBE_UNUSED(CALL_INFO ci), 8371 MAYBE_UNUSED(CALL_CACHE cc) 8372) 8373{ 8374 return 3; 8375} 8376 8377/* attr enum ruby_vminsn_type bin @ opt_succ(ci, cc)(recv)(val) */ 8378enum ruby_vminsn_type 8379attr_bin_opt_succ( 8380 MAYBE_UNUSED(CALL_INFO ci), 8381 MAYBE_UNUSED(CALL_CACHE cc) 8382) 8383{ 8384 return BIN(opt_succ); 8385} 8386 8387/* attr bool handles_sp @ opt_succ(ci, cc)(recv)(val) */ 8388bool 8389attr_handles_sp_opt_succ( 8390 MAYBE_UNUSED(CALL_INFO ci), 8391 MAYBE_UNUSED(CALL_CACHE cc) 8392) 8393{ 8394 return false; 8395} 8396 8397/* attr bool leaf @ opt_succ(ci, cc)(recv)(val) */ 8398bool 8399attr_leaf_opt_succ( 8400 MAYBE_UNUSED(CALL_INFO ci), 8401 MAYBE_UNUSED(CALL_CACHE cc) 8402) 8403{ 8404 return true; 8405} 8406 8407/* attr const char* name @ opt_succ(ci, cc)(recv)(val) */ 8408const char* 8409attr_name_opt_succ( 8410 MAYBE_UNUSED(CALL_INFO ci), 8411 MAYBE_UNUSED(CALL_CACHE cc) 8412) 8413{ 8414 return insn_name(BIN(opt_succ)); 8415} 8416 8417/* attr rb_num_t open @ opt_succ(ci, cc)(recv)(val) */ 8418rb_num_t 8419attr_open_opt_succ( 8420 MAYBE_UNUSED(CALL_INFO ci), 8421 MAYBE_UNUSED(CALL_CACHE cc) 8422) 8423{ 8424 return 2; 8425} 8426 8427/* attr rb_num_t popn @ opt_succ(ci, cc)(recv)(val) */ 8428rb_num_t 8429attr_popn_opt_succ( 8430 MAYBE_UNUSED(CALL_INFO ci), 8431 MAYBE_UNUSED(CALL_CACHE cc) 8432) 8433{ 8434 return 1; 8435} 8436 8437/* attr rb_num_t retn @ opt_succ(ci, cc)(recv)(val) */ 8438rb_num_t 8439attr_retn_opt_succ( 8440 MAYBE_UNUSED(CALL_INFO ci), 8441 MAYBE_UNUSED(CALL_CACHE cc) 8442) 8443{ 8444 return 1; 8445} 8446 8447/* attr rb_snum_t sp_inc @ opt_succ(ci, cc)(recv)(val) */ 8448rb_snum_t 8449attr_sp_inc_opt_succ( 8450 MAYBE_UNUSED(CALL_INFO ci), 8451 MAYBE_UNUSED(CALL_CACHE cc) 8452) 8453{ 8454 return 0; 8455} 8456 8457/* attr rb_num_t width @ opt_succ(ci, cc)(recv)(val) */ 8458rb_num_t 8459attr_width_opt_succ( 8460 MAYBE_UNUSED(CALL_INFO ci), 8461 MAYBE_UNUSED(CALL_CACHE cc) 8462) 8463{ 8464 return 3; 8465} 8466 8467/* attr enum ruby_vminsn_type bin @ opt_not(ci, cc)(recv)(val) */ 8468enum ruby_vminsn_type 8469attr_bin_opt_not( 8470 MAYBE_UNUSED(CALL_INFO ci), 8471 MAYBE_UNUSED(CALL_CACHE cc) 8472) 8473{ 8474 return BIN(opt_not); 8475} 8476 8477/* attr bool handles_sp @ opt_not(ci, cc)(recv)(val) */ 8478bool 8479attr_handles_sp_opt_not( 8480 MAYBE_UNUSED(CALL_INFO ci), 8481 MAYBE_UNUSED(CALL_CACHE cc) 8482) 8483{ 8484 return false; 8485} 8486 8487/* attr bool leaf @ opt_not(ci, cc)(recv)(val) */ 8488bool 8489attr_leaf_opt_not( 8490 MAYBE_UNUSED(CALL_INFO ci), 8491 MAYBE_UNUSED(CALL_CACHE cc) 8492) 8493{ 8494 return true; 8495} 8496 8497/* attr const char* name @ opt_not(ci, cc)(recv)(val) */ 8498const char* 8499attr_name_opt_not( 8500 MAYBE_UNUSED(CALL_INFO ci), 8501 MAYBE_UNUSED(CALL_CACHE cc) 8502) 8503{ 8504 return insn_name(BIN(opt_not)); 8505} 8506 8507/* attr rb_num_t open @ opt_not(ci, cc)(recv)(val) */ 8508rb_num_t 8509attr_open_opt_not( 8510 MAYBE_UNUSED(CALL_INFO ci), 8511 MAYBE_UNUSED(CALL_CACHE cc) 8512) 8513{ 8514 return 2; 8515} 8516 8517/* attr rb_num_t popn @ opt_not(ci, cc)(recv)(val) */ 8518rb_num_t 8519attr_popn_opt_not( 8520 MAYBE_UNUSED(CALL_INFO ci), 8521 MAYBE_UNUSED(CALL_CACHE cc) 8522) 8523{ 8524 return 1; 8525} 8526 8527/* attr rb_num_t retn @ opt_not(ci, cc)(recv)(val) */ 8528rb_num_t 8529attr_retn_opt_not( 8530 MAYBE_UNUSED(CALL_INFO ci), 8531 MAYBE_UNUSED(CALL_CACHE cc) 8532) 8533{ 8534 return 1; 8535} 8536 8537/* attr rb_snum_t sp_inc @ opt_not(ci, cc)(recv)(val) */ 8538rb_snum_t 8539attr_sp_inc_opt_not( 8540 MAYBE_UNUSED(CALL_INFO ci), 8541 MAYBE_UNUSED(CALL_CACHE cc) 8542) 8543{ 8544 return 0; 8545} 8546 8547/* attr rb_num_t width @ opt_not(ci, cc)(recv)(val) */ 8548rb_num_t 8549attr_width_opt_not( 8550 MAYBE_UNUSED(CALL_INFO ci), 8551 MAYBE_UNUSED(CALL_CACHE cc) 8552) 8553{ 8554 return 3; 8555} 8556 8557/* attr enum ruby_vminsn_type bin @ opt_regexpmatch1(recv)(obj)(val) */ 8558enum ruby_vminsn_type 8559attr_bin_opt_regexpmatch1(MAYBE_UNUSED(VALUE recv)) 8560{ 8561 return BIN(opt_regexpmatch1); 8562} 8563 8564/* attr bool handles_sp @ opt_regexpmatch1(recv)(obj)(val) */ 8565bool 8566attr_handles_sp_opt_regexpmatch1(MAYBE_UNUSED(VALUE recv)) 8567{ 8568 return false; 8569} 8570 8571/* attr bool leaf @ opt_regexpmatch1(recv)(obj)(val) */ 8572bool 8573attr_leaf_opt_regexpmatch1(MAYBE_UNUSED(VALUE recv)) 8574{ 8575 return 8576#line 1397 "insns.def" 8577BASIC_OP_UNREDEFINED_P(BOP_MATCH, REGEXP_REDEFINED_OP_FLAG); 8578#line 8579 "insns_info.inc" 8579} 8580 8581/* attr const char* name @ opt_regexpmatch1(recv)(obj)(val) */ 8582const char* 8583attr_name_opt_regexpmatch1(MAYBE_UNUSED(VALUE recv)) 8584{ 8585 return insn_name(BIN(opt_regexpmatch1)); 8586} 8587 8588/* attr rb_num_t open @ opt_regexpmatch1(recv)(obj)(val) */ 8589rb_num_t 8590attr_open_opt_regexpmatch1(MAYBE_UNUSED(VALUE recv)) 8591{ 8592 return 1; 8593} 8594 8595/* attr rb_num_t popn @ opt_regexpmatch1(recv)(obj)(val) */ 8596rb_num_t 8597attr_popn_opt_regexpmatch1(MAYBE_UNUSED(VALUE recv)) 8598{ 8599 return 1; 8600} 8601 8602/* attr rb_num_t retn @ opt_regexpmatch1(recv)(obj)(val) */ 8603rb_num_t 8604attr_retn_opt_regexpmatch1(MAYBE_UNUSED(VALUE recv)) 8605{ 8606 return 1; 8607} 8608 8609/* attr rb_snum_t sp_inc @ opt_regexpmatch1(recv)(obj)(val) */ 8610rb_snum_t 8611attr_sp_inc_opt_regexpmatch1(MAYBE_UNUSED(VALUE recv)) 8612{ 8613 return 0; 8614} 8615 8616/* attr rb_num_t width @ opt_regexpmatch1(recv)(obj)(val) */ 8617rb_num_t 8618attr_width_opt_regexpmatch1(MAYBE_UNUSED(VALUE recv)) 8619{ 8620 return 2; 8621} 8622 8623/* attr enum ruby_vminsn_type bin @ opt_regexpmatch2(ci, cc)(obj2, obj1)(val) */ 8624enum ruby_vminsn_type 8625attr_bin_opt_regexpmatch2( 8626 MAYBE_UNUSED(CALL_INFO ci), 8627 MAYBE_UNUSED(CALL_CACHE cc) 8628) 8629{ 8630 return BIN(opt_regexpmatch2); 8631} 8632 8633/* attr bool handles_sp @ opt_regexpmatch2(ci, cc)(obj2, obj1)(val) */ 8634bool 8635attr_handles_sp_opt_regexpmatch2( 8636 MAYBE_UNUSED(CALL_INFO ci), 8637 MAYBE_UNUSED(CALL_CACHE cc) 8638) 8639{ 8640 return false; 8641} 8642 8643/* attr bool leaf @ opt_regexpmatch2(ci, cc)(obj2, obj1)(val) */ 8644bool 8645attr_leaf_opt_regexpmatch2( 8646 MAYBE_UNUSED(CALL_INFO ci), 8647 MAYBE_UNUSED(CALL_CACHE cc) 8648) 8649{ 8650 return true; 8651} 8652 8653/* attr const char* name @ opt_regexpmatch2(ci, cc)(obj2, obj1)(val) */ 8654const char* 8655attr_name_opt_regexpmatch2( 8656 MAYBE_UNUSED(CALL_INFO ci), 8657 MAYBE_UNUSED(CALL_CACHE cc) 8658) 8659{ 8660 return insn_name(BIN(opt_regexpmatch2)); 8661} 8662 8663/* attr rb_num_t open @ opt_regexpmatch2(ci, cc)(obj2, obj1)(val) */ 8664rb_num_t 8665attr_open_opt_regexpmatch2( 8666 MAYBE_UNUSED(CALL_INFO ci), 8667 MAYBE_UNUSED(CALL_CACHE cc) 8668) 8669{ 8670 return 2; 8671} 8672 8673/* attr rb_num_t popn @ opt_regexpmatch2(ci, cc)(obj2, obj1)(val) */ 8674rb_num_t 8675attr_popn_opt_regexpmatch2( 8676 MAYBE_UNUSED(CALL_INFO ci), 8677 MAYBE_UNUSED(CALL_CACHE cc) 8678) 8679{ 8680 return 2; 8681} 8682 8683/* attr rb_num_t retn @ opt_regexpmatch2(ci, cc)(obj2, obj1)(val) */ 8684rb_num_t 8685attr_retn_opt_regexpmatch2( 8686 MAYBE_UNUSED(CALL_INFO ci), 8687 MAYBE_UNUSED(CALL_CACHE cc) 8688) 8689{ 8690 return 1; 8691} 8692 8693/* attr rb_snum_t sp_inc @ opt_regexpmatch2(ci, cc)(obj2, obj1)(val) */ 8694rb_snum_t 8695attr_sp_inc_opt_regexpmatch2( 8696 MAYBE_UNUSED(CALL_INFO ci), 8697 MAYBE_UNUSED(CALL_CACHE cc) 8698) 8699{ 8700 return -1; 8701} 8702 8703/* attr rb_num_t width @ opt_regexpmatch2(ci, cc)(obj2, obj1)(val) */ 8704rb_num_t 8705attr_width_opt_regexpmatch2( 8706 MAYBE_UNUSED(CALL_INFO ci), 8707 MAYBE_UNUSED(CALL_CACHE cc) 8708) 8709{ 8710 return 3; 8711} 8712 8713/* attr enum ruby_vminsn_type bin @ opt_call_c_function(funcptr)()() */ 8714enum ruby_vminsn_type 8715attr_bin_opt_call_c_function(MAYBE_UNUSED(rb_insn_func_t funcptr)) 8716{ 8717 return BIN(opt_call_c_function); 8718} 8719 8720/* attr bool handles_sp @ opt_call_c_function(funcptr)()() */ 8721bool 8722attr_handles_sp_opt_call_c_function(MAYBE_UNUSED(rb_insn_func_t funcptr)) 8723{ 8724 return 8725#line 1423 "insns.def" 8726true; 8727#line 8728 "insns_info.inc" 8728} 8729 8730/* attr bool leaf @ opt_call_c_function(funcptr)()() */ 8731bool 8732attr_leaf_opt_call_c_function(MAYBE_UNUSED(rb_insn_func_t funcptr)) 8733{ 8734 return 8735#line 1422 "insns.def" 8736false; 8737#line 8738 "insns_info.inc" 8738} 8739 8740/* attr const char* name @ opt_call_c_function(funcptr)()() */ 8741const char* 8742attr_name_opt_call_c_function(MAYBE_UNUSED(rb_insn_func_t funcptr)) 8743{ 8744 return insn_name(BIN(opt_call_c_function)); 8745} 8746 8747/* attr rb_num_t open @ opt_call_c_function(funcptr)()() */ 8748rb_num_t 8749attr_open_opt_call_c_function(MAYBE_UNUSED(rb_insn_func_t funcptr)) 8750{ 8751 return 1; 8752} 8753 8754/* attr rb_num_t popn @ opt_call_c_function(funcptr)()() */ 8755rb_num_t 8756attr_popn_opt_call_c_function(MAYBE_UNUSED(rb_insn_func_t funcptr)) 8757{ 8758 return 0; 8759} 8760 8761/* attr rb_num_t retn @ opt_call_c_function(funcptr)()() */ 8762rb_num_t 8763attr_retn_opt_call_c_function(MAYBE_UNUSED(rb_insn_func_t funcptr)) 8764{ 8765 return 0; 8766} 8767 8768/* attr rb_snum_t sp_inc @ opt_call_c_function(funcptr)()() */ 8769rb_snum_t 8770attr_sp_inc_opt_call_c_function(MAYBE_UNUSED(rb_insn_func_t funcptr)) 8771{ 8772 return 0; 8773} 8774 8775/* attr rb_num_t width @ opt_call_c_function(funcptr)()() */ 8776rb_num_t 8777attr_width_opt_call_c_function(MAYBE_UNUSED(rb_insn_func_t funcptr)) 8778{ 8779 return 2; 8780} 8781 8782/* attr enum ruby_vminsn_type bin @ bitblt()()(ret) */ 8783enum ruby_vminsn_type 8784attr_bin_bitblt(void) 8785{ 8786 return BIN(bitblt); 8787} 8788 8789/* attr bool handles_sp @ bitblt()()(ret) */ 8790bool 8791attr_handles_sp_bitblt(void) 8792{ 8793 return false; 8794} 8795 8796/* attr bool leaf @ bitblt()()(ret) */ 8797bool 8798attr_leaf_bitblt(void) 8799{ 8800 return true; 8801} 8802 8803/* attr const char* name @ bitblt()()(ret) */ 8804const char* 8805attr_name_bitblt(void) 8806{ 8807 return insn_name(BIN(bitblt)); 8808} 8809 8810/* attr rb_num_t open @ bitblt()()(ret) */ 8811rb_num_t 8812attr_open_bitblt(void) 8813{ 8814 return 0; 8815} 8816 8817/* attr rb_num_t popn @ bitblt()()(ret) */ 8818rb_num_t 8819attr_popn_bitblt(void) 8820{ 8821 return 0; 8822} 8823 8824/* attr rb_num_t retn @ bitblt()()(ret) */ 8825rb_num_t 8826attr_retn_bitblt(void) 8827{ 8828 return 1; 8829} 8830 8831/* attr rb_snum_t sp_inc @ bitblt()()(ret) */ 8832rb_snum_t 8833attr_sp_inc_bitblt(void) 8834{ 8835 return 1; 8836} 8837 8838/* attr rb_num_t width @ bitblt()()(ret) */ 8839rb_num_t 8840attr_width_bitblt(void) 8841{ 8842 return 1; 8843} 8844 8845/* attr enum ruby_vminsn_type bin @ answer()()(ret) */ 8846enum ruby_vminsn_type 8847attr_bin_answer(void) 8848{ 8849 return BIN(answer); 8850} 8851 8852/* attr bool handles_sp @ answer()()(ret) */ 8853bool 8854attr_handles_sp_answer(void) 8855{ 8856 return false; 8857} 8858 8859/* attr bool leaf @ answer()()(ret) */ 8860bool 8861attr_leaf_answer(void) 8862{ 8863 return true; 8864} 8865 8866/* attr const char* name @ answer()()(ret) */ 8867const char* 8868attr_name_answer(void) 8869{ 8870 return insn_name(BIN(answer)); 8871} 8872 8873/* attr rb_num_t open @ answer()()(ret) */ 8874rb_num_t 8875attr_open_answer(void) 8876{ 8877 return 0; 8878} 8879 8880/* attr rb_num_t popn @ answer()()(ret) */ 8881rb_num_t 8882attr_popn_answer(void) 8883{ 8884 return 0; 8885} 8886 8887/* attr rb_num_t retn @ answer()()(ret) */ 8888rb_num_t 8889attr_retn_answer(void) 8890{ 8891 return 1; 8892} 8893 8894/* attr rb_snum_t sp_inc @ answer()()(ret) */ 8895rb_snum_t 8896attr_sp_inc_answer(void) 8897{ 8898 return 1; 8899} 8900 8901/* attr rb_num_t width @ answer()()(ret) */ 8902rb_num_t 8903attr_width_answer(void) 8904{ 8905 return 1; 8906} 8907 8908/* attr enum ruby_vminsn_type bin @ getlocal_WC_0(idx)()(val) */ 8909enum ruby_vminsn_type 8910attr_bin_getlocal_WC_0(MAYBE_UNUSED(lindex_t idx)) 8911{ 8912 return BIN(getlocal_WC_0); 8913} 8914 8915/* attr bool handles_sp @ getlocal_WC_0(idx)()(val) */ 8916bool 8917attr_handles_sp_getlocal_WC_0(MAYBE_UNUSED(lindex_t idx)) 8918{ 8919 return false; 8920} 8921 8922/* attr bool leaf @ getlocal_WC_0(idx)()(val) */ 8923bool 8924attr_leaf_getlocal_WC_0(MAYBE_UNUSED(lindex_t idx)) 8925{ 8926 return true; 8927} 8928 8929/* attr const char* name @ getlocal_WC_0(idx)()(val) */ 8930const char* 8931attr_name_getlocal_WC_0(MAYBE_UNUSED(lindex_t idx)) 8932{ 8933 return insn_name(BIN(getlocal_WC_0)); 8934} 8935 8936/* attr rb_num_t open @ getlocal_WC_0(idx)()(val) */ 8937rb_num_t 8938attr_open_getlocal_WC_0(MAYBE_UNUSED(lindex_t idx)) 8939{ 8940 return 1; 8941} 8942 8943/* attr rb_num_t popn @ getlocal_WC_0(idx)()(val) */ 8944rb_num_t 8945attr_popn_getlocal_WC_0(MAYBE_UNUSED(lindex_t idx)) 8946{ 8947 return 0; 8948} 8949 8950/* attr rb_num_t retn @ getlocal_WC_0(idx)()(val) */ 8951rb_num_t 8952attr_retn_getlocal_WC_0(MAYBE_UNUSED(lindex_t idx)) 8953{ 8954 return 1; 8955} 8956 8957/* attr rb_snum_t sp_inc @ getlocal_WC_0(idx)()(val) */ 8958rb_snum_t 8959attr_sp_inc_getlocal_WC_0(MAYBE_UNUSED(lindex_t idx)) 8960{ 8961 return 1; 8962} 8963 8964/* attr rb_num_t width @ getlocal_WC_0(idx)()(val) */ 8965rb_num_t 8966attr_width_getlocal_WC_0(MAYBE_UNUSED(lindex_t idx)) 8967{ 8968 return 2; 8969} 8970 8971/* attr enum ruby_vminsn_type bin @ getlocal_WC_1(idx)()(val) */ 8972enum ruby_vminsn_type 8973attr_bin_getlocal_WC_1(MAYBE_UNUSED(lindex_t idx)) 8974{ 8975 return BIN(getlocal_WC_1); 8976} 8977 8978/* attr bool handles_sp @ getlocal_WC_1(idx)()(val) */ 8979bool 8980attr_handles_sp_getlocal_WC_1(MAYBE_UNUSED(lindex_t idx)) 8981{ 8982 return false; 8983} 8984 8985/* attr bool leaf @ getlocal_WC_1(idx)()(val) */ 8986bool 8987attr_leaf_getlocal_WC_1(MAYBE_UNUSED(lindex_t idx)) 8988{ 8989 return true; 8990} 8991 8992/* attr const char* name @ getlocal_WC_1(idx)()(val) */ 8993const char* 8994attr_name_getlocal_WC_1(MAYBE_UNUSED(lindex_t idx)) 8995{ 8996 return insn_name(BIN(getlocal_WC_1)); 8997} 8998 8999/* attr rb_num_t open @ getlocal_WC_1(idx)()(val) */ 9000rb_num_t 9001attr_open_getlocal_WC_1(MAYBE_UNUSED(lindex_t idx)) 9002{ 9003 return 1; 9004} 9005 9006/* attr rb_num_t popn @ getlocal_WC_1(idx)()(val) */ 9007rb_num_t 9008attr_popn_getlocal_WC_1(MAYBE_UNUSED(lindex_t idx)) 9009{ 9010 return 0; 9011} 9012 9013/* attr rb_num_t retn @ getlocal_WC_1(idx)()(val) */ 9014rb_num_t 9015attr_retn_getlocal_WC_1(MAYBE_UNUSED(lindex_t idx)) 9016{ 9017 return 1; 9018} 9019 9020/* attr rb_snum_t sp_inc @ getlocal_WC_1(idx)()(val) */ 9021rb_snum_t 9022attr_sp_inc_getlocal_WC_1(MAYBE_UNUSED(lindex_t idx)) 9023{ 9024 return 1; 9025} 9026 9027/* attr rb_num_t width @ getlocal_WC_1(idx)()(val) */ 9028rb_num_t 9029attr_width_getlocal_WC_1(MAYBE_UNUSED(lindex_t idx)) 9030{ 9031 return 2; 9032} 9033 9034/* attr enum ruby_vminsn_type bin @ setlocal_WC_0(idx)(val)() */ 9035enum ruby_vminsn_type 9036attr_bin_setlocal_WC_0(MAYBE_UNUSED(lindex_t idx)) 9037{ 9038 return BIN(setlocal_WC_0); 9039} 9040 9041/* attr bool handles_sp @ setlocal_WC_0(idx)(val)() */ 9042bool 9043attr_handles_sp_setlocal_WC_0(MAYBE_UNUSED(lindex_t idx)) 9044{ 9045 return false; 9046} 9047 9048/* attr bool leaf @ setlocal_WC_0(idx)(val)() */ 9049bool 9050attr_leaf_setlocal_WC_0(MAYBE_UNUSED(lindex_t idx)) 9051{ 9052 return true; 9053} 9054 9055/* attr const char* name @ setlocal_WC_0(idx)(val)() */ 9056const char* 9057attr_name_setlocal_WC_0(MAYBE_UNUSED(lindex_t idx)) 9058{ 9059 return insn_name(BIN(setlocal_WC_0)); 9060} 9061 9062/* attr rb_num_t open @ setlocal_WC_0(idx)(val)() */ 9063rb_num_t 9064attr_open_setlocal_WC_0(MAYBE_UNUSED(lindex_t idx)) 9065{ 9066 return 1; 9067} 9068 9069/* attr rb_num_t popn @ setlocal_WC_0(idx)(val)() */ 9070rb_num_t 9071attr_popn_setlocal_WC_0(MAYBE_UNUSED(lindex_t idx)) 9072{ 9073 return 1; 9074} 9075 9076/* attr rb_num_t retn @ setlocal_WC_0(idx)(val)() */ 9077rb_num_t 9078attr_retn_setlocal_WC_0(MAYBE_UNUSED(lindex_t idx)) 9079{ 9080 return 0; 9081} 9082 9083/* attr rb_snum_t sp_inc @ setlocal_WC_0(idx)(val)() */ 9084rb_snum_t 9085attr_sp_inc_setlocal_WC_0(MAYBE_UNUSED(lindex_t idx)) 9086{ 9087 return -1; 9088} 9089 9090/* attr rb_num_t width @ setlocal_WC_0(idx)(val)() */ 9091rb_num_t 9092attr_width_setlocal_WC_0(MAYBE_UNUSED(lindex_t idx)) 9093{ 9094 return 2; 9095} 9096 9097/* attr enum ruby_vminsn_type bin @ setlocal_WC_1(idx)(val)() */ 9098enum ruby_vminsn_type 9099attr_bin_setlocal_WC_1(MAYBE_UNUSED(lindex_t idx)) 9100{ 9101 return BIN(setlocal_WC_1); 9102} 9103 9104/* attr bool handles_sp @ setlocal_WC_1(idx)(val)() */ 9105bool 9106attr_handles_sp_setlocal_WC_1(MAYBE_UNUSED(lindex_t idx)) 9107{ 9108 return false; 9109} 9110 9111/* attr bool leaf @ setlocal_WC_1(idx)(val)() */ 9112bool 9113attr_leaf_setlocal_WC_1(MAYBE_UNUSED(lindex_t idx)) 9114{ 9115 return true; 9116} 9117 9118/* attr const char* name @ setlocal_WC_1(idx)(val)() */ 9119const char* 9120attr_name_setlocal_WC_1(MAYBE_UNUSED(lindex_t idx)) 9121{ 9122 return insn_name(BIN(setlocal_WC_1)); 9123} 9124 9125/* attr rb_num_t open @ setlocal_WC_1(idx)(val)() */ 9126rb_num_t 9127attr_open_setlocal_WC_1(MAYBE_UNUSED(lindex_t idx)) 9128{ 9129 return 1; 9130} 9131 9132/* attr rb_num_t popn @ setlocal_WC_1(idx)(val)() */ 9133rb_num_t 9134attr_popn_setlocal_WC_1(MAYBE_UNUSED(lindex_t idx)) 9135{ 9136 return 1; 9137} 9138 9139/* attr rb_num_t retn @ setlocal_WC_1(idx)(val)() */ 9140rb_num_t 9141attr_retn_setlocal_WC_1(MAYBE_UNUSED(lindex_t idx)) 9142{ 9143 return 0; 9144} 9145 9146/* attr rb_snum_t sp_inc @ setlocal_WC_1(idx)(val)() */ 9147rb_snum_t 9148attr_sp_inc_setlocal_WC_1(MAYBE_UNUSED(lindex_t idx)) 9149{ 9150 return -1; 9151} 9152 9153/* attr rb_num_t width @ setlocal_WC_1(idx)(val)() */ 9154rb_num_t 9155attr_width_setlocal_WC_1(MAYBE_UNUSED(lindex_t idx)) 9156{ 9157 return 2; 9158} 9159 9160/* attr enum ruby_vminsn_type bin @ putobject_INT2FIX_0_()()(val) */ 9161enum ruby_vminsn_type 9162attr_bin_putobject_INT2FIX_0_(void) 9163{ 9164 return BIN(putobject_INT2FIX_0_); 9165} 9166 9167/* attr bool handles_sp @ putobject_INT2FIX_0_()()(val) */ 9168bool 9169attr_handles_sp_putobject_INT2FIX_0_(void) 9170{ 9171 return false; 9172} 9173 9174/* attr bool leaf @ putobject_INT2FIX_0_()()(val) */ 9175bool 9176attr_leaf_putobject_INT2FIX_0_(void) 9177{ 9178 return true; 9179} 9180 9181/* attr const char* name @ putobject_INT2FIX_0_()()(val) */ 9182const char* 9183attr_name_putobject_INT2FIX_0_(void) 9184{ 9185 return insn_name(BIN(putobject_INT2FIX_0_)); 9186} 9187 9188/* attr rb_num_t open @ putobject_INT2FIX_0_()()(val) */ 9189rb_num_t 9190attr_open_putobject_INT2FIX_0_(void) 9191{ 9192 return 0; 9193} 9194 9195/* attr rb_num_t popn @ putobject_INT2FIX_0_()()(val) */ 9196rb_num_t 9197attr_popn_putobject_INT2FIX_0_(void) 9198{ 9199 return 0; 9200} 9201 9202/* attr rb_num_t retn @ putobject_INT2FIX_0_()()(val) */ 9203rb_num_t 9204attr_retn_putobject_INT2FIX_0_(void) 9205{ 9206 return 1; 9207} 9208 9209/* attr rb_snum_t sp_inc @ putobject_INT2FIX_0_()()(val) */ 9210rb_snum_t 9211attr_sp_inc_putobject_INT2FIX_0_(void) 9212{ 9213 return 1; 9214} 9215 9216/* attr rb_num_t width @ putobject_INT2FIX_0_()()(val) */ 9217rb_num_t 9218attr_width_putobject_INT2FIX_0_(void) 9219{ 9220 return 1; 9221} 9222 9223/* attr enum ruby_vminsn_type bin @ putobject_INT2FIX_1_()()(val) */ 9224enum ruby_vminsn_type 9225attr_bin_putobject_INT2FIX_1_(void) 9226{ 9227 return BIN(putobject_INT2FIX_1_); 9228} 9229 9230/* attr bool handles_sp @ putobject_INT2FIX_1_()()(val) */ 9231bool 9232attr_handles_sp_putobject_INT2FIX_1_(void) 9233{ 9234 return false; 9235} 9236 9237/* attr bool leaf @ putobject_INT2FIX_1_()()(val) */ 9238bool 9239attr_leaf_putobject_INT2FIX_1_(void) 9240{ 9241 return true; 9242} 9243 9244/* attr const char* name @ putobject_INT2FIX_1_()()(val) */ 9245const char* 9246attr_name_putobject_INT2FIX_1_(void) 9247{ 9248 return insn_name(BIN(putobject_INT2FIX_1_)); 9249} 9250 9251/* attr rb_num_t open @ putobject_INT2FIX_1_()()(val) */ 9252rb_num_t 9253attr_open_putobject_INT2FIX_1_(void) 9254{ 9255 return 0; 9256} 9257 9258/* attr rb_num_t popn @ putobject_INT2FIX_1_()()(val) */ 9259rb_num_t 9260attr_popn_putobject_INT2FIX_1_(void) 9261{ 9262 return 0; 9263} 9264 9265/* attr rb_num_t retn @ putobject_INT2FIX_1_()()(val) */ 9266rb_num_t 9267attr_retn_putobject_INT2FIX_1_(void) 9268{ 9269 return 1; 9270} 9271 9272/* attr rb_snum_t sp_inc @ putobject_INT2FIX_1_()()(val) */ 9273rb_snum_t 9274attr_sp_inc_putobject_INT2FIX_1_(void) 9275{ 9276 return 1; 9277} 9278 9279/* attr rb_num_t width @ putobject_INT2FIX_1_()()(val) */ 9280rb_num_t 9281attr_width_putobject_INT2FIX_1_(void) 9282{ 9283 return 1; 9284} 9285 9286PUREFUNC(MAYBE_UNUSED(static int insn_stack_increase(int depth, int insn, const VALUE *opes))); 9287PUREFUNC(static rb_snum_t insn_stack_increase_dispatch(enum ruby_vminsn_type insn, const VALUE *opes)); 9288 9289rb_snum_t 9290insn_stack_increase_dispatch(enum ruby_vminsn_type insn, const VALUE *opes) 9291{ 9292 static const signed char t[] = { 9293 0, 1, -1, 1, -1, 1, 1, -1, 9294 1, -1, 1, -1, 0, -2, 1, -1, 9295 1, 1, 1, 1, 1, 1, -127, -1, 9296 0, -127, 0, -127, 1, 1, -127, -1, 9297 0, -127, -1, -1, 1, -127, 0, -127, 9298 -127, -127, -127, -127, 0, -1, 1, 0, 9299 -1, -127, -127, 1, 1, -127, -127, -127, 9300 -127, 0, 0, 0, -1, -1, -1, 1, 9301 0, 1, -127, -1, -1, -1, -1, -1, 9302 -1, -1, -1, -1, -1, -1, -1, -1, 9303 -1, -1, -2, -1, 0, 0, 0, 0, 9304 0, 0, 0, -1, 0, 1, 1, 1, 9305 1, -1, -1, 1, 1, 0, 0, 0, 9306 0, 0, 0, 0, 0, 0, 0, 0, 9307 0, 0, 0, 0, 0, 0, 0, 0, 9308 0, 0, 0, 0, 0, 0, 0, 0, 9309 0, 0, 0, 0, 0, 0, 0, 0, 9310 0, 0, 0, 0, 0, 0, 0, 0, 9311 0, 0, 0, 0, 0, 0, 0, 0, 9312 0, 0, 0, 0, 0, 0, 0, 0, 9313 0, 0, 0, 0, 0, 0, 0, 0, 9314 0, 0, 0, 0, 0, 0, 0, 0, 9315 0, 0, 0, 0, 0, 0, 0, 0, 9316 0, 0, 0, 0, 0, 0, 0, 0, 9317 0, 0, 0, 0, 0, 0, 0, 0, 9318 0, 0, 9319 }; 9320 signed char c = t[insn]; 9321 9322 ASSERT_VM_INSTRUCTION_SIZE(t); 9323 if (c != -127) { 9324 return c; 9325 } 9326 else switch(insn) { 9327 default: 9328 UNREACHABLE; 9329 case BIN(concatstrings): 9330 return attr_sp_inc_concatstrings(NUM2LONG(opes[0])); 9331 case BIN(toregexp): 9332 return attr_sp_inc_toregexp(NUM2LONG(opes[0]), NUM2LONG(opes[1])); 9333 case BIN(newarray): 9334 return attr_sp_inc_newarray(NUM2LONG(opes[0])); 9335 case BIN(expandarray): 9336 return attr_sp_inc_expandarray(NUM2LONG(opes[0]), NUM2LONG(opes[1])); 9337 case BIN(newhash): 9338 return attr_sp_inc_newhash(NUM2LONG(opes[0])); 9339 case BIN(dupn): 9340 return attr_sp_inc_dupn(NUM2LONG(opes[0])); 9341 case BIN(reverse): 9342 return attr_sp_inc_reverse(NUM2LONG(opes[0])); 9343 case BIN(reput): 9344 return attr_sp_inc_reput(); 9345 case BIN(topn): 9346 return attr_sp_inc_topn(NUM2LONG(opes[0])); 9347 case BIN(setn): 9348 return attr_sp_inc_setn(NUM2LONG(opes[0])); 9349 case BIN(adjuststack): 9350 return attr_sp_inc_adjuststack(NUM2LONG(opes[0])); 9351 case BIN(send): 9352 return attr_sp_inc_send((CALL_INFO)(opes[0]), (CALL_CACHE)(opes[1]), (ISEQ)(opes[2])); 9353 case BIN(opt_send_without_block): 9354 return attr_sp_inc_opt_send_without_block((CALL_INFO)(opes[0]), (CALL_CACHE)(opes[1])); 9355 case BIN(opt_newarray_max): 9356 return attr_sp_inc_opt_newarray_max(NUM2LONG(opes[0])); 9357 case BIN(opt_newarray_min): 9358 return attr_sp_inc_opt_newarray_min(NUM2LONG(opes[0])); 9359 case BIN(invokesuper): 9360 return attr_sp_inc_invokesuper((CALL_INFO)(opes[0]), (CALL_CACHE)(opes[1]), (ISEQ)(opes[2])); 9361 case BIN(invokeblock): 9362 return attr_sp_inc_invokeblock((CALL_INFO)(opes[0])); 9363 case BIN(opt_case_dispatch): 9364 return attr_sp_inc_opt_case_dispatch((CDHASH)(opes[0]), (OFFSET)(opes[1])); 9365 } 9366} 9367 9368int 9369insn_stack_increase(int depth, int insn, const VALUE *opes) 9370{ 9371 enum ruby_vminsn_type itype = (enum ruby_vminsn_type)insn; 9372 return depth + (int)insn_stack_increase_dispatch(itype, opes); 9373} 9374 9375