| /* |
| * 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 |
| * |
| */ |
| |
| #include <iostream> |
| #include "Opcode.h" |
| #include "optarithmetic.h" |
| #include "Log.h" |
| #include "optimizer.h" |
| |
| namespace Jitrino { |
| |
| |
| // new MODIFIER system |
| // to allow some checking of modifiers and opcodes, an Operation value is checked |
| // at construction time to make sure that the modifiers appropriate to the Opcode |
| // are present. |
| // |
| // To add a new Modifier, use "NewModifier1" and "NewModifier2" as a model, |
| // but please leave them there as models for others. See Opcode.h as well; |
| // there, numbers (_IsShiftedBy and Modifier::Kind values) should be adjusted after adding |
| // the new modifier before Modifier1 |
| // |
| // Next, any instruction which uses the modifier must have the modifier as part of its |
| // modifierKind field in opcodeTable. Unfortunately, due to typing issues when there are |
| // several modifiers present, the combination must be defined in Modifer::Kind. See |
| // the definition of Overflow_and_Exception_and_Strict in Opcode.h for an example. |
| // |
| // (There may be a way to abstract some of the numeric constants, but I was hitted by a compiler |
| // issues with a more elegant solution and backed off to this.) |
| |
| struct Mobility { |
| enum Kind { |
| None, // phis, labels, pis, and the like |
| Movable, // totally movable (but must also check for Overflow modifier) |
| CSEable, // can be CSEed |
| Check, // see also |
| Exception, // can generate an exception |
| StoreOrSync, // affects memory state |
| Call, // may end a block, may have exception, may affect memory state |
| ControlFlow, // is control flow |
| Load, // is a load |
| MustEndBlock // --- not used |
| }; |
| }; |
| |
| typedef Modifier::Kind MK; |
| typedef Mobility MB; |
| |
| struct OpcodeInfo { |
| Opcode opcode; |
| bool essential; |
| Mobility::Kind mobility; |
| MK::Enum modifierKind; |
| const char *opcodeString; |
| const char *opcodeFormatString; |
| }; |
| |
| static OpcodeInfo opcodeTable[] = { |
| { Op_Add, false, MB::Movable, MK::Overflow_and_Exception_and_Strict, "add ", "add%m %s -) %l" }, |
| { Op_Mul, false, MB::Movable, MK::Overflow_and_Exception_and_Strict, "mul ", "mul%m %s -) %l", }, |
| { Op_Sub, false, MB::Movable, MK::Overflow_and_Exception_and_Strict, "sub ", "sub%m %s -) %l", }, |
| { Op_TauDiv, false, MB::Movable, MK::Signed_and_Strict, "div ", "div%m %0,%1 ((%2)) -) %l", }, // (opnds must already be checked for 0/overflow) |
| { Op_TauRem, false, MB::Movable, MK::Signed_and_Strict, "rem ", "rem%m %0,%1 ((%2)) -) %l", }, // (opnds must already be checked for 0/overflow) |
| { Op_Neg, false, MB::Movable, MK::None, "neg ", "neg %s -) %l", }, |
| { Op_MulHi, false, MB::Movable, MK::Signed, "mulhi ", "mulhi%m %s -) %l", }, // SignedModifier (but only signed needed now) |
| { Op_Min, false, MB::Movable, MK::None, "min ", "min %s -) %l", }, |
| { Op_Max, false, MB::Movable, MK::None, "max ", "max %s -) %l", }, |
| { Op_Abs, false, MB::Movable, MK::None, "abs ", "abs %s -) %l", }, |
| { Op_And, false, MB::Movable, MK::None, "and ", "and %s -) %l", }, |
| { Op_Or, false, MB::Movable, MK::None, "or ", "or %s -) %l", }, |
| { Op_Xor, false, MB::Movable, MK::None, "xor ", "xor %s -) %l", }, |
| { Op_Not, false, MB::Movable, MK::None, "not ", "not %s -) %l", }, |
| { Op_Select, false, MB::Movable, MK::None, "select", "select %s -) %l", }, // (src1 ? src2 : src3) |
| { Op_Conv, false, MB::Movable, MK::Overflow_and_Exception_and_Strict, "conv ", "conv%t%m %s -) %l", }, |
| { Op_ConvZE, false, MB::Movable, MK::Overflow_and_Exception_and_Strict, "convze ", "conv_ze_%t%m %s -) %l", }, |
| { Op_ConvUnmanaged, false, MB::StoreOrSync, MK::Overflow_and_Exception_and_Strict, "convu ", "conv_unm_%t%m %s -) %l", }, |
| { Op_Shladd, false, MB::Movable, MK::None, "shladd", "shladd %s -) %l", }, // no mods, 2nd operand must be LdConstant |
| { Op_Shl, false, MB::Movable, MK::ShiftMask, "shl ", "shl%m %s -) %l", }, |
| { Op_Shr, false, MB::Movable, MK::ShiftMask_and_Signed, "shr ", "shr%m %s -) %l", }, |
| { Op_Cmp, false, MB::Movable, MK::Comparison, "cmp ", "c%m:%t %s -) %l", }, |
| { Op_Cmp3, false, MB::Movable, MK::Comparison, "cmp3 ", "c3%m:%t %s -) %l", }, // 3-way compare, e.g.: ((s0>s1)?1:((s1>s0)?-1:0)) |
| { Op_Branch, true, MB::ControlFlow, MK::Comparison, "br ", "if c%m.%t %s goto %l", }, |
| { Op_Jump, true, MB::ControlFlow, MK::None, "jmp ", "goto %l", }, // (different from the CLI jmp opcode) |
| { Op_Switch, true, MB::ControlFlow, MK::None, "switch", "switch (%l)[%0]", }, |
| { Op_DirectCall, true, MB::Call, MK::Exception, "call ", "call %d(%p) ((%0,%1)) -) %l %b", }, |
| { Op_TauVirtualCall, true, MB::Call, MK::Exception, "callvirt", "callvrt [%2.%d](%a) ((%0,%1)) -) %l %b", }, |
| { Op_IndirectCall, true, MB::Call, MK::Exception, "calli", "calli [%0](%a) ((%1,%2)) -) %l", }, |
| { Op_IndirectMemoryCall, true, MB::Call, MK::Exception, "callimem", "callimem [%0](%a) ((%1,%2)) -) %l", }, |
| { Op_JitHelperCall, true, MB::Call, MK::Exception, "callhelper", "callhelper %d(%s) -) %l", }, |
| { Op_VMHelperCall, true, MB::Call, MK::Exception, "callvmhelper", "callvmhelper %d(%s) -) %l %b", }, |
| { Op_Return, true, MB::ControlFlow, MK::None, "return", "return %s", }, |
| { Op_Catch, true, MB::ControlFlow, MK::None, "catch", "catch -) %l", }, |
| { Op_Throw, true, MB::Exception, MK::Throw, "throw ", "throw %0 %b", }, |
| { Op_PseudoThrow, true, MB::Exception, MK::Exception, "pseudoThrow ", "pseudoThrow %b", }, |
| { Op_ThrowSystemException, true, MB::Exception, MK::None, "throwsys ", "throwsys %d %b", }, |
| { Op_ThrowLinkingException, true, MB::Exception, MK::None, "throwLink ", "throwLink", }, |
| { Op_JSR, true, MB::Call, MK::None, "jsr", "jsr %l", }, // Java only, JSR's -- DELETE |
| { Op_Ret, true, MB::ControlFlow, MK::None, "ret", "ret %s", }, // Java only, JSR's -- DELETE |
| { Op_SaveRet, true, MB::ControlFlow, MK::None, "saveret", "saveret -) %l", }, // Java only, JSR's -- DELETE |
| // Move instruction |
| { Op_Copy, false, MB::Movable, MK::None, "copy", "copy %s -) %l", }, |
| { Op_DefArg, true, MB::None, MK::DefArg, "defarg", "defarg%m -) %l", }, |
| // Load instructions |
| { Op_LdConstant, false, MB::Movable, MK::None, "ldc ", "ldc%t #%c -) %l", }, |
| { Op_LdRef, false, MB::Movable, MK::AutoCompress, "ldref ", "ldref%m (%d) -) %l %b", }, |
| { Op_LdVar, false, MB::None, MK::None, "ldvar ", "ldvar %0 -) %l", }, |
| { Op_LdVarAddr, false, MB::Movable, MK::None, "ldvara", "ldvara %0 -) %l", }, |
| { Op_TauLdInd, false, MB::Load, MK::AutoCompress_Speculative, "ldind", "ldind%m:%t [%0] ((%1,%2)) -) %l", }, |
| { Op_TauLdField, false, MB::Load, MK::AutoCompress, "ldfld", "ldfld:%t [%0.%d] ((%1,%2)) -) %l", }, |
| { Op_LdStatic, false, MB::Load, MK::AutoCompress, "ldsfld", "ldsfld:%t [%d] -) %l", }, |
| { Op_TauLdElem, false, MB::Load, MK::AutoCompress, "ldelem", "ldelem:%t [%0[%1]] ((%2,%3)) -) %l", }, |
| { Op_LdFieldAddr, false, MB::Movable, MK::None, "ldflda", "ldflda [%0.%d] -) %l", }, |
| { Op_LdStaticAddr, false, MB::Movable, MK::None, "ldsflda", "ldsflda [%d] -) %l", }, |
| { Op_LdElemAddr, false, MB::Movable, MK::None, "ldelema", "ldelema [%0[%1]] -) %l", }, |
| { Op_TauLdVTableAddr, false, MB::Movable, MK::None, "ldvtable", "ldvtable %0 ((%1)) -) %l", }, |
| { Op_TauLdIntfcVTableAddr, false, MB::Movable, MK::None, "ldintfcvt", "ldintfcvt %0,%d -) %l", }, |
| { Op_TauLdVirtFunAddr, false, MB::CSEable, MK::None, "ldvfn ", "ldvfn [%0.%d] ((%1)) -) %l", }, |
| { Op_TauLdVirtFunAddrSlot, false, MB::CSEable, MK::None, "ldvfnslot", "ldvfnslot [%0.%d] ((%1)) -) %l", }, |
| { Op_LdFunAddr, false, MB::CSEable, MK::None, "ldfn ", "ldfn [%d] -) %l", }, |
| { Op_LdFunAddrSlot, false, MB::CSEable, MK::None, "ldfnslot", "ldfnslot [%d] -) %l", }, |
| { Op_GetVTableAddr, false, MB::Movable, MK::None, "getvtable", "getvtable %d -) %l", }, // obtains the address of the vtable for a particular object type |
| { Op_GetClassObj, false, MB::Movable, MK::None, "getclassobj", "getclassobj %d -) %l", }, // obtains the java.lang.class object for a particular type |
| { Op_TauArrayLen, false, MB::CSEable, MK::None, "arraylen ", "arraylen %0 ((%1,%2)) -) %l", }, |
| { Op_LdArrayBaseAddr, false, MB::CSEable, MK::None, "ldbase", "ldbase %s -) %l", }, // load the base (zero'th element) address of array |
| { Op_AddScaledIndex, false, MB::Movable, MK::None, "addindex", "addindex %s -) %l", }, // Add a scaled index to an array element address |
| { Op_StVar, true, MB::None, MK::None, "stvar ", "stvar %0 -) %l", }, |
| { Op_TauStInd, true, MB::StoreOrSync, MK::Store_AutoCompress, "stind", "stind%m:%t %0 ((%2,%3,%4)) -) [%1]", }, |
| { Op_TauStField, true, MB::StoreOrSync, MK::Store_AutoCompress, "stfld", "stfld%m:%t %0 ((%2,%3)) -) [%1.%d]", }, |
| { Op_TauStElem, true, MB::StoreOrSync, MK::Store_AutoCompress, "stelem", "stelem%m:%t %0 ((%3,%4,%5)) -) [%1[%2]]", }, |
| { Op_TauStStatic, true, MB::StoreOrSync, MK::Store_AutoCompress, "stsfld", "stsfld:%t %0 ((%1)) -) [%d]", }, |
| { Op_TauStRef, true, MB::StoreOrSync, MK::Store_AutoCompress, "stref ", "stref%m %0 ((%3,%4,%5)) -) [%1 %2] ", }, // high-level version that will make a call to the VM |
| { Op_TauCheckBounds, false, MB::Check, MK::Overflow_and_Exception, "chkbounds", "chkbounds %1 .lt. %0 -) %l %b", }, // takes index and array length arguments, }, |
| { Op_TauCheckLowerBound, false, MB::Check, MK::Overflow_and_Exception, "chklb", "chklb %0 .le. %1 -) %l", }, // throws unless src0 <= src1 |
| { Op_TauCheckUpperBound, false, MB::Check, MK::Overflow_and_Exception, "chkub", "chkub %0 .lt. %1 -) %l", }, // throws unless src0 < src1 |
| { Op_TauCheckNull, false, MB::Check, MK::Exception_and_DefArg, "chknull", "chknull %0 -) %l %b", }, // throws NullPointerException if src is null |
| { Op_TauCheckZero, false, MB::Check, MK::Exception, "chkzero", "chkzero %0 -) %l %b", }, // for divide by zero exceptions (div and rem) |
| { Op_TauCheckDivOpnds, false, MB::Check, MK::Exception, "chkdivopnds", "chkdivopnds %0,%1 -) %l", }, // for signed divide overflow in CLI (div/rem of MAXNEGINT, -1): generates an ArithmeticException |
| { Op_TauCheckElemType, false, MB::Check, MK::Exception, "chkelemtype", "chkelemtype %0,%1 ((%2,%3)) -) %l", }, // Array element type check for aastore |
| { Op_TauCheckFinite, false, MB::Check, MK::Exception, "ckfinite", "ckfinite %s -) %l", }, // throws ArithmeticException if value is NaN or +- inifinity |
| { Op_NewObj, false, MB::Exception, MK::Exception, "newobj", "newobj %d -) %l %b", }, // OutOfMemoryException |
| { Op_NewArray, false, MB::Exception, MK::Exception, "newarray", "newarray %d[%0] -) %l %b", }, // OutOfMemoryException, NegativeArraySizeException |
| { Op_NewMultiArray, false, MB::Exception, MK::Exception, "newmultiarray", "newmultiarray %d[%s] -) %l", }, // OutOfMemoryException, NegativeArraySizeException |
| { Op_TauMonitorEnter, true, MB::StoreOrSync, MK::None, "monenter", "monenter %0 ((%1))", }, // (opnd must be non-null) |
| { Op_TauMonitorExit, true, MB::StoreOrSync, MK::Exception, "monexit", "monexit %0 ((%1))", }, // (opnd must be non-null), IllegalMonitorStateException |
| { Op_TypeMonitorEnter, true, MB::StoreOrSync, MK::None, "tmonenter", "monenter %d", }, |
| { Op_TypeMonitorExit, true, MB::StoreOrSync, MK::Exception, "tmonexit", "monexit %d", }, |
| { Op_LdLockAddr, false, MB::Movable, MK::None, "ldlockaddr", "ldlockaddr %0 -) %l", }, // yields ref:int16 |
| { Op_IncRecCount, true, MB::StoreOrSync, MK::None, "increccnt", "increccnt %s", }, // allows BalancedMonitorEnter to be used with regular MonitorExit |
| { Op_TauBalancedMonitorEnter, true, MB::StoreOrSync, MK::None, "balmonenter", "balmonenter %0,%1 ((%2)) -) %l", }, // (opnd must be non-null), postdominated by BalancedMonitorExit |
| { Op_BalancedMonitorExit, true, MB::StoreOrSync, MK::None, "balmonexit", "balmonexit %s", }, // (cannot yield exception), },dominated by BalancedMonitorEnter |
| { Op_TauOptimisticBalancedMonitorEnter, true, MB::StoreOrSync, MK::None, "optbalmonenter", "optbalmonenter %0,%1 ((%2)) -) %l", }, // (opnd must be non-null), postdominated by BalancedMonitorExit |
| { Op_OptimisticBalancedMonitorExit, true, MB::StoreOrSync, MK::Exception, "optbalmonexit", "optbalmonexit %s", }, // (cannot yield exception), },dominated by BalancedMonitorEnter |
| { Op_MonitorEnterFence, true, MB::StoreOrSync, MK::None, "monenterfence", "monenterfence %0", }, // (opnd must be non-null) |
| { Op_MonitorExitFence, true, MB::StoreOrSync, MK::None, "monexitfence", "monexitfence %0", }, // (opnd must be non-null) |
| { Op_TauStaticCast, false, MB::Movable, MK::None, "staticcast", "staticcast %0,%d ((%1)) -) %l", }, // Compile-time assertion. Asserts that cast is legal. |
| { Op_TauCast, false, MB::Check, MK::Exception, "cast ", "cast %0,%d ((%1)) -) %l %b", }, // CastException (suceeds if argument is null, returns casted object) |
| { Op_TauAsType, false, MB::Movable, MK::None, "astype", "astype %0,%d -) %l", }, // returns casted object if argument is an instance of, null otherwise |
| { Op_TauInstanceOf, false, MB::Movable, MK::None, "instanceof", "instanceof %0,%d ((%1)) -) %l",}, // returns true if argument is an instance of type T, tau opnd isNonNull |
| { Op_InitType, true, MB::CSEable, MK::Exception, "inittype", "inittype %d %b", }, // can throw a linking exception during class initialization |
| { Op_Label, true, MB::None, MK::None, "label ", "%l: %b", }, // special label instructions for branch labels, finally, catch |
| { Op_MethodEntry, true, MB::None, MK::None, "methodentry", "--- MethodEntry(%d): (%s) %b",}, // method entry label |
| { Op_MethodEnd, true, MB::None, MK::None, "methodend", "+++ MethodEnd(%d) (%s)", }, // end of a method |
| |
| // Memory instructions |
| // Special SSA nodes |
| { Op_Phi, false, MB::None, MK::None, "phi ", "phi(%s) -) %l", }, // merge point |
| { Op_TauPi, false, MB::Movable, MK::None, "pi ", "pi(%0 : %d) ((%1)) -) %l", }, // liverange split based on condition |
| |
| // Profile instrumentation instructions |
| { Op_IncCounter, true, MB::None, MK::None, "inccounter", "inccounter(%d)", }, // Increment a profile counter by 1 |
| { Op_Prefetch, true, MB::StoreOrSync, MK::None, "prefetch", "prefetch %0 ", }, //StoreOrSync |
| |
| // Compressed Pointer instructions |
| { Op_UncompressRef, false, MB::Movable, MK::None, "uncmpref", "uncmpref %s -) %l", }, |
| { Op_CompressRef, false, MB::Movable, MK::None, "cmpref", "cmpref %s -) %l", }, |
| { Op_LdFieldOffset, false, MB::Movable, MK::None, "ldfldoff", "ldfldoff [.%d] -) %l", }, |
| { Op_LdFieldOffsetPlusHeapbase, |
| false, MB::Movable, MK::None, "ldfldophb", "ldfldoffphb [.%d] -) %l", }, |
| { Op_LdArrayBaseOffset, false, MB::Movable, MK::None, "ldbaseoff", "ldbaseoff -) %l", }, |
| { Op_LdArrayBaseOffsetPlusHeapbase, |
| false, MB::Movable, MK::None, "ldbaseoffphb", "ldbaseoffphb -) %l", }, |
| { Op_LdArrayLenOffset, false, MB::Movable, MK::None, "ldlenoff", "ldlenoff -) %l", }, |
| { Op_LdArrayLenOffsetPlusHeapbase, |
| false, MB::Movable, MK::None, "ldlenoffphb", "ldlenoffphb -) %l", }, |
| { Op_AddOffset, false, MB::Movable, MK::None, "addoffset", "addoff %s -) %l", }, |
| { Op_AddOffsetPlusHeapbase, false, MB::Movable, MK::None, "addoffphb", "addoffphb %s -) %l", }, |
| |
| { Op_TauPoint, false, MB::None, MK::None, "taupoint ", "taupoint() -) %l", }, // mark |
| { Op_TauEdge, false, MB::None, MK::None, "tauedge ", "tauedge() -) %l", }, // mark |
| { Op_TauAnd, false, MB::Movable, MK::None, "tauand ", "tauand %s -) %l", }, |
| { Op_TauUnsafe, false, MB::None, MK::None, "tauunsafe", "tauunsafe() -) %l", }, // mark |
| { Op_TauSafe, false, MB::None, MK::None, "tauunsafe", "tausafe() -) %l", }, // mark |
| |
| { Op_TauCheckCast, false, MB::Check, MK::Exception, "tauchkcast ", "tauchkcast %0,%d ((%1)) -) %l", }, // CastException (suceeds if argument is null, returns casted object) |
| { Op_TauHasType, false, MB::Movable, MK::None, "tauhastype ", "tauhastype %0,%d -) %l", }, // temporary declaration that source is of given type |
| { Op_TauHasExactType, false, MB::CSEable, MK::None, "tauexacttype ", "tauexacttype %0,%d -) %l", }, // temporary declaration that source is exactly of given type |
| { Op_TauIsNonNull, true, MB::CSEable, MK::None, "tauisnonnull ", "tauisnonnull %0 -) %l", }, // temporary declaration that source null |
| { Op_IdentHC, true, MB::Call, MK::None, "identityHC", "identityHC %s -) %l ", }, |
| }; |
| |
| unsigned short Modifier::encode(Opcode opcode, U_32 numbits) const |
| { |
| assert((opcode >= 0) && (opcode < NumOpcodes)); |
| Modifier::Kind::Enum kinds = opcodeTable[opcode].modifierKind; |
| if (kinds == 0) return 0; |
| U_32 encoded = 0; |
| U_32 bitsused = 0; |
| if ((kinds & Modifier::Kind::Overflow) != 0) addEncoding(encoded, bitsused, Overflow_Mask, Overflow_None, Overflow_Unsigned, OverflowModifier_IsShiftedBy, OverflowModifier_BitsToEncode); |
| if ((kinds & Modifier::Kind::Signed) != 0) addEncoding(encoded, bitsused, Signed_Mask, SignedOp, UnsignedOp, SignedModifier_IsShiftedBy, SignedModifier_BitsToEncode); |
| if ((kinds & Modifier::Kind::Comparison) != 0) addEncoding(encoded, bitsused, Cmp_Mask, Cmp_EQ, Cmp_NonZero, ComparisonModifier_IsShiftedBy, ComparisonModifier_BitsToEncode); |
| if ((kinds & Modifier::Kind::ShiftMask) != 0) addEncoding(encoded, bitsused, ShiftMask_Mask, ShiftMask_None, ShiftMask_Masked, ShiftMaskModifier_IsShiftedBy, ShiftMaskModifier_BitsToEncode); |
| if ((kinds & Modifier::Kind::Strict) != 0) addEncoding(encoded, bitsused, Strict_Mask, Strict_No, Strict_Yes, StrictModifier_IsShiftedBy, StrictModifier_BitsToEncode); |
| if ((kinds & Modifier::Kind::DefArg) != 0) addEncoding(encoded, bitsused, DefArg_Mask, DefArgNoModifier, DefArgBothModifiers, DefArgModifier_IsShiftedBy, DefArgModifier_BitsToEncode); |
| if ((kinds & Modifier::Kind::Store) != 0) addEncoding(encoded, bitsused, Store_Mask, Store_NoWriteBarrier, Store_WriteBarrier, StoreModifier_IsShiftedBy, StoreModifier_BitsToEncode); |
| if ((kinds & Modifier::Kind::Exception) != 0) addEncoding(encoded, bitsused, Exception_Mask, Exception_Sometimes, Exception_Never, ExceptionModifier_IsShiftedBy, ExceptionModifier_BitsToEncode); |
| if ((kinds & Modifier::Kind::AutoCompress) != 0) addEncoding(encoded, bitsused, AutoCompress_Mask, AutoCompress_Yes, AutoCompress_No, AutoCompressModifier_IsShiftedBy, AutoCompressModifier_BitsToEncode); |
| if ((kinds & Modifier::Kind::Speculative) != 0) addEncoding(encoded, bitsused, |
| Speculative_Mask, Speculative_Yes, Speculative_No, SpeculativeModifier_IsShiftedBy, SpeculativeModifier_BitsToEncode); |
| if ((kinds & Modifier::Kind::Throw) != 0) addEncoding(encoded, bitsused, Throw_Mask, Throw_NoModifier, Throw_CreateStackTrace, ThrowModifier_IsShiftedBy, ThrowModifier_BitsToEncode); |
| if ((kinds & Modifier::Kind::NewModifier1) != 0) addEncoding(encoded, bitsused, NewModifier1_Mask, NewModifier1_Value1, NewModifier1_Value2, NewModifier1_IsShiftedBy, NewModifier1_BitsToEncode); |
| if ((kinds & Modifier::Kind::NewModifier2) != 0) addEncoding(encoded, bitsused, NewModifier2_Mask, NewModifier2_Value1, NewModifier2_Value3, NewModifier2_IsShiftedBy, NewModifier2_BitsToEncode); |
| assert(bitsused <= numbits); |
| unsigned short usencoded = (unsigned short) encoded; |
| assert(encoded == (U_32) usencoded); |
| if (0 && Log::isEnabled()) { |
| Log::out() << ::std::endl << "Modifier " << ::std::hex << (int) value << " and Opcode " |
| << (int) opcode << " encoded as " << (int) usencoded << ::std::dec << ::std::endl; |
| } |
| return (unsigned short) usencoded; |
| } |
| |
| Modifier::Modifier(Opcode opcode, U_32 encoding) : value(0) |
| { |
| assert((opcode >= 0) && (opcode < NumOpcodes)); |
| Modifier::Kind::Enum kinds = opcodeTable[opcode].modifierKind; |
| if (kinds == 0) return; |
| U_32 bitsused = 0; |
| if ((kinds & Modifier::Kind::Overflow) != 0) addDecoding(encoding, bitsused, Overflow_Mask, Overflow_None, Overflow_Unsigned, OverflowModifier_IsShiftedBy, OverflowModifier_BitsToEncode); |
| if ((kinds & Modifier::Kind::Signed) != 0) addDecoding(encoding, bitsused, Signed_Mask, SignedOp, UnsignedOp, SignedModifier_IsShiftedBy, SignedModifier_BitsToEncode); |
| if ((kinds & Modifier::Kind::Comparison) != 0) addDecoding(encoding, bitsused, Cmp_Mask, Cmp_EQ, Cmp_NonZero, ComparisonModifier_IsShiftedBy, ComparisonModifier_BitsToEncode); |
| if ((kinds & Modifier::Kind::ShiftMask) != 0) addDecoding(encoding, bitsused, ShiftMask_Mask, ShiftMask_None, ShiftMask_Masked, ShiftMaskModifier_IsShiftedBy, ShiftMaskModifier_BitsToEncode); |
| if ((kinds & Modifier::Kind::Strict) != 0) addDecoding(encoding, bitsused, Strict_Mask, Strict_No, Strict_Yes, StrictModifier_IsShiftedBy, StrictModifier_BitsToEncode); |
| if ((kinds & Modifier::Kind::DefArg) != 0) addDecoding(encoding, bitsused, DefArg_Mask, DefArgNoModifier, DefArgBothModifiers, DefArgModifier_IsShiftedBy, DefArgModifier_BitsToEncode); |
| if ((kinds & Modifier::Kind::Store) != 0) addDecoding(encoding, bitsused, Store_Mask, Store_NoWriteBarrier, Store_WriteBarrier, StoreModifier_IsShiftedBy, StoreModifier_BitsToEncode); |
| if ((kinds & Modifier::Kind::Exception) != 0) addDecoding(encoding, bitsused, Exception_Mask, Exception_Sometimes, Exception_Never, ExceptionModifier_IsShiftedBy, ExceptionModifier_BitsToEncode); |
| if ((kinds & Modifier::Kind::AutoCompress) != 0) addDecoding(encoding, bitsused, AutoCompress_Mask, AutoCompress_Yes, AutoCompress_No, AutoCompressModifier_IsShiftedBy, AutoCompressModifier_BitsToEncode); |
| if ((kinds & Modifier::Kind::Speculative) != 0) addDecoding(encoding, bitsused, Speculative_Mask, Speculative_Yes, Speculative_No, SpeculativeModifier_IsShiftedBy, SpeculativeModifier_BitsToEncode); |
| if ((kinds & Modifier::Kind::Throw) != 0) addDecoding(encoding, bitsused, Throw_Mask, Throw_NoModifier, Throw_CreateStackTrace, ThrowModifier_IsShiftedBy, ThrowModifier_BitsToEncode); |
| if ((kinds & Modifier::Kind::NewModifier1) != 0) addDecoding(encoding, bitsused, NewModifier1_Mask, NewModifier1_Value1, NewModifier1_Value2, NewModifier1_IsShiftedBy, NewModifier1_BitsToEncode); |
| if ((kinds & Modifier::Kind::NewModifier2) != 0) addDecoding(encoding, bitsused, NewModifier2_Mask, NewModifier2_Value1, NewModifier2_Value3, NewModifier2_IsShiftedBy, NewModifier2_BitsToEncode); |
| |
| assert(bitsused <= OPERATION_MODIFIER_BITS); |
| |
| if (0 && Log::isEnabled()) { |
| Log::out() << ::std::endl << "Opcode " << ::std::hex << (int) opcode << " and bits " << (int) encoding |
| << " decoded to Modifier " << (int) value << ::std::dec << ::std::endl; |
| } |
| assert(((U_32)encode(opcode, OPERATION_MODIFIER_BITS)) == encoding); |
| } |
| |
| |
| void Modifier::addEncoding(U_32 &encoded, U_32 &bitsused, U_32 mask, |
| U_32 minval, U_32 maxval, |
| U_32 isshiftedby, |
| U_32 bitstoencode) const |
| { |
| U_32 thisval = value & mask; |
| |
| assert((minval <= thisval) && (thisval <= maxval)); |
| U_32 encodedval = ((thisval - minval) >> isshiftedby) << bitsused; |
| encoded = encoded | encodedval ; |
| bitsused = bitsused + bitstoencode; |
| } |
| |
| void Modifier::addDecoding(U_32 &encoding, U_32 &bitsused, U_32 mask, |
| U_32 minval, U_32 maxval, |
| U_32 isshiftedby, |
| U_32 bitstoencode) |
| { |
| U_32 maskedbits = (1 << bitstoencode)-1; |
| U_32 shifted = ((encoding >> bitsused) & maskedbits) << isshiftedby; |
| U_32 decoded = shifted + minval; |
| U_32 masked = decoded & mask; |
| assert(masked != 0); |
| value |= masked; |
| bitsused = bitsused + bitstoencode; |
| } |
| |
| const char* |
| Operation::getModifierString() const { |
| assert(opcode < NumOpcodes); |
| const OpcodeInfo &info = opcodeTable[opcode]; |
| assert(info.opcode == opcode); |
| switch (info.modifierKind) { |
| case MK::None: |
| return ""; |
| |
| case MK::Overflow_and_Exception: |
| { |
| enum OverflowModifier omod = getOverflowModifier(); |
| enum ExceptionModifier emod = getExceptionModifier(); |
| switch (emod) { |
| case Exception_Sometimes: |
| switch (omod) { |
| case Overflow_None: return ""; |
| case Overflow_Signed: return ".ovf"; |
| case Overflow_Unsigned: return ".ovf.un"; |
| default: assert(0); |
| } |
| case Exception_Always: |
| switch (omod) { |
| case Overflow_None: assert(0); |
| case Overflow_Signed: return ".ovf.throw"; |
| case Overflow_Unsigned: return ".ovf.un.throw"; |
| default: assert(0); |
| } |
| case Exception_Never: |
| switch (omod) { |
| case Overflow_None: return ""; |
| case Overflow_Signed: return ".ovf.safe"; |
| case Overflow_Unsigned: return ".ovf.un.safe"; |
| default: assert(0); |
| } |
| default: assert(0); |
| } |
| } |
| break; |
| case MK::Overflow_and_Exception_and_Strict: |
| { |
| enum OverflowModifier omod = getOverflowModifier(); |
| enum ExceptionModifier emod = getExceptionModifier(); |
| enum StrictModifier smod = getStrictModifier(); |
| switch (emod) { |
| case Exception_Sometimes: |
| assert(smod == Strict_No); |
| switch (omod) { |
| case Overflow_None: return ""; |
| case Overflow_Signed: return ".ovf"; |
| case Overflow_Unsigned: return ".ovf.un"; |
| default: assert(0); |
| } |
| case Exception_Always: |
| assert(smod == Strict_No); |
| switch (omod) { |
| case Overflow_None: assert(0); |
| case Overflow_Signed: return ".ovf.throw"; |
| case Overflow_Unsigned: return ".ovf.un.throw"; |
| default: assert(0); |
| } |
| case Exception_Never: |
| switch (omod) { |
| case Overflow_None: |
| switch (smod) { |
| case Strict_No: |
| return ""; |
| case Strict_Yes: |
| return ".strict"; |
| default: |
| assert(0); |
| } |
| return ""; |
| case Overflow_Signed: |
| assert(smod == Strict_No); |
| return ".ovf.safe"; |
| case Overflow_Unsigned: |
| assert(smod == Strict_No); |
| return ".ovf.un.safe"; |
| default: assert(0); |
| } |
| default: assert(0); |
| } |
| } |
| break; |
| case MK::Signed: |
| { |
| enum SignedModifier smod = getSignedModifier(); |
| switch (smod) { |
| case SignedOp: return ""; |
| case UnsignedOp: return ".un"; |
| default: assert(0); |
| } |
| } |
| break; |
| case MK::Signed_and_Strict: |
| { |
| enum SignedModifier smod = getSignedModifier(); |
| enum StrictModifier stmod = getStrictModifier(); |
| switch (smod) { |
| case SignedOp: |
| switch (stmod) { |
| case Strict_No: return ""; |
| case Strict_Yes: return ".strict"; |
| default: assert(0); |
| } |
| return ""; |
| case UnsignedOp: |
| switch (stmod) { |
| case Strict_No: return ""; |
| case Strict_Yes: return ".un.strict"; |
| default: assert(0); |
| } |
| return ".un"; |
| default: assert(0); |
| } |
| } |
| break; |
| case MK::Comparison: |
| { |
| enum ComparisonModifier mod = getComparisonModifier(); |
| switch (mod) { |
| case Cmp_EQ: return "eq"; |
| case Cmp_NE_Un: return "ne"; |
| case Cmp_GT: return "gt"; |
| case Cmp_GT_Un: return "gtu"; |
| case Cmp_GTE: return "ge"; |
| case Cmp_GTE_Un: return "geu"; |
| case Cmp_Zero: return "z"; |
| case Cmp_NonZero: return "nz"; |
| default: |
| assert(0); |
| } |
| } |
| break; |
| case MK::ShiftMask: |
| { |
| enum ShiftMaskModifier shmod = getShiftMaskModifier(); |
| switch (shmod) { |
| case ShiftMask_None: return ""; |
| case ShiftMask_Masked: return ".mask"; |
| default: assert(0); |
| } |
| } |
| break; |
| case MK::ShiftMask_and_Signed: |
| { |
| enum SignedModifier smod = getSignedModifier(); |
| enum ShiftMaskModifier shmod = getShiftMaskModifier(); |
| switch (smod) { |
| case SignedOp: |
| switch (shmod) { |
| case ShiftMask_None: return ""; |
| case ShiftMask_Masked: return ".mask"; |
| default: assert(0); |
| } |
| case UnsignedOp: |
| switch (shmod) { |
| case ShiftMask_None: return ".un"; |
| case ShiftMask_Masked: return ".un.mask"; |
| default: assert(0); |
| } |
| default: assert(0); |
| } |
| } |
| break; |
| case MK::Strict: |
| { |
| enum StrictModifier stmod = getStrictModifier(); |
| switch (stmod) { |
| case Strict_Yes: return ".strict"; |
| case Strict_No: return ""; |
| default: assert(0); |
| } |
| } |
| break; |
| case MK::DefArg: |
| { |
| enum DefArgModifier damod = getDefArgModifier(); |
| switch (damod) { |
| case DefArgNoModifier: return ""; |
| case NonNullThisArg: return ".ths"; |
| case SpecializedToExactType: return ".xt"; |
| case DefArgBothModifiers: return ".ths.xt"; |
| default: assert(0); |
| } |
| } |
| break; |
| case MK::Store: |
| { |
| enum StoreModifier smod = getStoreModifier(); |
| switch (smod) { |
| case Store_NoWriteBarrier: return ""; |
| case Store_WriteBarrier: return ".wb"; |
| default: assert(0); |
| } |
| } |
| break; |
| case MK::Store_AutoCompress: |
| { |
| enum StoreModifier smod = getStoreModifier(); |
| enum AutoCompressModifier acmod = getAutoCompressModifier(); |
| switch (smod) { |
| case Store_NoWriteBarrier: |
| switch (acmod) { |
| case AutoCompress_Yes: return ""; |
| case AutoCompress_No: return ".unc"; |
| default: assert(0); |
| } |
| break; |
| case Store_WriteBarrier: |
| switch (acmod) { |
| case AutoCompress_Yes: return ".wb"; |
| case AutoCompress_No: return ".wb.unc"; |
| default: assert(0); |
| } |
| break; |
| default: |
| assert(0); |
| } |
| break; |
| } |
| case MK::AutoCompress_Speculative: |
| { |
| enum AutoCompressModifier acmod = getAutoCompressModifier(); |
| enum SpeculativeModifier smod = getSpeculativeModifier(); |
| switch (acmod) { |
| case AutoCompress_Yes: |
| switch(smod) { |
| case Speculative_Yes: return ".s"; |
| case Speculative_No: return ""; |
| default: assert(false); |
| } |
| case AutoCompress_No: |
| switch(smod) { |
| case Speculative_Yes: return ".s.unc"; |
| case Speculative_No: return ".unc"; |
| default: assert(false); |
| } |
| default: assert(0); |
| } |
| break; |
| } |
| case MK::Exception: |
| { |
| enum ExceptionModifier emod = getExceptionModifier(); |
| switch (emod) { |
| case Exception_Sometimes: return ""; |
| case Exception_Always: return ".throw"; |
| case Exception_Never: return ".safe"; |
| default: assert(0); |
| } |
| break; |
| } |
| case MK::AutoCompress: |
| { |
| enum AutoCompressModifier acmod = getAutoCompressModifier(); |
| switch (acmod) { |
| case AutoCompress_Yes: return ""; |
| case AutoCompress_No: return ".unc"; |
| default: assert(0); |
| } |
| break; |
| } |
| case MK::Throw: |
| { |
| // if this occurs in conjunction with other modifiers, then |
| // should modify a case above to check for it |
| enum ThrowModifier throwmod = getThrowModifier(); |
| switch (throwmod) { |
| case Throw_NoModifier: return ""; |
| case Throw_CreateStackTrace: return ".newtrace"; |
| default: assert(0); |
| } |
| break; |
| } |
| case MK::NewModifier1: |
| { |
| // if this occurs in conjunction with other modifiers, then |
| // should modify a case above to check for it |
| enum NewModifier1 new1mod = getNewModifier1(); |
| switch (new1mod) { |
| case NewModifier1_Value1: return ".new1v1"; |
| case NewModifier1_Value2: return ".new1v2"; |
| default: assert(0); |
| } |
| break; |
| } |
| case MK::NewModifier2: |
| { |
| // if this occurs in conjunction with other modifiers, then |
| // should modify a case above to check for it |
| enum NewModifier2 new2mod = getNewModifier2(); |
| switch (new2mod) { |
| case NewModifier2_Value1: return ".new2v1"; |
| case NewModifier2_Value2: return ".new2v2"; |
| case NewModifier2_Value3: return ".new2v3"; |
| default: assert(0); |
| } |
| break; |
| } |
| default: |
| assert(0); |
| } |
| assert(0); |
| return "ERROR"; |
| } |
| |
| const char* |
| Operation::getOpcodeString() const { |
| assert(opcode < NumOpcodes); |
| assert(opcodeTable[opcode].opcode == opcode); |
| const char* s = opcodeTable[opcode].opcodeString; |
| return s; |
| } |
| |
| const char* |
| Operation::getOpcodeFormatString() const { |
| assert(opcode < NumOpcodes); |
| assert(opcodeTable[opcode].opcode == opcode); |
| const char* s = opcodeTable[opcode].opcodeFormatString; |
| return s; |
| } |
| |
| bool Operation::canThrow() const |
| { |
| assert(opcode < NumOpcodes); |
| const OpcodeInfo &info = opcodeTable[opcode]; |
| assert(info.opcode == opcode); |
| if ((info.mobility == MB::Exception) || (info.mobility == MB::Check)) { |
| return true; |
| } |
| |
| if (opcode == Op_InitType) return true; |
| |
| Modifier mod = getModifier(); |
| if (mod.hasExceptionModifier()) { |
| enum ExceptionModifier emod = mod.getExceptionModifier(); |
| if (emod != Exception_Never) return true; |
| } |
| return false; |
| } |
| |
| bool Operation::isCheck() const |
| { |
| assert(opcode < NumOpcodes); |
| const OpcodeInfo &info = opcodeTable[opcode]; |
| assert(info.opcode == opcode); |
| if ((info.mobility == MB::Check)) { |
| return true; |
| } |
| return false; |
| } |
| |
| bool Operation::isMovable() const |
| { |
| if (canThrow()) return false; |
| assert(opcode < NumOpcodes); |
| const OpcodeInfo &info = opcodeTable[opcode]; |
| assert(info.opcode == opcode); |
| switch (info.mobility) { |
| case MB::None: return false; |
| case MB::Movable: return true; // overflow case is handled above |
| case MB::CSEable: return false; |
| case MB::Check: return false; |
| case MB::Exception: return false; |
| case MB::StoreOrSync: return false; |
| case MB::Call: return false; |
| case MB::ControlFlow: return false; |
| case MB::MustEndBlock: return false; |
| case MB::Load: return false; |
| default: assert(0); |
| } |
| return false; |
| } |
| |
| bool Operation::isCSEable() const { |
| assert(opcode < NumOpcodes); |
| assert(opcodeTable[opcode].opcode == opcode); |
| Mobility::Kind mobility = opcodeTable[opcode].mobility; |
| switch (mobility) { |
| case MB::Movable: // even operations with overflow are CSEable; first instance will throw |
| case MB::CSEable: |
| case MB::Check: |
| return true; |
| case MB::Load: // is CSEable for final fields, but we can't check that here. |
| default: |
| return false; |
| } |
| } |
| |
| bool Operation::isStoreOrSync() const { |
| assert(opcode < NumOpcodes); |
| const OpcodeInfo &info = opcodeTable[opcode]; |
| assert(info.opcode == opcode); |
| switch (info.mobility) { |
| case MB::Call: |
| case MB::StoreOrSync: |
| return true; |
| default: |
| break; |
| } |
| return false; |
| } |
| |
| bool Operation::mustEndBlock() const { |
| assert(opcode < NumOpcodes); |
| const OpcodeInfo &info = opcodeTable[opcode]; |
| assert(info.opcode == opcode); |
| switch (info.mobility) { |
| case MB::MustEndBlock: |
| case MB::Exception: |
| return true; |
| case MB::ControlFlow: |
| if (opcode == Op_Catch) return false; |
| return true; |
| case MB::CSEable: |
| if (opcode == Op_InitType) return true; |
| case MB::Call: |
| case MB::Movable: |
| case MB::Check: |
| case MB::StoreOrSync: |
| // must check Exception modifier |
| { |
| if (hasExceptionModifier()) { |
| enum ExceptionModifier exc = getExceptionModifier(); |
| switch (exc) { |
| case Exception_Never: |
| return false; |
| case Exception_Sometimes: |
| case Exception_Always: |
| return true; |
| default: |
| assert(0); |
| } |
| } else |
| return false; |
| } |
| default: |
| return false; |
| } |
| } |
| |
| bool Operation::isLoad() const |
| { |
| assert(opcode < NumOpcodes); |
| const OpcodeInfo &info = opcodeTable[opcode]; |
| assert(info.opcode == opcode); |
| return (info.mobility == MB::Load); |
| } |
| |
| bool Operation::isNonEssential() const |
| { |
| assert(opcode < NumOpcodes); |
| const OpcodeInfo &info = opcodeTable[opcode]; |
| assert(info.opcode == opcode); |
| if (info.essential) { |
| return false; |
| } else { |
| Modifier mod = getModifier(); |
| if (mod.hasExceptionModifier()) { |
| enum ExceptionModifier emod = mod.getExceptionModifier(); |
| if (emod != Exception_Never) { |
| return false; |
| } |
| } |
| return true; |
| } |
| } |
| |
| bool Operation::isConstant() const |
| { |
| switch (opcode) { |
| case Op_LdConstant: |
| case Op_LdRef: |
| case Op_LdVarAddr: |
| case Op_GetVTableAddr: |
| case Op_LdFieldOffset: |
| case Op_LdFieldOffsetPlusHeapbase: |
| case Op_LdArrayBaseOffset: |
| case Op_LdArrayBaseOffsetPlusHeapbase: |
| case Op_LdArrayLenOffset: |
| case Op_LdArrayLenOffsetPlusHeapbase: |
| return true; |
| default: |
| return false; |
| } |
| } |
| |
| } //namespace Jitrino |
