//===----------- JavaJIT.h - Java just in time compiler -------------------===//
//
//                            The VMKit project
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//

#ifndef JNJVM_JAVA_JIT_H
#define JNJVM_JAVA_JIT_H

#include <vector>
#include <map>

#include "llvm/BasicBlock.h"
#include "llvm/Function.h"
#include "llvm/Instructions.h"
#include "llvm/LLVMContext.h"
#include "llvm/Metadata.h"
#include "llvm/Type.h"
#include "llvm/Value.h"
#include "llvm/Support/DebugLoc.h"
#include "llvm/Analysis/DebugInfo.h"

#include "types.h"

#include "j3/JavaLLVMCompiler.h"

#include "JavaClass.h"
#include "JavaUpcalls.h"

namespace j3 {

class Class;
class JavaMethod;
class Reader;

/// Opinfo - This class gives for each opcode if it starts a new block and
/// its exception destination.
///
struct Opinfo {

  /// newBlock - If it is non-null, the block that the instruction starts.
  ///
  llvm::BasicBlock* newBlock;

  /// exceptionBlock - Never null, the exception destination of the
  /// instruction.
  ///
  llvm::BasicBlock* exceptionBlock;

  /// handler - If the instruction is the first instruction of a Java exception
  /// handler.
  ///
  bool handler;

  /// stack - The stack at this location if there is a new block
  ///
  std::vector<CommonClass*> stack;

  /// lineNumber - The line number of this bytecode.
  uint16 lineNumber;
};


struct LineInfo {
  uint16 lineNumber;
  uint16 ctpIndex;
  uint16 bytecodeIndex;
  uint16 bytecode;
};

/// JavaJIT - The compilation engine of J3. Parses the bycode and returns
/// its LLVM representation.
///
class JavaJIT {
public:
 
  /// JavaJIT - Default constructor.
  JavaJIT(JavaLLVMCompiler* C, JavaMethod* meth, llvm::Function* func) {
    compilingMethod = meth;
    compilingClass = meth->classDef;
    upcalls = compilingClass->classLoader->bootstrapLoader->upcalls;
    TheCompiler = C;
    intrinsics = TheCompiler->getIntrinsics();
    llvmFunction = func;
    llvmContext = &func->getContext();
    inlining = false;
    callsStackWalker = false;
    endNode = 0;
    currentStackIndex = 0;
    currentLineNumber = 0;
    currentBytecodeIndex = 0;
    currentCtpIndex = -1;
    currentBytecode = -1;
    callNumber = 0;
  }

  /// javaCompile - Compile the Java method.
  llvm::Function* javaCompile();
  
  /// nativeCompile - Compile the native method.
  llvm::Function* nativeCompile(intptr_t natPtr = 0);

private:
  
  /// compilingClass - The class that is defining the method being compiled.
  Class* compilingClass;

  /// compilingMethod - The method being compiled.
  JavaMethod* compilingMethod;

  /// upcalls - Upcalls used tp type the stack and locals.
  Classpath* upcalls;

  /// llvmFunction - The LLVM representation of the method.
  llvm::Function* llvmFunction;

  /// llvmContext - The current LLVM context of compilation.
  llvm::LLVMContext* llvmContext;
  
  /// intrinsics - The LLVM intrinsics where lives the compiling LLVM function.
  J3Intrinsics* intrinsics;

  /// TheCompiler - The LLVM Java compiler.
  ///
  JavaLLVMCompiler* TheCompiler;
  
  /// locals - The locals of the method.
  std::vector<llvm::AllocaInst*> intLocals;
  std::vector<llvm::AllocaInst*> longLocals;
  std::vector<llvm::AllocaInst*> floatLocals;
  std::vector<llvm::AllocaInst*> doubleLocals;
  std::vector<llvm::AllocaInst*> objectLocals;

  /// endBlock - The block that returns.
  llvm::BasicBlock* endBlock;

  /// endNode - The result of the method.
  llvm::PHINode* endNode;
  
  /// arraySize - Get the size of the array.
  llvm::Value* arraySize(llvm::Value* obj) {
    return llvm::CallInst::Create(intrinsics->ArrayLengthFunction, obj, "",
                                  currentBlock);
  }
  
  /// convertValue - Convert a value to a new type.
  void convertValue(llvm::Value*& val, const llvm::Type* t1,
                    llvm::BasicBlock* currentBlock, bool usign);
 
  /// getCurrentThread - Emit code to get the current thread.
  llvm::Value* getCurrentThread(const llvm::Type* Ty);

//===------------------------- Debugging support --------------------------===//
  
  llvm::MDNode* DbgSubprogram;
  
  /// currentLineIndex - The current line being processed.
  uint16 currentLineNumber;

  /// currentBytecodeIndex - The current bytecode being processed.
  uint16 currentBytecodeIndex;
  
  /// currentCtpIndex - The constant pool index being processed.
  uint16 currentCtpIndex;
  
  /// currentBytecode - The bytecode being processed.
  uint16 currentBytecode;
  
  /// callNumber - The number of a call for a single opcode. 
  uint16 callNumber;

  /// CreateLocation - Create debug information for a call.
  llvm::DebugLoc CreateLocation();

  // codeInfo - List of LineInfo for this method.
  std::vector<LineInfo> codeInfo;

//===--------------------------- Inline support ---------------------------===//

  /// inlineCompile - Parse the method and start its LLVM representation
  /// at curBB. endExBlock is the exception destination. args is the
  /// arguments of the method.
  llvm::Instruction* inlineCompile(llvm::BasicBlock*& curBB,
                                   llvm::BasicBlock* endExBlock,
                                   std::vector<llvm::Value*>& args);


  /// inlineMethods - Methods that are currently being inlined. The JIT
  /// uses this map to not inline a method currently bein inlined.
  std::map<JavaMethod*, bool> inlineMethods;

  /// inlining - Are we JITting a method inline?
  bool inlining;
  
  /// canBeInlined - Can this method's body be inlined?
  bool canBeInlined(JavaMethod* meth);

  /// callsStackWalker - Is the method calling a stack walker method? If it is,
  /// then this method can not be inlined.
  bool callsStackWalker;

  
//===------------------------- Bytecode parsing ---------------------------===//

  /// compileOpcodes - Parse the bytecode and create LLVM instructions.
  void compileOpcodes(uint8* bytecodes, uint32 codeLength);

  /// exploreOpcodes - Parse the bytecode and create the basic blocks.
  void exploreOpcodes(uint8* bytecodes, uint32 codeLength);
  
  /// readExceptionTable - Read the exception table in the bytecode. Prepare
  /// exception destination for all Java instructions and set the exception
  /// object to handler blocks.
  unsigned readExceptionTable(Reader& reader, uint32 codeLength);

  /// loadConstant - Load a constant from the _ldc bytecode.
  void loadConstant(uint16 index);

//===------------------------- Runtime exceptions -------------------------===//
  
  /// JITVerifyNull - Insert a null pointer check in the LLVM code.
  void JITVerifyNull(llvm::Value* obj);
  
  
  /// verifyAndComputePtr - Computes the address in the array. If out of bounds
  /// throw an exception.
  llvm::Value* verifyAndComputePtr(llvm::Value* obj, llvm::Value* index,
                                   const llvm::Type* arrayType,
                                   bool verif = true);

  /// compareFP - Do float comparisons.
  void compareFP(llvm::Value*, llvm::Value*, const llvm::Type*, bool l);
  

//===------------------------- Stack manipulation -------------------------===//

  /// stack - The compiler stack.
  std::vector<CommonClass*> stack;
  uint32 currentStackIndex;
  std::vector<llvm::AllocaInst*> objectStack;
  std::vector<llvm::AllocaInst*> intStack;
  std::vector<llvm::AllocaInst*> longStack;
  std::vector<llvm::AllocaInst*> floatStack;
  std::vector<llvm::AllocaInst*> doubleStack;

  /// push - Push a new value in the stack.
  void push(llvm::Value* val, bool unsign, CommonClass* cl = 0) {
    const llvm::Type* type = val->getType();
    if (unsign) {
      val = new llvm::ZExtInst(val, llvm::Type::getInt32Ty(*llvmContext), "", currentBlock);
      new llvm::StoreInst(val, intStack[currentStackIndex++], false,
                          currentBlock);
      stack.push_back(upcalls->OfInt);
    } else if (type == llvm::Type::getInt8Ty(*llvmContext) ||
               type == llvm::Type::getInt16Ty(*llvmContext)) {
      val = new llvm::SExtInst(val, llvm::Type::getInt32Ty(*llvmContext), "",
                               currentBlock);
      new llvm::StoreInst(val, intStack[currentStackIndex++], false,
                          currentBlock);
      stack.push_back(upcalls->OfInt);
    } else if (type == llvm::Type::getInt32Ty(*llvmContext)) {
      new llvm::StoreInst(val, intStack[currentStackIndex++], false,
                          currentBlock);
      stack.push_back(upcalls->OfInt);
    } else if (type == llvm::Type::getInt64Ty(*llvmContext)) {
      new llvm::StoreInst(val, longStack[currentStackIndex++], false,
                          currentBlock);
      stack.push_back(upcalls->OfLong);
    } else if (type == llvm::Type::getFloatTy(*llvmContext)) {
      new llvm::StoreInst(val, floatStack[currentStackIndex++], false,
                          currentBlock);
      stack.push_back(upcalls->OfFloat);
    } else if (type == llvm::Type::getDoubleTy(*llvmContext)) {
      new llvm::StoreInst(val, doubleStack[currentStackIndex++], false,
                          currentBlock);
      stack.push_back(upcalls->OfDouble);
    } else {
      assert(type == intrinsics->JavaObjectType && "Can't handle this type");
      llvm::Instruction* V = new 
        llvm::StoreInst(val, objectStack[currentStackIndex++], false,
                        currentBlock);
      stack.push_back(cl ? cl : upcalls->OfObject);
      addHighLevelType(V, topTypeInfo());
      if (llvm::Instruction* I = llvm::dyn_cast<llvm::Instruction>(val)) {
        addHighLevelType(I, topTypeInfo());
      }
    }
  }

  void addHighLevelType(llvm::Instruction* V, CommonClass* cl) {
    // Enable this when it will be actually used.
#if 0
    llvm::Value* A[1] = 
      { TheCompiler->getNativeClass(cl ? cl : upcalls->OfObject) };
    llvm::MDNode* Node = llvm::MDNode::get(*llvmContext, A, 1);
    V->setMetadata(intrinsics->MetadataTypeKind, Node);
#endif
  }

  /// pop - Pop a value from the stack and return it.
  llvm::Value* pop() {
    llvm::Value* res = top();
    --currentStackIndex;
    stack.pop_back();
    return res;
  }

  /// top - Return the value on top of the stack.
  llvm::Value* top() {
    CommonClass* cl = stack.back();
    if (cl == upcalls->OfInt)
      return new llvm::LoadInst(intStack[currentStackIndex - 1], false,
                                currentBlock);
    if (cl == upcalls->OfFloat)
      return new llvm::LoadInst(floatStack[currentStackIndex - 1], false,
                                currentBlock);
    if (cl == upcalls->OfDouble)
      return new llvm::LoadInst(doubleStack[currentStackIndex - 1], false,
                                currentBlock);
    if (cl == upcalls->OfLong)
      return new llvm::LoadInst(longStack[currentStackIndex - 1], false,
                                currentBlock);
    
    return new llvm::LoadInst(objectStack[currentStackIndex - 1], false,
                              currentBlock);
  }
  
  /// topTypeInfo - Return the type of the value on top of the stack.
  CommonClass* topTypeInfo() {
    return stack.back();
  }
 
  /// stackSize - Return the size of the stack.
  uint32 stackSize() {
    return stack.size();    
  }
  
  /// popAsInt - Pop a value from the stack and returns it as a Java
  /// int, ie signed int32.
  llvm::Value* popAsInt() {
    return pop();
  }

//===------------------------- Exception support --------------------------===//
  
  /// jsrs - The list of jsrs (jump subroutine) instructions.
  std::vector<llvm::BasicBlock*> jsrs;

  /// endExceptionBlock - The initial exception block where each handler goes
  /// if it does not handle the exception.
  llvm::BasicBlock* endExceptionBlock;

  /// currentExceptionBlock - The exception block of the current instruction.
  llvm::BasicBlock* currentExceptionBlock;

  /// unifiedUnreachable - When an exception is thrown, the code after is
  /// unreachable. All invokes that only throw an exception have the
  /// unifiedUnreachable block as their normal destination.
  llvm::BasicBlock* unifiedUnreachable;

  /// throwException - Emit code to throw an exception.
  void throwException(llvm::Function* F, llvm::Value** args,
                      uint32 nbArgs);
  void throwException(llvm::Function* F, llvm::Value* arg1);
  void throwException(llvm::Value* obj);

  /// finishExceptions - Emit code to unwind the current function if an
  /// exception is thrown.
  void finishExceptions();
//===--------------------------- Control flow  ----------------------------===//

  /// opcodeInfos - The informations for each instruction.
  Opinfo* opcodeInfos;

  /// currentBlock - The current block of the JIT.
  llvm::BasicBlock* currentBlock;

  /// createBasicBlock - Create a new basic block.
  llvm::BasicBlock* createBasicBlock(const char* name = "") {
    return llvm::BasicBlock::Create(*llvmContext, name, llvmFunction);
  }
 
  /// branch - Branch based on a boolean value.
  void branch(llvm::Value* test, llvm::BasicBlock* ifTrue, 
              llvm::BasicBlock* ifFalse, llvm::BasicBlock* insert,
              Opinfo& info) {
    if (stackSize())
      if (!info.stack.size())
        info.stack = stack;
    llvm::BranchInst::Create(ifTrue, ifFalse, test, insert);
  }

  /// branch - Branch to a new block.
  void branch(Opinfo& info, llvm::BasicBlock* insert) {
    if (stackSize())
      if (!info.stack.size())
        info.stack = stack;
    llvm::BranchInst::Create(info.newBlock, insert);
  }
  
//===-------------------------- Synchronization  --------------------------===//
  
  /// beginSynchronize - Emit synchronization code to acquire the instance
  /// or the class.
  void beginSynchronize();

  /// endSynchronize - Emit synchronization code to release the instance or the
  /// class.
  void endSynchronize();

  /// monitorEnter - Emit synchronization code to acquire the lock of the value.
  void monitorEnter(llvm::Value* obj);
  
  /// monitorExit - Emit synchronization code to release the lock of the value.
  void monitorExit(llvm::Value* obj);

//===----------------------- Java field accesses  -------------------------===//

  /// getStaticField - Emit code to get the static field declared at the given
  /// index in the constant pool.
  void getStaticField(uint16 index);

  /// setStaticField - Emit code to set a value to the static field declared
  /// at the given index in the constant pool.
  void setStaticField(uint16 index);

  /// getVirtualField - Emit code to get the virtual field declared at the given
  /// index in the constant pool.
  void getVirtualField(uint16 index);

  /// setVirtualField - Emit code to set a value to the virtual field declared
  /// at the given index in the constant pool.
  void setVirtualField(uint16 index);

  /// ldResolved - Emit code to get a pointer to a field.
  llvm::Value* ldResolved(uint16 index, bool stat, llvm::Value* object,
                          const llvm::Type* fieldType, 
                          const llvm::Type* fieldTypePtr);

//===--------------------- Constant pool accesses  ------------------------===//
 
  /// getResolvedCommonClass - Emit code to get a resolved common class. If the
  /// constant pool already links to the class, the class is emitted directly.
  /// Otherwise the JIT installs a resolver which will be called at runtime.
  llvm::Value* getResolvedCommonClass(uint16 index, bool doThrow,
                                      UserCommonClass** alreadyResolved);
  
  /// getResolvedCommonClass - Similar to getResolvedCommonClass, but the type
  /// of the returned value is Class.
  llvm::Value* getResolvedClass(uint16 index, bool clinit, bool doThrow,
                                UserClass** alreadyResolved);
  
  /// getConstantPoolAt - Return the value at the given index of the constant
  /// pool. The generated code invokes the resolver if the constant pool
  /// contains no value at the index.
  llvm::Value* getConstantPoolAt(uint32 index, llvm::Function* resolver,
                                 const llvm::Type* returnType,
                                 llvm::Value* addArg, bool doThrow = true);

//===----------------------- Java method calls  ---------------------------===//
  
  /// makeArgs - Insert the arguments of a method in the vector. The arguments
  /// are popped from the compilation stack.
  void makeArgs(llvm::FunctionType::param_iterator it,
                uint32 index, std::vector<llvm::Value*>& result, uint32 nb);

  /// invokeVirtual - Invoke a Java virtual method.
  void invokeVirtual(uint16 index);

  /// invokeInterface - Invoke a Java interface method. The buggyVirtual
  /// argument is for buggy java to bytecode compilers which emit a virtual
  /// call instead of an interface call in some occasions.
  void invokeInterface(uint16 index, bool buggyVirtual = false);

  /// invokeSpecial - Invoke an instance Java method directly.
  void invokeSpecial(uint16 index);

  /// invokeStatic - Invoke a static Java method.
  void invokeStatic(uint16 index);

  /// invokeNew - Allocate a new object.
  void invokeNew(uint16 index);

  /// invokeInline - Instead of calling the method, inline it.
  llvm::Instruction* invokeInline(JavaMethod* meth, 
                                  std::vector<llvm::Value*>& args);

  /// lowerMathOps - Map Java Math operations to LLVM intrinsics.
  llvm::Instruction* lowerMathOps(const UTF8* name, 
                                  std::vector<llvm::Value*>& args);
 
  /// lowerArraycopy - Create a fast path for System.arraycopy.
  void lowerArraycopy(std::vector<llvm::Value*>& args);

  /// invoke - invoke the LLVM method of a Java method.
  llvm::Instruction* invoke(llvm::Value *F, std::vector<llvm::Value*>&args,
                            const char* Name,
                            llvm::BasicBlock *InsertAtEnd);
  llvm::Instruction* invoke(llvm::Value *F, llvm::Value *Actual1,
                            llvm::Value *Actual2, const char* Name,
                            llvm::BasicBlock *InsertAtEnd);
  llvm::Instruction* invoke(llvm::Value *F, llvm::Value *Actual1,
                            const char* Name, llvm::BasicBlock *InsertAtEnd);
  llvm::Instruction* invoke(llvm::Value *F, const char* Name,
                            llvm::BasicBlock *InsertAtEnd);
  
//===--------------------- Yield point support  ---------------------------===//

  void checkYieldPoint();
 

#if defined(ISOLATE_SHARING)
//===----------------- Sharing bytecode support ---------------------------===//
  
  /// isolateLocal - The Jnjvm object that the method is currently executing.
  llvm::Value* isolateLocal;

  /// ctpCache - The constant pool cache.
  llvm::Value* ctpCache;

  /// getStaticInstanceCtp - Get the static instance of the class of the method
  /// being compiled.
  llvm::Value* getStaticInstanceCtp();

  /// getClassCtp - Get the class of the method being compiled.
  llvm::Value* getClassCtp();
#endif
  
};

enum Opcode {
      NOP = 0x00,
      ACONST_NULL = 0x01,
      ICONST_M1 = 0x02,
      ICONST_0 = 0x03,
      ICONST_1 = 0x04,
      ICONST_2 = 0x05,
      ICONST_3 = 0x06,
      ICONST_4 = 0x07,
      ICONST_5 = 0x08,
      LCONST_0 = 0x09,
      LCONST_1 = 0x0A,
      FCONST_0 = 0x0B,
      FCONST_1 = 0x0C,
      FCONST_2 = 0x0D,
      DCONST_0 = 0x0E,
      DCONST_1 = 0x0F,
      BIPUSH = 0x10,
      SIPUSH = 0x11,
      LDC = 0x12,
      LDC_W = 0x13,
      LDC2_W = 0x14,
      ILOAD = 0x15,
      LLOAD = 0x16,
      FLOAD = 0x17,
      DLOAD = 0x18,
      ALOAD = 0x19,
      ILOAD_0 = 0x1A,
      ILOAD_1 = 0x1B,
      ILOAD_2 = 0x1C,
      ILOAD_3 = 0x1D,
      LLOAD_0 = 0x1E,
      LLOAD_1 = 0x1F,
      LLOAD_2 = 0x20,
      LLOAD_3 = 0x21,
      FLOAD_0 = 0x22,
      FLOAD_1 = 0x23,
      FLOAD_2 = 0x24,
      FLOAD_3 = 0x25,
      DLOAD_0 = 0x26,
      DLOAD_1 = 0x27,
      DLOAD_2 = 0x28,
      DLOAD_3 = 0x29,
      ALOAD_0 = 0x2A,
      ALOAD_1 = 0x2B,
      ALOAD_2 = 0x2C,
      ALOAD_3 = 0x2D,
      IALOAD = 0x2E,
      LALOAD = 0x2F,
      FALOAD = 0x30,
      DALOAD = 0x31,
      AALOAD = 0x32,
      BALOAD = 0x33,
      CALOAD = 0x34,
      SALOAD = 0x35,
      ISTORE = 0x36,
      LSTORE = 0x37,
      FSTORE = 0x38,
      DSTORE = 0x39,
      ASTORE = 0x3A,
      ISTORE_0 = 0x3B,
      ISTORE_1 = 0x3C,
      ISTORE_2 = 0x3D,
      ISTORE_3 = 0x3E,
      LSTORE_0 = 0x3F,
      LSTORE_1 = 0x40,
      LSTORE_2 = 0x41,
      LSTORE_3 = 0x42,
      FSTORE_0 = 0x43,
      FSTORE_1 = 0x44,
      FSTORE_2 = 0x45,
      FSTORE_3 = 0x46,
      DSTORE_0 = 0x47,
      DSTORE_1 = 0x48,
      DSTORE_2 = 0x49,
      DSTORE_3 = 0x4A,
      ASTORE_0 = 0x4B,
      ASTORE_1 = 0x4C,
      ASTORE_2 = 0x4D,
      ASTORE_3 = 0x4E,
      IASTORE = 0x4F,
      LASTORE = 0x50,
      FASTORE = 0x51,
      DASTORE = 0x52,
      AASTORE = 0x53,
      BASTORE = 0x54,
      CASTORE = 0x55,
      SASTORE = 0x56,
      POP = 0x57,
      POP2 = 0x58,
      DUP = 0x59,
      DUP_X1 = 0x5A,
      DUP_X2 = 0x5B,
      DUP2 = 0x5C,
      DUP2_X1 = 0x5D,
      DUP2_X2 = 0x5E,
      SWAP = 0x5F,
      IADD = 0x60,
      LADD = 0x61,
      FADD = 0x62,
      DADD = 0x63,
      ISUB = 0x64,
      LSUB = 0x65,
      FSUB = 0x66,
      DSUB = 0x67,
      IMUL = 0x68,
      LMUL = 0x69,
      FMUL = 0x6A,
      DMUL = 0x6B,
      IDIV = 0x6C,
      LDIV = 0x6D,
      FDIV = 0x6E,
      DDIV = 0x6F,
      IREM = 0x70,
      LREM = 0x71,
      FREM = 0x72,
      DREM = 0x73,
      INEG = 0x74,
      LNEG = 0x75,
      FNEG = 0x76,
      DNEG = 0x77,
      ISHL = 0x78,
      LSHL = 0x79,
      ISHR = 0x7A,
      LSHR = 0x7B,
      IUSHR = 0x7C,
      LUSHR = 0x7D,
      IAND = 0x7E,
      LAND = 0x7F,
      IOR = 0x80,
      LOR = 0x81,
      IXOR = 0x82,
      LXOR = 0x83,
      IINC = 0x84,
      I2L = 0x85,
      I2F = 0x86,
      I2D = 0x87,
      L2I = 0x88,
      L2F = 0x89,
      L2D = 0x8A,
      F2I = 0x8B,
      F2L = 0x8C,
      F2D = 0x8D,
      D2I = 0x8E,
      D2L = 0x8F,
      D2F = 0x90,
      I2B = 0x91,
      I2C = 0x92,
      I2S = 0x93,
      LCMP = 0x94,
      FCMPL = 0x95,
      FCMPG = 0x96,
      DCMPL = 0x97,
      DCMPG = 0x98,
      IFEQ = 0x99,
      IFNE = 0x9A,
      IFLT = 0x9B,
      IFGE = 0x9C,
      IFGT = 0x9D,
      IFLE = 0x9E,
      IF_ICMPEQ = 0x9F,
      IF_ICMPNE = 0xA0,
      IF_ICMPLT = 0xA1,
      IF_ICMPGE = 0xA2,
      IF_ICMPGT = 0xA3,
      IF_ICMPLE = 0xA4,
      IF_ACMPEQ = 0xA5,
      IF_ACMPNE = 0xA6,
      GOTO = 0xA7,
      JSR = 0xA8,
      RET = 0xA9,
      TABLESWITCH = 0xAA,
      LOOKUPSWITCH = 0xAB,
      IRETURN = 0xAC,
      LRETURN = 0xAD,
      FRETURN = 0xAE,
      DRETURN = 0xAF,
      ARETURN = 0xB0,
      RETURN = 0xB1,
      GETSTATIC = 0xB2,
      PUTSTATIC = 0xB3,
      GETFIELD = 0xB4,
      PUTFIELD = 0xB5,
      INVOKEVIRTUAL = 0xB6,
      INVOKESPECIAL = 0xB7,
      INVOKESTATIC = 0xB8,
      INVOKEINTERFACE = 0xB9,
      UNUSED = 0xBA,
      NEW = 0xBB,
      NEWARRAY = 0xBC,
      ANEWARRAY = 0xBD,
      ARRAYLENGTH = 0xBE,
      ATHROW = 0xBF,
      CHECKCAST = 0xC0,
      INSTANCEOF = 0xC1,
      MONITORENTER = 0xC2,
      MONITOREXIT = 0xC3,
      WIDE = 0xC4,
      MULTIANEWARRAY = 0xC5,
      IFNULL = 0xC6,
      IFNONNULL = 0xC7,
      GOTO_W = 0xC8,
      JSR_W = 0xC9,
      BREAKPOINT = 0xCA,
      IMPDEP1 = 0xFE,
      IMPDEP2 = 0xFF
};

} // end namespace j3

#endif