[Harmony Wiki] Update of "Jitrino OPT/opcodes" by AlexeyVarlamov

[Apache Wiki <wi...@apache.org>]

Dear Wiki user,

You have subscribed to a wiki page or wiki category on "Harmony Wiki" for change notification.

The following page has been changed by AlexeyVarlamov:
http://wiki.apache.org/harmony/Jitrino_OPT/opcodes

New page:
== List of High-Level IR opcodes used in Jitrino.OPT compiler: ==

=== Arithmetic: ===
 * [:Jitrino_OPT/opcodes/Add: Op_Add]    
 * [:Jitrino_OPT/opcodes/Mul: Op_Mul]    
 * [:Jitrino_OPT/opcodes/Sub: Op_Sub] -  OverflowModifier, ExceptionModifier
 * [:Jitrino_OPT/opcodes/TauDiv: Op_TauDiv]    
 * [:Jitrino_OPT/opcodes/TauRem: Op_TauRem] -  SignedModifier, (opnds must already be checked for 0/overflow)
 * [:Jitrino_OPT/opcodes/Neg: Op_Neg]
 * [:Jitrino_OPT/opcodes/MulHi: Op_MulHi] -  SignedModifier (but only signed needed now)
 * [:Jitrino_OPT/opcodes/Min: Op_Min]   
 * [:Jitrino_OPT/opcodes/Max: Op_Max]   
 * [:Jitrino_OPT/opcodes/Abs: Op_Abs] -  no modifiers
// Bitwise
 * [:Jitrino_OPT/opcodes/And: Op_And]    
 * [:Jitrino_OPT/opcodes/Or: Op_Or]    
 * [:Jitrino_OPT/opcodes/Xor: Op_Xor]
 * [:Jitrino_OPT/opcodes/Not: Op_Not]
// Selection
 * [:Jitrino_OPT/opcodes/Select: Op_Select] -  (src1 ? src2 : src3)
// Conversion
 * [:Jitrino_OPT/opcodes/Conv: Op_Conv] -  OverflowModifier, ExceptionModifier
 * [:Jitrino_OPT/opcodes/ConvZE: Op_ConvZE] -  OverflowModifier, ExceptionModifier    
 * [:Jitrino_OPT/opcodes/ConvUnmanaged: Op_ConvUnmanaged] -  OverflowModifier, ExceptionModifier
// Shift
 * [:Jitrino_OPT/opcodes/Shladd: Op_Shladd] -  no mods, 2nd operand must be LdConstant
 * [:Jitrino_OPT/opcodes/Shl: Op_Shl] -  ShiftMaskModifier
 * [:Jitrino_OPT/opcodes/Shr: Op_Shr] -  ShiftMaskModifier, SignedModifier
// Comparison
 * [:Jitrino_OPT/opcodes/Cmp: Op_Cmp] -  ComparisonModifier
 * [:Jitrino_OPT/opcodes/Cmp3: Op_Cmp3] -  3-way compare, e.g.: ((s0>s1)?1:((s1>s0)?-1:0)). For floats, exactly 1 of the two comparisons is unordered; the modifier in the instruction applies to the first test
                                
=== Control flow: ===
 * [:Jitrino_OPT/opcodes/Branch: Op_Branch] -  ComparisonModifier
 * [:Jitrino_OPT/opcodes/Jump: Op_Jump] -  (different from the CLI jmp opcode) 
 * [:Jitrino_OPT/opcodes/Switch: Op_Switch]
 * [:Jitrino_OPT/opcodes/DirectCall: Op_DirectCall]
 * [:Jitrino_OPT/opcodes/TauVirtualCall: Op_TauVirtualCall]
 * [:Jitrino_OPT/opcodes/IndirectCall: Op_IndirectCall]
 * [:Jitrino_OPT/opcodes/IndirectMemoryCall: Op_IndirectMemoryCall]
 * [:Jitrino_OPT/opcodes/JitHelperCall: Op_JitHelperCall] -  call to a jit helper routine
 * [:Jitrino_OPT/opcodes/VMHelperCall: Op_VMHelperCall] -  call to a vm (runtime) helper routine 
 * [:Jitrino_OPT/opcodes/Return: Op_Return]

=== Exception processing: ===
 * [:Jitrino_OPT/opcodes/Catch: Op_Catch]
 * [:Jitrino_OPT/opcodes/Throw: Op_Throw] 
 * [:Jitrino_OPT/opcodes/PseudoThrow: Op_PseudoThrow] -  pseudo instruction to break infinte loops
 * [:Jitrino_OPT/opcodes/ThrowSystemException: Op_ThrowSystemException] -  takes a CompilationInterface::SystemExceptionId parameter
 * [:Jitrino_OPT/opcodes/ThrowLinkingException: Op_ThrowLinkingException] -  generate a call to Helper_Throw_LinkingException
 * [:Jitrino_OPT/opcodes/Leave: Op_Leave]                       
 * [:Jitrino_OPT/opcodes/EndFinally: Op_EndFinally]                  

 * [:Jitrino_OPT/opcodes/EndFilter: Op_EndFilter]                   
 * [:Jitrino_OPT/opcodes/EndCatch: Op_EndCatch]                    
 * [:Jitrino_OPT/opcodes/JSR: Op_JSR]                         
 * [:Jitrino_OPT/opcodes/Ret: Op_Ret]                         
 * [:Jitrino_OPT/opcodes/SaveRet: Op_SaveRet]                     

=== Move instruction: ===
 * [:Jitrino_OPT/opcodes/Copy: Op_Copy]
 * [:Jitrino_OPT/opcodes/DefArg: Op_DefArg] -  DefArgModifier

=== Load instructions: ===
 * [:Jitrino_OPT/opcodes/LdConstant: Op_LdConstant]
 * [:Jitrino_OPT/opcodes/LdRef: Op_LdRef] -  String or reference
 * [:Jitrino_OPT/opcodes/LdVar: Op_LdVar]    
 * [:Jitrino_OPT/opcodes/LdVarAddr: Op_LdVarAddr]
 * [:Jitrino_OPT/opcodes/TauLdInd: Op_TauLdInd]
 * [:Jitrino_OPT/opcodes/TauLdField: Op_TauLdField]
 * [:Jitrino_OPT/opcodes/LdStatic: Op_LdStatic]
 * [:Jitrino_OPT/opcodes/TauLdElem: Op_TauLdElem]
 * [:Jitrino_OPT/opcodes/LdFieldAddr: Op_LdFieldAddr] -  lower to ldoffset+addoffset
 * [:Jitrino_OPT/opcodes/LdStaticAddr: Op_LdStaticAddr]
 * [:Jitrino_OPT/opcodes/LdElemAddr: Op_LdElemAddr]
 * [:Jitrino_OPT/opcodes/TauLdVTableAddr: Op_TauLdVTableAddr]

 * [:Jitrino_OPT/opcodes/TauLdIntfcVTableAddr: Op_TauLdIntfcVTableAddr]
 * [:Jitrino_OPT/opcodes/TauLdVirtFunAddr: Op_TauLdVirtFunAddr]    
 * [:Jitrino_OPT/opcodes/TauLdVirtFunAddrSlot: Op_TauLdVirtFunAddrSlot]
 * [:Jitrino_OPT/opcodes/LdFunAddr: Op_LdFunAddr]
 * [:Jitrino_OPT/opcodes/LdFunAddrSlot: Op_LdFunAddrSlot]
 * [:Jitrino_OPT/opcodes/GetVTableAddr: Op_GetVTableAddr] -  obtains the address of the vtable for a particular object type

=== Array manipulation: ===
 * [:Jitrino_OPT/opcodes/TauArrayLen: Op_TauArrayLen]        
 * [:Jitrino_OPT/opcodes/LdArrayBaseAddr: Op_LdArrayBaseAddr] -  load the base (zero'th element) address of array
 * [:Jitrino_OPT/opcodes/AddScaledIndex: Op_AddScaledIndex] -  Add a scaled index to an array element address

=== Store instructions: ===
 * [:Jitrino_OPT/opcodes/StVar: Op_StVar]
 * [:Jitrino_OPT/opcodes/TauStInd: Op_TauStInd] -  StoreModifier
 * [:Jitrino_OPT/opcodes/TauStField: Op_TauStField] -  StoreModifier
 * [:Jitrino_OPT/opcodes/TauStElem: Op_TauStElem] -  StoreModifier
 * [:Jitrino_OPT/opcodes/TauStStatic: Op_TauStStatic]                    
 * [:Jitrino_OPT/opcodes/TauStRef: Op_TauStRef] -  high-level version that will make a call to the VM

=== Runtime exception check instructions: ===
// all of these take ExceptionModifier
 * [:Jitrino_OPT/opcodes/TauCheckBounds: Op_TauCheckBounds] -  takes index and array length arguments, ovf mod==none indicates 0<=idx*eltsize<2^31
 * [:Jitrino_OPT/opcodes/TauCheckLowerBound: Op_TauCheckLowerBound] -  throws unless src0 <= src1
 * [:Jitrino_OPT/opcodes/TauCheckUpperBound: Op_TauCheckUpperBound] -  throws unless src0 < src1
 * [:Jitrino_OPT/opcodes/TauCheckNull: Op_TauCheckNull] -  throws NullPointerException if source is null
 * [:Jitrino_OPT/opcodes/TauCheckZero: Op_TauCheckZero] -  for divide by zero exceptions (div and rem)
 * [:Jitrino_OPT/opcodes/TauCheckDivOpnds: Op_TauCheckDivOpnds] -  for signed divide overflow in CLI (div/rem of MAXNEGINT, -1): generates an ArithmeticException
 * [:Jitrino_OPT/opcodes/TauCheckElemType: Op_TauCheckElemType] -  Array element type check for aastore
 * [:Jitrino_OPT/opcodes/TauCheckFinite: Op_TauCheckFinite] -  throws ArithmeticException if value is NaN or +- inifinity

=== Allocation: ===
 * [:Jitrino_OPT/opcodes/NewObj: Op_NewObj] -  OutOfMemoryException
 * [:Jitrino_OPT/opcodes/NewArray: Op_NewArray] -  OutOfMemoryException, NegativeArraySizeException
 * [:Jitrino_OPT/opcodes/NewMultiArray: Op_NewMultiArray] -  OutOfMemoryException, NegativeArraySizeException

=== Synchronization: ===
 * [:Jitrino_OPT/opcodes/TauMonitorEnter: Op_TauMonitorEnter] -  (opnd must be non-null)
// this could take an ExceptionModifier
 * [:Jitrino_OPT/opcodes/TauMonitorExit: Op_TauMonitorExit] -  (opnd must be non-null), IllegalMonitorStateException
 * [:Jitrino_OPT/opcodes/TypeMonitorEnter: Op_TypeMonitorEnter]
 * [:Jitrino_OPT/opcodes/TypeMonitorExit: Op_TypeMonitorExit]
// Lowered parts of MonitorEnter/Exit
 * [:Jitrino_OPT/opcodes/LdLockAddr: Op_LdLockAddr] -  yields ref:int16
 * [:Jitrino_OPT/opcodes/IncRecCount: Op_IncRecCount] -  allows BalancedMonitorEnter to be used with regular MonitorExit
 * [:Jitrino_OPT/opcodes/TauBalancedMonitorEnter: Op_TauBalancedMonitorEnter] -  (opnd must be non-null), post-dominated by BalancedMonitorExit
 * [:Jitrino_OPT/opcodes/BalancedMonitorExit: Op_BalancedMonitorExit] -  (cannot yield exception), dominated by BalancedMonitorEnter
 * [:Jitrino_OPT/opcodes/TauOptimisticBalancedMonitorEnter: Op_TauOptimisticBalancedMonitorEnter] -  (opnd must be non-null), post-dominated by BalancedMonitorExit
 * [:Jitrino_OPT/opcodes/OptimisticBalancedMonitorExit: Op_OptimisticBalancedMonitorExit] -  (may yield exception), dominated by BalancedMonitorEnter
 * [:Jitrino_OPT/opcodes/MonitorEnterFence: Op_MonitorEnterFence] -  (opnd must be non-null)
 * [:Jitrino_OPT/opcodes/MonitorExitFence: Op_MonitorExitFence] -  (opnd must be non-null)

=== Type checking: ===
// cast takes an ExceptionModifier
 * [:Jitrino_OPT/opcodes/TauStaticCast: Op_TauStaticCast] -  Compile-time assertion.  Asserts that cast is legal.
 * [:Jitrino_OPT/opcodes/TauCast: Op_TauCast] -  CastException (succeeds if argument is null, returns casted object)
 * [:Jitrino_OPT/opcodes/TauAsType: Op_TauAsType] -  returns casted object if argument is an instance of, null otherwise
 * [:Jitrino_OPT/opcodes/TauInstanceOf: Op_TauInstanceOf] -  returns true if argument is a non-null instance of type T
 * [:Jitrino_OPT/opcodes/TauCheckCast: Op_TauCheckCast]
 * [:Jitrino_OPT/opcodes/TauHasType: Op_TauHasType]
 * [:Jitrino_OPT/opcodes/TauHasExactType: Op_TauHasExactType]
 * [:Jitrino_OPT/opcodes/TauIsNonNull: Op_TauIsNonNull]

=== Type initialization: ===
 * [:Jitrino_OPT/opcodes/InitType: Op_InitType] -  initialize type before static method invocation or field access. 

=== Labels & markers: ===
 * [:Jitrino_OPT/opcodes/Label: Op_Label] -  special label instructions for branch labels, finally, catch
 * [:Jitrino_OPT/opcodes/MethodEntry: Op_MethodEntry] -  method entry label
 * [:Jitrino_OPT/opcodes/MethodEnd: Op_MethodEnd] -  end of a method
 * [:Jitrino_OPT/opcodes/SourceLineNumber: Op_SourceLineNumber] -  change to source position
            
=== Memory instructions: ===
 * [:Jitrino_OPT/opcodes/InitBlock: Op_InitBlock] -  memset
 * [:Jitrino_OPT/opcodes/CopyBlock: Op_CopyBlock] -  memcopy
 * [:Jitrino_OPT/opcodes/Alloca: Op_Alloca] -  allocations memory from the stack, not verifiable
 * [:Jitrino_OPT/opcodes/ArgList: Op_ArgList] -  for implementing varargs; use is private to CLI System.ArgIterator

=== Profile instrumentation instructions: ===
 * [:Jitrino_OPT/opcodes/IncCounter: Op_IncCounter] -  Increment a profile counter by 1
 * [:Jitrino_OPT/opcodes/Prefetch: Op_Prefetch]

=== Compressed Pointer instructions: ===
 * [:Jitrino_OPT/opcodes/UncompressRef: Op_UncompressRef] -  uncmpref = (cmpref<<s) + heapbase 
 * [:Jitrino_OPT/opcodes/CompressRef: Op_CompressRef] -  cmpref = uncmpref - heapbase

 * [:Jitrino_OPT/opcodes/LdFieldOffset: Op_LdFieldOffset] -  just offset
 * [:Jitrino_OPT/opcodes/LdFieldOffsetPlusHeapbase: Op_LdFieldOffsetPlusHeapbase] -  offset + heapbase
 * [:Jitrino_OPT/opcodes/LdArrayBaseOffset: Op_LdArrayBaseOffset] -  offset of array base
 * [:Jitrino_OPT/opcodes/LdArrayBaseOffsetPlusHeapbase: Op_LdArrayBaseOffsetPlusHeapbase] -  offset of array base
 * [:Jitrino_OPT/opcodes/LdArrayLenOffset: Op_LdArrayLenOffset] -  offset of array length field
 * [:Jitrino_OPT/opcodes/LdArrayLenOffsetPlusHeapbase: Op_LdArrayLenOffsetPlusHeapbase] -  offset of array length field

 * [:Jitrino_OPT/opcodes/AddOffset: Op_AddOffset] -  add uncompref+offset
 * [:Jitrino_OPT/opcodes/AddOffsetPlusHeapbase: Op_AddOffsetPlusHeapbase] -  add compref+offsetPlusHeapbase (uncompressing)

=== Special SSA nodes: ===
 * [:Jitrino_OPT/opcodes/Phi: Op_Phi] -  merge point
 * [:Jitrino_OPT/opcodes/TauPi: Op_TauPi] -  leverage split based on condition 

 * [:Jitrino_OPT/opcodes/TauPoint: Op_TauPoint]
 * [:Jitrino_OPT/opcodes/TauEdge: Op_TauEdge]
 * [:Jitrino_OPT/opcodes/TauAnd: Op_TauAnd]
 * [:Jitrino_OPT/opcodes/TauUnsafe: Op_TauUnsafe]
 * [:Jitrino_OPT/opcodes/TauSafe: Op_TauSafe]

=== Instructions for manipulating value objects in CLI: ===
 * [:Jitrino_OPT/opcodes/LdObj: Op_LdObj] -  load a value type to the stack
 * [:Jitrino_OPT/opcodes/StObj: Op_StObj] -  store a value type from the stack
 * [:Jitrino_OPT/opcodes/CopyObj: Op_CopyObj] -  copy a value type
 * [:Jitrino_OPT/opcodes/InitObj: Op_InitObj] -  initialize a value type
 * [:Jitrino_OPT/opcodes/Sizeof: Op_Sizeof] -  Pushes the size of a value type as a U4
 * [:Jitrino_OPT/opcodes/Box: Op_Box]
 * [:Jitrino_OPT/opcodes/Unbox: Op_Unbox]
 * [:Jitrino_OPT/opcodes/LdToken: Op_LdToken]    - Pushes a RuntimeMethodHandle, RuntimeTypeHandle, or RuntimeFieldHandle for 
 passing to the Reflection methods in the system class library.


=== Instruction for manipulating typed references: ===
 * [:Jitrino_OPT/opcodes/MkRefAny: Op_MkRefAny] -  transforms a pointer to a typed reference
 * [:Jitrino_OPT/opcodes/RefAnyVal: Op_RefAnyVal]                   
 * [:Jitrino_OPT/opcodes/RefAnyType: Op_RefAnyType]