/* -*- C -*- */

/* This is  an auto-generated file  and is a  part of the  programming language
 * Ruby.   The person  who  created  a program  to  generate  this file  (``I''
 * hereafter) would like  to refrain from defining licensing  of this generated
 * source code.
 *
 * This file consists of many small  parts of codes copyrighted by each author,
 * not  only  the  ``I''  person.   Those  original  authors  agree  with  some
 * open-source license.  I  believe that the license we agree  is the condition
 * mentioned in  the file COPYING.  It  states "4.  You may  modify and include
 * the part of the software into any  other software ...".  But the problem is,
 * the license never makes it clear if  such modified parts still remain in the
 * same  license, or  not.   The fact  that  we agree  with  the source  code's
 * licensing terms does not automatically  define that of generated ones.  This
 * is the reason why this file is  under an unclear situation.  All what I know
 * is that above provision guarantees this file to exist.
 *
 * Please let me hesitate to declare  something about this nuanced contract.  I
 * am not in the position to take  over other authors' license to merge into my
 * one.  Changing them to (say) GPLv3 is not doable by myself.  Perhaps someday
 * it might turn  out to be okay to  say this file is under a  license.  I wish
 * the situation would become more clear in the future. */

/*******************************************************************/
/*******************************************************************/
/*******************************************************************/
/**
  This file contains YARV instruction list.

  ----
  This file is auto generated by insns2vm.rb
  DO NOT TOUCH!

  If you want to fix something, you must edit "tool/ruby_vm/views/insns.inc.erb"
  or tool/insns2vm.rb
 */

#ifndef INSNS_INC
#define INSNS_INC 1

/* BIN : Basic Instruction Name */
#define BIN(n) YARVINSN_##n

enum ruby_vminsn_type {
    BIN(nop),
    BIN(getlocal),
    BIN(setlocal),
    BIN(getblockparam),
    BIN(setblockparam),
    BIN(getblockparamproxy),
    BIN(getspecial),
    BIN(setspecial),
    BIN(getinstancevariable),
    BIN(setinstancevariable),
    BIN(getclassvariable),
    BIN(setclassvariable),
    BIN(opt_getconstant_path),
    BIN(getconstant),
    BIN(setconstant),
    BIN(getglobal),
    BIN(setglobal),
    BIN(putnil),
    BIN(putself),
    BIN(putobject),
    BIN(putspecialobject),
    BIN(putstring),
    BIN(putchilledstring),
    BIN(concatstrings),
    BIN(anytostring),
    BIN(toregexp),
    BIN(intern),
    BIN(newarray),
    BIN(pushtoarraykwsplat),
    BIN(duparray),
    BIN(duphash),
    BIN(expandarray),
    BIN(concatarray),
    BIN(concattoarray),
    BIN(pushtoarray),
    BIN(splatarray),
    BIN(splatkw),
    BIN(newhash),
    BIN(newrange),
    BIN(pop),
    BIN(dup),
    BIN(dupn),
    BIN(swap),
    BIN(opt_reverse),
    BIN(topn),
    BIN(setn),
    BIN(adjuststack),
    BIN(defined),
    BIN(definedivar),
    BIN(checkmatch),
    BIN(checkkeyword),
    BIN(checktype),
    BIN(defineclass),
    BIN(definemethod),
    BIN(definesmethod),
    BIN(send),
    BIN(sendforward),
    BIN(opt_send_without_block),
    BIN(opt_new),
    BIN(objtostring),
    BIN(opt_ary_freeze),
    BIN(opt_hash_freeze),
    BIN(opt_str_freeze),
    BIN(opt_nil_p),
    BIN(opt_str_uminus),
    BIN(opt_duparray_send),
    BIN(opt_newarray_send),
    BIN(invokesuper),
    BIN(invokesuperforward),
    BIN(invokeblock),
    BIN(leave),
    BIN(throw),
    BIN(jump),
    BIN(branchif),
    BIN(branchunless),
    BIN(branchnil),
    BIN(once),
    BIN(opt_case_dispatch),
    BIN(opt_plus),
    BIN(opt_minus),
    BIN(opt_mult),
    BIN(opt_div),
    BIN(opt_mod),
    BIN(opt_eq),
    BIN(opt_neq),
    BIN(opt_lt),
    BIN(opt_le),
    BIN(opt_gt),
    BIN(opt_ge),
    BIN(opt_ltlt),
    BIN(opt_and),
    BIN(opt_or),
    BIN(opt_aref),
    BIN(opt_aset),
    BIN(opt_length),
    BIN(opt_size),
    BIN(opt_empty_p),
    BIN(opt_succ),
    BIN(opt_not),
    BIN(opt_regexpmatch2),
    BIN(invokebuiltin),
    BIN(opt_invokebuiltin_delegate),
    BIN(opt_invokebuiltin_delegate_leave),
    BIN(getlocal_WC_0),
    BIN(getlocal_WC_1),
    BIN(setlocal_WC_0),
    BIN(setlocal_WC_1),
    BIN(putobject_INT2FIX_0_),
    BIN(putobject_INT2FIX_1_),
    BIN(trace_nop),
    BIN(trace_getlocal),
    BIN(trace_setlocal),
    BIN(trace_getblockparam),
    BIN(trace_setblockparam),
    BIN(trace_getblockparamproxy),
    BIN(trace_getspecial),
    BIN(trace_setspecial),
    BIN(trace_getinstancevariable),
    BIN(trace_setinstancevariable),
    BIN(trace_getclassvariable),
    BIN(trace_setclassvariable),
    BIN(trace_opt_getconstant_path),
    BIN(trace_getconstant),
    BIN(trace_setconstant),
    BIN(trace_getglobal),
    BIN(trace_setglobal),
    BIN(trace_putnil),
    BIN(trace_putself),
    BIN(trace_putobject),
    BIN(trace_putspecialobject),
    BIN(trace_putstring),
    BIN(trace_putchilledstring),
    BIN(trace_concatstrings),
    BIN(trace_anytostring),
    BIN(trace_toregexp),
    BIN(trace_intern),
    BIN(trace_newarray),
    BIN(trace_pushtoarraykwsplat),
    BIN(trace_duparray),
    BIN(trace_duphash),
    BIN(trace_expandarray),
    BIN(trace_concatarray),
    BIN(trace_concattoarray),
    BIN(trace_pushtoarray),
    BIN(trace_splatarray),
    BIN(trace_splatkw),
    BIN(trace_newhash),
    BIN(trace_newrange),
    BIN(trace_pop),
    BIN(trace_dup),
    BIN(trace_dupn),
    BIN(trace_swap),
    BIN(trace_opt_reverse),
    BIN(trace_topn),
    BIN(trace_setn),
    BIN(trace_adjuststack),
    BIN(trace_defined),
    BIN(trace_definedivar),
    BIN(trace_checkmatch),
    BIN(trace_checkkeyword),
    BIN(trace_checktype),
    BIN(trace_defineclass),
    BIN(trace_definemethod),
    BIN(trace_definesmethod),
    BIN(trace_send),
    BIN(trace_sendforward),
    BIN(trace_opt_send_without_block),
    BIN(trace_opt_new),
    BIN(trace_objtostring),
    BIN(trace_opt_ary_freeze),
    BIN(trace_opt_hash_freeze),
    BIN(trace_opt_str_freeze),
    BIN(trace_opt_nil_p),
    BIN(trace_opt_str_uminus),
    BIN(trace_opt_duparray_send),
    BIN(trace_opt_newarray_send),
    BIN(trace_invokesuper),
    BIN(trace_invokesuperforward),
    BIN(trace_invokeblock),
    BIN(trace_leave),
    BIN(trace_throw),
    BIN(trace_jump),
    BIN(trace_branchif),
    BIN(trace_branchunless),
    BIN(trace_branchnil),
    BIN(trace_once),
    BIN(trace_opt_case_dispatch),
    BIN(trace_opt_plus),
    BIN(trace_opt_minus),
    BIN(trace_opt_mult),
    BIN(trace_opt_div),
    BIN(trace_opt_mod),
    BIN(trace_opt_eq),
    BIN(trace_opt_neq),
    BIN(trace_opt_lt),
    BIN(trace_opt_le),
    BIN(trace_opt_gt),
    BIN(trace_opt_ge),
    BIN(trace_opt_ltlt),
    BIN(trace_opt_and),
    BIN(trace_opt_or),
    BIN(trace_opt_aref),
    BIN(trace_opt_aset),
    BIN(trace_opt_length),
    BIN(trace_opt_size),
    BIN(trace_opt_empty_p),
    BIN(trace_opt_succ),
    BIN(trace_opt_not),
    BIN(trace_opt_regexpmatch2),
    BIN(trace_invokebuiltin),
    BIN(trace_opt_invokebuiltin_delegate),
    BIN(trace_opt_invokebuiltin_delegate_leave),
    BIN(trace_getlocal_WC_0),
    BIN(trace_getlocal_WC_1),
    BIN(trace_setlocal_WC_0),
    BIN(trace_setlocal_WC_1),
    BIN(trace_putobject_INT2FIX_0_),
    BIN(trace_putobject_INT2FIX_1_),
#if USE_ZJIT
    BIN(zjit_getinstancevariable),
    BIN(zjit_setinstancevariable),
    BIN(zjit_definedivar),
    BIN(zjit_send),
    BIN(zjit_opt_send_without_block),
    BIN(zjit_objtostring),
    BIN(zjit_opt_nil_p),
    BIN(zjit_invokeblock),
    BIN(zjit_opt_plus),
    BIN(zjit_opt_minus),
    BIN(zjit_opt_mult),
    BIN(zjit_opt_div),
    BIN(zjit_opt_mod),
    BIN(zjit_opt_eq),
    BIN(zjit_opt_neq),
    BIN(zjit_opt_lt),
    BIN(zjit_opt_le),
    BIN(zjit_opt_gt),
    BIN(zjit_opt_ge),
    BIN(zjit_opt_ltlt),
    BIN(zjit_opt_and),
    BIN(zjit_opt_or),
    BIN(zjit_opt_aref),
    BIN(zjit_opt_aset),
    BIN(zjit_opt_length),
    BIN(zjit_opt_size),
    BIN(zjit_opt_empty_p),
    BIN(zjit_opt_succ),
    BIN(zjit_opt_not),
    BIN(zjit_opt_regexpmatch2),
#endif
    VM_INSTRUCTION_SIZE
};

#define VM_BARE_INSTRUCTION_SIZE 109

#define ASSERT_VM_INSTRUCTION_SIZE(array) \
    STATIC_ASSERT(numberof_##array, numberof(array) == VM_INSTRUCTION_SIZE)

#endif
