/* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You under the Apache License, Version 2.0 * (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ /** * @author Intel, Pavel A. Ozhdikhin * */ #ifndef _OPCODE_H_ #define _OPCODE_H_ #include "Type.h" namespace Jitrino { // // Runtime exceptions that can be thrown by instructions. // enum OpcodeExceptions { OverflowException, // for signed/unsigned arithmetic instruction DivideByZeroException, // for divide and remainder instructions NullPointerException, // any field, element or method access OutOfMemoryException, // object allocation StackOverflowException, // for local memory allocation (localloc) CastException, // for dynamic type casting (Op_TauCast) BoundsException, // array index out of bounds ArrayStoreTypeException, // stored object type incompatible with array element type NegativeArraySizeException, // (Java only) }; // // ** An instruction's opcode, modifiers, and type are encoded in a single 32-bit // word as an Operation value; see definition of Operation below. // // // The OverflowModifier is used for the Op_Add, Op_Mul, Op_Sub, and Op_Conv opcodes. // This modifier indicates whether the instruction will throw an arithmetic overflow // exception. // bits 0-1 // enum OverflowModifier { Overflow_None = 0x1 << 0, // (signed arith) Overflow_Signed = 0x2 << 0, // .ovf Overflow_Unsigned = 0x3 << 0, // .ovf.un Overflow_Mask = 0x3 << 0, OverflowModifier_IsShiftedBy = 0, OverflowModifier_BitsToEncode = 2, OverflowModifier_BitsConsumed = 2 }; inline bool isOverflowModifierSigned(enum OverflowModifier mod) { assert((Overflow_None <= mod) && (mod <= Overflow_Unsigned)); return (mod != Overflow_Unsigned); } // // The SignedModifier is used for the Op_TauDiv, Op_TauRem, Op_MulHi, and Op_Shr opcodes. // bit 2-3 // enum SignedModifier { SignedOp = 0x1 << 2, UnsignedOp = 0x2 << 2, // .un Signed_Mask = 0x3 << 2, SignedModifier_IsShiftedBy = 2, // = OverflowModifier_IsShiftedBy + OverflowModifier_BitsConsumed SignedModifier_BitsToEncode = 1, SignedModifier_BitsConsumed = 2 }; inline bool isSignedModifierSigned(enum SignedModifier mod) { assert((SignedOp <= mod) && (mod <= UnsignedOp)); return (mod != UnsignedOp); } // // The ComparisonModifier is used by the OP_Cmp and Op_Branch opcodes. // For less than and less than or equal comparisons, commute the operands and use // the Cmp_GT, and Cmp_GTE modifiers. // bits 4-7 // // Suffix _Un means: // - if integers, main function, but treat operands as unsigned integers // - if floating point, main function or unordered // enum ComparisonModifier { Cmp_EQ = 0x1 << 4, Cmp_NE_Un = 0x2 << 4, // .un: unsigned or unordered comparison (true if either parameter is NaN) Cmp_GT = 0x3 << 4, Cmp_GT_Un = 0x4 << 4, // .un: unsigned or unordered comparison (true if either parameter is NaN) Cmp_GTE = 0x5 << 4, Cmp_GTE_Un = 0x6 << 4, // .un: unsigned or unordered comparison (true if either parameter is NaN) // unary boolean comparisons Cmp_Zero = 0x7 << 4, // also cmp_null Cmp_NonZero = 0x8 << 4, // also cmp_nonull Cmp_Mask = 0xf << 4, ComparisonModifier_IsShiftedBy = 4, // = SignedModifier_IsShiftedBy + SignedModifier_BitsConsumed ComparisonModifier_BitsToEncode = 3, ComparisonModifier_BitsConsumed = 4 }; inline bool isComparisonModifierSigned(enum ComparisonModifier mod) { switch (mod) { case Cmp_EQ: case Cmp_GT: case Cmp_GTE: return true; case Cmp_NE_Un: case Cmp_GT_Un: case Cmp_GTE_Un: return false; default: break; } assert(((int)SignedOp <= (int)mod) && ((int)mod <= (int)UnsignedOp)); return ((int)mod != (int)UnsignedOp); } // There is a difference in semantics of variable shift instructions between CLI and Java. // Java says that the shift amount is quantity & mask, where mask is 0x1f for 32 bit shifts, // and 0x3f for 64 bit shifts. CLI says that this is implementation dependent. The following // bits capture that notion: enum ShiftMaskModifier { ShiftMask_None = 0x1 << 8, ShiftMask_Masked = 0x2 << 8, ShiftMask_Mask = 0x3 << 8, ShiftMaskModifier_IsShiftedBy = 8,//= ComparisonModifier_IsShiftedBy + ShiftMaskModifier_BitsConsumed ShiftMaskModifier_BitsToEncode = 1, ShiftMaskModifier_BitsConsumed = 2 }; // Java can specify strict mode for floating-point operations // enum StrictModifier { Strict_No = 0x01 << 10, Strict_Yes = 0x02 << 10, Strict_Mask = 0x03 << 10, StrictModifier_IsShiftedBy = 10, // = ShiftMaskModifier_IsShiftedBy + ..._BitsConsumed StrictModifier_BitsToEncode = 1, StrictModifier_BitsConsumed = 2 }; // // Modifier for Op_DefArg // NonNullThisArgFlag indicates that the argument is the this // parameter and is non-null. Used for the Java this parameter (which // can never be null) and for CLI when the method is specialized for // the vtable. // // SpecializedToExactType indicates that the parameter's type is exactly // the type of the instruction. This is used when a method is specialized // for the vtable type. // // Note, that these are flags, so both or neither may be set. // // update: // also a modifier for Op_TauCheckNull with different semantics: // DefArgNoModifier <-- a common 'chknull' operation that can be eliminated // by the 'hardware NPE' optimization // NonNullThisArg <-- means that 'chknull' checks for 'this' operand // (of an inlined method) and cannot be eliminated // by the 'hardware NPE' optimization // SpecializedToExactType <-- unused // enum DefArgModifier { DefArgNoModifier = 0x1 << 12, NonNullThisArg = 0x2 << 12, SpecializedToExactType = 0x3 << 12, DefArgBothModifiers = 0x4 << 12, DefArg_Mask = 0x7 << 12, DefArgModifier_IsShiftedBy = 12, // = StrictModifier_IsShiftedBy + ..._BitsConsumed DefArgModifier_BitsToEncode = 2, DefArgModifier_BitsConsumed = 3 }; enum StoreModifier { Store_NoWriteBarrier = 0x1 << 15, Store_WriteBarrier = 0x2 << 15, Store_Mask = 0x3 << 15, StoreModifier_IsShiftedBy = 15, // = DefArgModifier_IsShiftedBy + ..._BitsConsumed StoreModifier_BitsToEncode = 1, StoreModifier_BitsConsumed = 2 }; enum ExceptionModifier { Exception_Sometimes = 0x1 << 17, // the default Exception_Always = 0x2 << 17, Exception_Never = 0x3 << 17, Exception_Mask = 0x3 << 17, ExceptionModifier_IsShiftedBy = 17, // = StoreModifier_IsShiftedBy + ..._BitsConsumed ExceptionModifier_BitsToEncode = 2, ExceptionModifier_BitsConsumed = 2 }; enum SrcNonNullModifier { SrcNonNull_No = 0x1 << 19, // the default SrcNonNull_Yes = 0x2 << 19, SrcNonNull_Mask = 0x3 << 19, SrcNonNullModifier_IsShiftedBy = 19, // = ExceptionModifier_IsShiftedBy + ..._BitsConsumed SrcNonNullModifier_BitsToEncode = 1, SrcNonNullModifier_BitsConsumed = 2 }; enum AutoCompressModifier { AutoCompress_Yes = 0x1 << 21, // the default AutoCompress_No = 0x2 << 21, AutoCompress_Mask = 0x3 << 21, AutoCompressModifier_IsShiftedBy = 21, // = SrcNonNullModifier_IsShiftedBy + ..._BitsConsumed AutoCompressModifier_BitsToEncode = 1, AutoCompressModifier_BitsConsumed = 2 }; // If we are marking an instruction (load) as speculative, then the // back-end should produce either an speculative instruction (IPF's ld.s) // or enclose it in a 'catchall' region where exceptions are ignored. // enum SpeculativeModifier { Speculative_Yes = 0x1 << 23, Speculative_No = 0x2 << 23, Speculative_Mask = 0x3 << 23, SpeculativeModifier_IsShiftedBy = 23, // = AutoCompressModifier_IsShiftedBy + ..._BitsConsumed SpeculativeModifier_BitsToEncode = 1, SpeculativeModifier_BitsConsumed = 2 }; enum ThrowModifier { Throw_NoModifier = 0x1 << 25, Throw_CreateStackTrace = 0x2 << 25, Throw_Mask = 0x3 << 25, ThrowModifier_IsShiftedBy = 25, // = SpeculativeModifier_IsShiftedBy + ..._BitsConsumed ThrowModifier_BitsToEncode = 1, ThrowModifier_BitsConsumed = 2 }; enum NewModifier1 { NewModifier1_Value1 = 0x1 << 27, NewModifier1_Value2 = 0x2 << 27, NewModifier1_Mask = 0x3 << 27, NewModifier1_IsShiftedBy = 27, // = ThrowModifier_IsShiftedBy + ..._BitsConsumed NewModifier1_BitsToEncode = 1, NewModifier1_BitsConsumed = 2 }; enum NewModifier2 { NewModifier2_Value1 = 0x1 << 29, NewModifier2_Value2 = 0x2 << 29, NewModifier2_Value3 = 0x3 << 29, NewModifier2_Mask = 0x3 << 29, NewModifier2_IsShiftedBy = 29, // = NewModifier1_IsShiftedBy + ..._BitsConsumed NewModifier2_BitsToEncode = 2, NewModifier2_BitsConsumed = 2 }; enum JitHelperCallId { Prefetch, Memset0, InitializeArray, FillArrayWithConst, SaveThisState, //todo: replace with GetTLS + offset sequence ReadThisState, //todo: replace with GetTLS + offset sequence LockedCompareAndExchange, AddValueProfileValue, ArrayCopyDirect, ArrayCopyReverse, StringCompareTo, StringRegionMatches, StringIndexOf, ClassIsArray, ClassGetAllocationHandle, ClassGetTypeSize, ClassGetArrayElemSize, ClassIsInterface, ClassIsFinal, ClassGetArrayClass, ClassIsFinalizable, ClassGetFastCheckDepth }; enum Opcode { // Arithmetic Op_Add, Op_Mul, Op_Sub, // OverflowModifier, ExceptionModifier Op_TauDiv, Op_TauRem, // SignedModifier, (opnds must already be checked for 0/overflow) Op_Neg, Op_MulHi, // SignedModifier (but only signed needed now) Op_Min, Op_Max, Op_Abs, // no modifiers // Bitwise Op_And, Op_Or, Op_Xor, Op_Not, // Selection Op_Select, // (src1 ? src2 : src3) // Conversion Op_Conv, // OverflowModifier, ExceptionModifier Op_ConvZE, // OverflowModifier, ExceptionModifier Op_ConvUnmanaged, // OverflowModifier, ExceptionModifier // Shift Op_Shladd, // no mods, 2nd operand must be LdConstant Op_Shl, // ShiftMaskModifier Op_Shr, // ShiftMaskModifier, SignedModifier // Comparison Op_Cmp, // ComparisonModifier 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 Op_Branch, // ComparisonModifier Op_Jump, // (different from the CLI jmp opcode) Op_Switch, Op_DirectCall, Op_TauVirtualCall, Op_IndirectCall, Op_IndirectMemoryCall, Op_JitHelperCall, // call to a jit helper routine Op_VMHelperCall, // call to a vm (runtime) helper routine Op_Return, // Exception processing Op_Catch, Op_Throw, Op_PseudoThrow, // pseudo instruction to break infinte loops Op_ThrowSystemException, // takes a CompilationInterface::SystemExceptionId parameter Op_ThrowLinkingException, // generate a call to Helper_Throw_LinkingException Op_JSR, Op_Ret, Op_SaveRet, // Move instruction Op_Copy, Op_DefArg, // DefArgModifier // Load instructions Op_LdConstant, Op_LdRef, // String or reference Op_LdVar, Op_LdVarAddr, Op_TauLdInd, Op_TauLdField, Op_LdStatic, Op_TauLdElem, Op_LdFieldAddr, // lower to ldoffset+addoffset Op_LdStaticAddr, Op_LdElemAddr, Op_TauLdVTableAddr, Op_TauLdIntfcVTableAddr, Op_TauLdVirtFunAddr, Op_TauLdVirtFunAddrSlot, Op_LdFunAddr, Op_LdFunAddrSlot, // Move these to the loads Op_GetVTableAddr, // obtains the address of the vtable for a particular object type Op_GetClassObj, // array manipulation Op_TauArrayLen, Op_LdArrayBaseAddr, // load the base (zero'th element) address of array Op_AddScaledIndex, // Add a scaled index to an array element address // Store instructions Op_StVar, Op_TauStInd, // StoreModifier Op_TauStField, // StoreModifier Op_TauStElem, // StoreModifier Op_TauStStatic, Op_TauStRef, // high-level version that will make a call to the VM // Runtime exception check instructions // all of these take ExceptionModifier Op_TauCheckBounds, // takes index and array length arguments, ovf mod==none indicates 0<=idx*eltsize<2^31 Op_TauCheckLowerBound, // throws unless src0 <= src1 Op_TauCheckUpperBound, // throws unless src0 < src1 Op_TauCheckNull, // throws NullPointerException if source is null Op_TauCheckZero, // for divide by zero exceptions (div and rem) Op_TauCheckDivOpnds, // for signed divide overflow in CLI (div/rem of MAXNEGINT, -1): generates an ArithmeticException Op_TauCheckElemType, // Array element type check for aastore Op_TauCheckFinite, // throws ArithmeticException if value is NaN or +- inifinity // Allocation Op_NewObj, // OutOfMemoryException Op_NewArray, // OutOfMemoryException, NegativeArraySizeException Op_NewMultiArray, // OutOfMemoryException, NegativeArraySizeException // Synchronization Op_TauMonitorEnter, // (opnd must be non-null) // this could take an ExceptionModifier Op_TauMonitorExit, // (opnd must be non-null), IllegalMonitorStateException Op_TypeMonitorEnter, Op_TypeMonitorExit, // Lowered parts of MonitorEnter/Exit Op_LdLockAddr, // yields ref:int16 Op_IncRecCount, // allows BalancedMonitorEnter to be used with regular MonitorExit Op_TauBalancedMonitorEnter, // (opnd must be non-null), post-dominated by BalancedMonitorExit Op_BalancedMonitorExit, // (cannot yield exception), dominated by BalancedMonitorEnter Op_TauOptimisticBalancedMonitorEnter, // (opnd must be non-null), post-dominated by BalancedMonitorExit Op_OptimisticBalancedMonitorExit, // (may yield exception), dominated by BalancedMonitorEnter Op_MonitorEnterFence, // (opnd must be non-null) Op_MonitorExitFence, // (opnd must be non-null) // type checking // cast takes an ExceptionModifier Op_TauStaticCast, // Compile-time assertion. Asserts that cast is legal. Op_TauCast, // CastException (succeeds if argument is null, returns casted object) Op_TauAsType, // returns casted object if argument is an instance of, null otherwise Op_TauInstanceOf, // returns true if argument is a non-null instance of type T // type initialization Op_InitType, // initialize type before static method invocation // or field access. // Labels & markers Op_Label, // special label instructions for branch labels, finally, catch Op_MethodEntry, // method entry label Op_MethodEnd, // end of a method // Special SSA nodes Op_Phi, // merge point Op_TauPi, // leverage split based on condition // Profile instrumentation instructions Op_IncCounter, // Increment a profile counter by 1 Op_Prefetch, // Compressed Pointer instructions Op_UncompressRef, // uncmpref = (cmpref<