| /* |
| * 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, Vyacheslav P. Shakin |
| * |
| */ |
| |
| #ifndef _CODEGENINTFC_H_ |
| #define _CODEGENINTFC_H_ |
| |
| #include "open/types.h" |
| #include "Type.h" |
| #include "Jitrino.h" |
| #include "VMInterface.h" |
| #include "Stl.h" |
| |
| |
| |
| namespace Jitrino |
| { |
| |
| // struct ::JitFrameContext; |
| class CG_OpndHandle { |
| }; |
| |
| |
| // "_Ovf" types are used to support CLI's overflow semantics. CLI supports |
| // overflow arithmetic. If an overflow type is used below, generated code must |
| // test for and throw an exception if an overflow occurs. |
| |
| class ArithmeticOp { |
| public: |
| enum Types { |
| I4, I4_Ovf, U4_Ovf, |
| I8, I8_Ovf, U8_Ovf, |
| I, I_Ovf, U_Ovf, |
| F, S, D |
| }; |
| }; |
| |
| class RefArithmeticOp { |
| public: |
| enum Types { |
| I4, I, U4_Ovf, U_Ovf |
| }; |
| }; |
| |
| class IntegerOp { |
| public: |
| enum Types { |
| I4, |
| I8, |
| I |
| }; |
| }; |
| |
| class DivOp { |
| public: |
| enum Types { |
| I4, U4, |
| I8, U8, |
| I, U, |
| F, S, D |
| }; |
| }; |
| |
| class MulHiOp { |
| public: |
| enum Types { |
| I4, U4, I8, U8, I, U |
| }; |
| }; |
| |
| class NegOp { |
| public: |
| enum Types { |
| I4, |
| I8, |
| I, |
| F, S, D |
| }; |
| }; |
| |
| class CompareOp { |
| public: |
| enum Types { |
| I4, |
| I8, |
| I, |
| F, S, D, |
| Ref, |
| CompRef |
| }; |
| enum Operators { |
| Eq, // equal |
| Ne, // int: not equal; |
| // fp: not equal or unordered |
| Gt, // greater than |
| Gtu, // int: greater than unsigned; |
| // fp: greater than or unordered |
| Ge, // greater than or equal |
| Geu // int: greater than or equal unsigned; |
| // fp: greater than or equal or unordered |
| }; |
| }; |
| |
| class CompareZeroOp { |
| public: |
| enum Types { |
| I4, |
| I8, |
| I, |
| Ref, |
| CompRef |
| }; |
| }; |
| |
| class ConvertToIntOp { |
| public: |
| enum Types { |
| I1, I2, I4, I8, I |
| }; |
| enum OverflowMod { |
| NoOvf, |
| SignedOvf, |
| UnsignedOvf |
| }; |
| }; |
| |
| class ConvertToFpOp { |
| public: |
| enum Types { |
| Single, |
| Double, |
| FloatFromUnsigned |
| }; |
| }; |
| |
| class JitHelperCallOp { |
| public: |
| enum Id { |
| Prefetch, |
| Memset0, |
| InitializeArray, |
| FillArrayWithConst, |
| SaveThisState, |
| ReadThisState, |
| LockedCompareAndExchange, |
| AddValueProfileValue, |
| ArrayCopyDirect, |
| ArrayCopyReverse, |
| StringCompareTo, |
| StringRegionMatches, |
| StringIndexOf |
| }; |
| }; |
| |
| class InstructionCallback { |
| public: |
| virtual ~InstructionCallback() {} |
| virtual void opndMaybeGlobal(CG_OpndHandle* opnd) = 0; |
| |
| // tau generating instructions |
| virtual CG_OpndHandle* tauPoint() = 0; // depends on all preceding branches |
| virtual CG_OpndHandle* tauEdge() = 0; // tied to incoming edge |
| virtual CG_OpndHandle* tauAnd(U_32 numArgs, CG_OpndHandle** args) = 0; |
| virtual CG_OpndHandle* tauUnsafe() = 0; // have lost dependence info, don't move uses |
| virtual CG_OpndHandle* tauSafe() = 0; // operation is always safe |
| |
| virtual CG_OpndHandle* add(ArithmeticOp::Types,CG_OpndHandle* src1,CG_OpndHandle* src2) = 0; |
| virtual CG_OpndHandle* addRef(RefArithmeticOp::Types,CG_OpndHandle* refSrc,CG_OpndHandle* intSrc) = 0; |
| virtual CG_OpndHandle* sub(ArithmeticOp::Types,CG_OpndHandle* src1,CG_OpndHandle* src2) = 0; |
| virtual CG_OpndHandle* subRef(RefArithmeticOp::Types,CG_OpndHandle* refSrc, CG_OpndHandle* intSrc) = 0; |
| virtual CG_OpndHandle* diffRef(bool ovf, CG_OpndHandle* ref1,CG_OpndHandle* ref2) = 0; |
| virtual CG_OpndHandle* mul(ArithmeticOp::Types,CG_OpndHandle* src1,CG_OpndHandle* src2) = 0; |
| virtual CG_OpndHandle* tau_div(DivOp::Types,CG_OpndHandle* src1,CG_OpndHandle* src2, |
| CG_OpndHandle *tauSrc1NonZero) = 0; |
| virtual CG_OpndHandle* tau_rem(DivOp::Types,CG_OpndHandle* src1,CG_OpndHandle* src2, |
| CG_OpndHandle *tauSrc2NonZero) = 0; |
| virtual CG_OpndHandle* neg(NegOp::Types,CG_OpndHandle* src) = 0; |
| virtual CG_OpndHandle* mulhi(MulHiOp::Types,CG_OpndHandle* src1,CG_OpndHandle* src2) = 0; |
| virtual CG_OpndHandle* min_op(NegOp::Types,CG_OpndHandle* src1,CG_OpndHandle* src2) = 0; |
| virtual CG_OpndHandle* max_op(NegOp::Types,CG_OpndHandle* src1,CG_OpndHandle* src2) = 0; |
| virtual CG_OpndHandle* abs_op(NegOp::Types,CG_OpndHandle* src1) = 0; |
| virtual CG_OpndHandle* tau_ckfinite(CG_OpndHandle* src) = 0; |
| virtual CG_OpndHandle* and_(IntegerOp::Types,CG_OpndHandle* src1,CG_OpndHandle* src2) = 0; |
| virtual CG_OpndHandle* or_(IntegerOp::Types,CG_OpndHandle* src1,CG_OpndHandle* src2) = 0; |
| virtual CG_OpndHandle* xor_(IntegerOp::Types,CG_OpndHandle* src1,CG_OpndHandle* src2) = 0; |
| virtual CG_OpndHandle* not_(IntegerOp::Types,CG_OpndHandle* src) = 0; |
| virtual CG_OpndHandle* shladd(IntegerOp::Types,CG_OpndHandle* value, |
| U_32 shiftamount, |
| CG_OpndHandle* addto) = 0; |
| virtual CG_OpndHandle* shl(IntegerOp::Types,CG_OpndHandle* value,CG_OpndHandle* shiftAmount) = 0; |
| virtual CG_OpndHandle* shr(IntegerOp::Types,CG_OpndHandle* value,CG_OpndHandle* shiftAmount) = 0; |
| virtual CG_OpndHandle* shru(IntegerOp::Types,CG_OpndHandle* value,CG_OpndHandle* shiftAmount) = 0; |
| virtual CG_OpndHandle* select(CompareOp::Types,CG_OpndHandle* src1,CG_OpndHandle* src2, |
| CG_OpndHandle* src3) = 0; |
| // BEGIN PRED DEPRECATED |
| virtual CG_OpndHandle* cmp(CompareOp::Operators,CompareOp::Types, CG_OpndHandle* src1,CG_OpndHandle* src2,int ifNaNResult=0) = 0; |
| virtual CG_OpndHandle* cmp3(CompareOp::Operators,CompareOp::Types,CG_OpndHandle* src1,CG_OpndHandle* src2) { return 0; }; |
| virtual CG_OpndHandle* czero(CompareZeroOp::Types,CG_OpndHandle* src) = 0; |
| virtual CG_OpndHandle* cnzero(CompareZeroOp::Types,CG_OpndHandle* src) = 0; |
| // END PRED DEPRECATED |
| |
| // result is a predicate |
| virtual CG_OpndHandle* pred_czero(CompareZeroOp::Types,CG_OpndHandle* src) = 0; |
| virtual CG_OpndHandle* pred_cnzero(CompareZeroOp::Types,CG_OpndHandle* src) = 0; |
| |
| // BEGIN PRED DEPRECATED |
| virtual void branch(CompareOp::Operators,CompareOp::Types,CG_OpndHandle* src1,CG_OpndHandle* src2) = 0; |
| virtual void bzero(CompareZeroOp::Types,CG_OpndHandle* src) = 0; |
| virtual void bnzero(CompareZeroOp::Types,CG_OpndHandle* src) = 0; |
| // END PRED DEPRECATED |
| |
| virtual void jump() = 0; |
| virtual void tableSwitch(CG_OpndHandle* src, U_32 nTargets) = 0; |
| virtual void throwException(CG_OpndHandle* exceptionObj, bool createStackTrace) = 0; |
| virtual void throwSystemException(CompilationInterface::SystemExceptionId) = 0; |
| virtual void throwLinkingException(Class_Handle encClass, U_32 cp_ndx, U_32 opcode) = 0; |
| |
| /// convert unmanaged pointer to object. Boxing |
| virtual CG_OpndHandle* convUPtrToObject(ObjectType * dstType, CG_OpndHandle* val) = 0; |
| /// convert object or integer to unmanaged pointer. Unboxing |
| virtual CG_OpndHandle* convToUPtr(PtrType * dstType, CG_OpndHandle* op) = 0; |
| |
| virtual CG_OpndHandle* convToInt(ConvertToIntOp::Types, bool isSigned, bool isZeroExtend, |
| ConvertToIntOp::OverflowMod, |
| Type* dstType, CG_OpndHandle* src) = 0; |
| virtual CG_OpndHandle* convToFp(ConvertToFpOp::Types, Type* dstType, CG_OpndHandle* src) = 0; |
| |
| virtual CG_OpndHandle* ldFunAddr(Type* dstType, MethodDesc *desc) = 0; |
| virtual CG_OpndHandle* tau_ldVirtFunAddr(Type* dstType, CG_OpndHandle* vtableAddr, |
| MethodDesc *desc, |
| CG_OpndHandle *tauVtableHasDesc) = 0; |
| virtual CG_OpndHandle* tau_ldVTableAddr(Type *dstType, CG_OpndHandle* base, |
| CG_OpndHandle *tauBaseNonNull) = 0; |
| virtual CG_OpndHandle* getVTableAddr(Type *dstType, ObjectType *base) = 0; |
| virtual CG_OpndHandle* getClassObj(Type *dstType, ObjectType *base) = 0; |
| virtual CG_OpndHandle* tau_ldIntfTableAddr(Type *dstType, CG_OpndHandle* base, |
| NamedType* vtableType) = 0; |
| virtual CG_OpndHandle* call(U_32 numArgs, CG_OpndHandle** args, Type* retType, |
| MethodDesc *desc) = 0; |
| virtual CG_OpndHandle* tau_call(U_32 numArgs, CG_OpndHandle** args, Type* retType, |
| MethodDesc *desc, |
| CG_OpndHandle *tauNullChecked, |
| CG_OpndHandle *tauTypesChecked) = 0; |
| // for callvirt this reference is in args[0] |
| virtual CG_OpndHandle* tau_callvirt(U_32 numArgs, CG_OpndHandle** args, Type* retType, |
| MethodDesc *desc, CG_OpndHandle* tauNullChecked, |
| CG_OpndHandle* tauTypesChecked) = 0; |
| virtual CG_OpndHandle* tau_calli(U_32 numArgs,CG_OpndHandle** args, Type* retType, |
| CG_OpndHandle* methodPtr, |
| CG_OpndHandle* tauNullChecked, |
| CG_OpndHandle* tauTypesChecked) = 0; |
| virtual CG_OpndHandle* callhelper(U_32 numArgs, CG_OpndHandle** args, Type* retType, |
| JitHelperCallOp::Id callId) = 0; |
| virtual CG_OpndHandle* callvmhelper(U_32 numArgs, CG_OpndHandle** args, Type* retType, |
| VM_RT_SUPPORT callId) = 0; |
| |
| virtual CG_OpndHandle* ldc_i4(I_32 val) = 0; |
| virtual CG_OpndHandle* ldc_i8(int64 val) = 0; |
| virtual CG_OpndHandle* ldc_s(float val) = 0; |
| virtual CG_OpndHandle* ldc_d(double val) = 0; |
| virtual CG_OpndHandle* ldnull(bool compressed) = 0; |
| |
| // result of each of these is now a tau |
| // if a negative result is needed, use a tau_point() on the exception handler |
| virtual CG_OpndHandle* tau_checkNull(CG_OpndHandle* base, bool checksThisForInlinedMethod) = 0; |
| virtual CG_OpndHandle* tau_checkBounds(CG_OpndHandle* arrayLen, CG_OpndHandle *index) = 0; |
| virtual CG_OpndHandle* tau_checkLowerBound(CG_OpndHandle* a, CG_OpndHandle *b) = 0; // throw if (a > b), unsigned if pointer |
| virtual CG_OpndHandle* tau_checkUpperBound(CG_OpndHandle* a, CG_OpndHandle *b) = 0; // throw if (a >= b) |
| virtual CG_OpndHandle* tau_checkElemType(CG_OpndHandle* array, CG_OpndHandle *src, |
| CG_OpndHandle* tauNullChecked, |
| CG_OpndHandle* tauIsArray) = 0; |
| virtual CG_OpndHandle* tau_checkZero(CG_OpndHandle* src) = 0; |
| virtual CG_OpndHandle* tau_checkDivOpnds(CG_OpndHandle* src1, CG_OpndHandle *src2) = 0; |
| |
| virtual CG_OpndHandle* tau_checkCast(ObjectType *toType, CG_OpndHandle* obj, |
| CG_OpndHandle* tauCheckedNull) = 0; // for lowered cast |
| |
| // *** begin 32-bit pointers: |
| virtual CG_OpndHandle* uncompressRef(CG_OpndHandle *compref) = 0; |
| virtual CG_OpndHandle* compressRef(CG_OpndHandle *ref) = 0; |
| |
| // yields an Offset |
| virtual CG_OpndHandle* ldFieldOffset(FieldDesc *desc) = 0; |
| // yields an OffsetPlusHeapbase |
| virtual CG_OpndHandle* ldFieldOffsetPlusHeapbase(FieldDesc *desc) = 0; |
| |
| // yields an Offset |
| virtual CG_OpndHandle* ldArrayBaseOffset(Type *elemType) = 0; |
| // yields an Offset |
| virtual CG_OpndHandle* ldArrayLenOffset(Type *elemType) = 0; |
| // yields an OffsetPlusHeapbase |
| virtual CG_OpndHandle* ldArrayBaseOffsetPlusHeapbase(Type *elemType) = 0; |
| // yields an OffsetPlusHeapbase |
| virtual CG_OpndHandle* ldArrayLenOffsetPlusHeapbase(Type *elemType) = 0; |
| |
| // takes an uncompressed reference ref and an Offset fieldOffset, |
| // yields a managed pointer of type fieldRefType: |
| virtual CG_OpndHandle* addOffset(Type *pointerType, CG_OpndHandle* ref, |
| CG_OpndHandle* fieldOffset) = 0; |
| // takes a compressed reference compRef and an OffsetPlusHeapbase, |
| // yields a managed pointer of type fieldRefType: |
| virtual CG_OpndHandle* addOffsetPlusHeapbase(Type *pointerType, |
| CG_OpndHandle* compRef, |
| CG_OpndHandle* fieldOffsetPlusHeapbase) = 0; |
| |
| // *** end 32-bit pointers |
| |
| // COMPRESSED_PTR note: if we are using compressed references, and |
| // field is a reference, then result type should be |
| // Ptr<CompressedRef>; otherwise, it is Ptr<Ref>. |
| virtual CG_OpndHandle* ldFieldAddr(Type* fieldRefType,CG_OpndHandle* base,FieldDesc *desc) = 0; |
| virtual CG_OpndHandle* ldStaticAddr(Type* fieldRefType,FieldDesc *desc) = 0; |
| virtual CG_OpndHandle* ldElemBaseAddr(CG_OpndHandle* array) = 0; |
| virtual CG_OpndHandle* addElemIndex(Type*, CG_OpndHandle *elemBase,CG_OpndHandle* index) = 0; |
| virtual CG_OpndHandle* addElemIndexWithLEA(Type*, CG_OpndHandle *elemBase,CG_OpndHandle* index) = 0; |
| virtual CG_OpndHandle* ldElemAddr(CG_OpndHandle* array,CG_OpndHandle* index) = 0; |
| // COMPRESSED_PTR note: |
| // if we are using compressed references, and ptr is Ptr<CompressedRef>, then |
| // if autoUncompressRef, then result is uncompressed by CG and is of type Ref |
| // otherwise, result is of type CompressedRef and optimizer will handle it |
| // TAU note: |
| // tau_addressInRange = (for array reference) tau_isarray && tau_inbounds |
| // (for field reference) tau_hastype |
| // (for static reference) special AlwaysTrueTau |
| // (for speculative reference) special AlwaysFalseTau |
| // (for array length) chknull tau |
| virtual CG_OpndHandle* tau_ldInd(Type* dstType, CG_OpndHandle* ptr, Type::Tag memType, |
| bool autoUncompressRef, bool speculate, |
| CG_OpndHandle* tauBaseNonNull, |
| CG_OpndHandle* tauaddressInRange) = 0; |
| // COMPRESSED_PTR note: similar here, except field type determines behavior |
| virtual CG_OpndHandle* ldStatic(Type *dstType, FieldDesc *desc, Type::Tag fieldType, |
| bool autoUncompressRef) = 0; |
| virtual CG_OpndHandle* tau_ldField(Type *dstType, CG_OpndHandle* base, Type::Tag fieldType, |
| FieldDesc *desc, bool autoUncompressRef, |
| CG_OpndHandle* tauBaseNonNull, |
| CG_OpndHandle* tauBaseTypeHasField) = 0; |
| virtual CG_OpndHandle* tau_ldElem(Type *dstType, CG_OpndHandle* array, CG_OpndHandle* index, |
| bool autoUncompressRef, |
| CG_OpndHandle* tauBaseNonNull, |
| CG_OpndHandle* tauIdxIsInBounds) = 0; |
| // COMPRESSED_PTR note: var is already uncompressed, so compression doesn't affect these: |
| virtual CG_OpndHandle* ldVarAddr(U_32 varId) = 0; |
| virtual CG_OpndHandle* ldVar(Type* dstType, U_32 varId) = 0; |
| virtual CG_OpndHandle* tau_arrayLen(Type* dstType, ArrayType* arrayType, Type* lenType, |
| CG_OpndHandle* array, |
| CG_OpndHandle* tauArrayNonNull, |
| CG_OpndHandle* tauIsArray) = 0; |
| |
| // COMPRESSED_PTR note: If we are using compressed references, and |
| // ptr is Ptr<Compressed Ref>, then |
| // (1) if autoCompressRef, then src should be Ref and CG will compress |
| // it on store; type is uncompressedRef type |
| // (2) if !autoCompressRef, then src should be CompressedRef; type is |
| // compressedRef type |
| virtual void tau_stInd(CG_OpndHandle* src, CG_OpndHandle* ptr, Type::Tag memType, |
| bool autoCompressRef, |
| CG_OpndHandle* tauBaseNonNull, |
| CG_OpndHandle* tauAddressInRange, |
| CG_OpndHandle* tauElemTypeChecked) = 0; |
| // COMPRESSED_PTR note: similar here |
| virtual void tau_stStatic(CG_OpndHandle* src, FieldDesc *desc, Type::Tag fieldType, |
| bool autoCompressRef, |
| CG_OpndHandle* tauFieldTypeChecked) = 0; |
| virtual void tau_stField(CG_OpndHandle* src, CG_OpndHandle* base, Type::Tag fieldType, |
| FieldDesc *desc, bool autoCompress, |
| CG_OpndHandle* tauBaseNonNull, |
| CG_OpndHandle* tauBaseTypeHasField, |
| CG_OpndHandle* tauFieldTypeChecked) = 0; |
| virtual void tau_stElem(CG_OpndHandle* src, CG_OpndHandle* array, |
| CG_OpndHandle* index, |
| bool autoCompress, |
| CG_OpndHandle* tauBaseNonNull, |
| CG_OpndHandle* tauAddressInRange, |
| CG_OpndHandle* tauElemTypeChecked) = 0; |
| virtual void tau_stRef(CG_OpndHandle* src, CG_OpndHandle* ptr, CG_OpndHandle* base, Type::Tag memType, |
| bool autoCompressRef, |
| CG_OpndHandle* tauBaseNonNull, |
| CG_OpndHandle* tauAddressInRange, |
| CG_OpndHandle* tauElemTypeChecked) = 0; |
| // COMPRESSED_PTR note: var is already uncompressed, so compression doesn't affect it |
| virtual void stVar(CG_OpndHandle* src, U_32 varId) = 0; |
| |
| virtual CG_OpndHandle* newObj(ObjectType* objType) = 0; |
| virtual CG_OpndHandle* newArray(ArrayType* arrayType, CG_OpndHandle* numElems) = 0; |
| virtual CG_OpndHandle* newMultiArray(ArrayType* arrayType, U_32 numDims, CG_OpndHandle** dims) = 0; |
| virtual CG_OpndHandle* ldRef(Type* type,MethodDesc* enclosingMethod,U_32 stringToken, bool autouncompress) = 0; |
| virtual void incCounter(Type *counterType,U_32 counter) = 0; |
| |
| virtual void ret() = 0; |
| virtual void ret(CG_OpndHandle* returnValue) = 0; |
| virtual CG_OpndHandle* defArg(U_32 position,Type *type) = 0; |
| |
| virtual void tau_monitorEnter(CG_OpndHandle* obj, |
| CG_OpndHandle* tauIsNonNull) = 0; |
| virtual void tau_monitorExit(CG_OpndHandle* obj, |
| CG_OpndHandle* tauIsNonNull) = 0; |
| virtual CG_OpndHandle* ldLockAddr(CG_OpndHandle* obj) = 0; |
| virtual CG_OpndHandle* tau_balancedMonitorEnter(CG_OpndHandle* obj, CG_OpndHandle* lockAddr, |
| CG_OpndHandle* tauIsNonNull) = 0; |
| // null-check dependence is threaded through oldLock from tau_balancedMonitorEnter |
| virtual void balancedMonitorExit(CG_OpndHandle* obj, CG_OpndHandle* lockAddr, |
| CG_OpndHandle* oldLoc) = 0; |
| virtual CG_OpndHandle* tau_optimisticBalancedMonitorEnter(CG_OpndHandle* obj, |
| CG_OpndHandle* lockAddr, |
| CG_OpndHandle* tauIsNonNull) = 0; |
| // null-check dependence is threaded through oldLock from tau_optimisticBalancedMonitorEnter |
| virtual void optimisticBalancedMonitorExit(CG_OpndHandle* obj, |
| CG_OpndHandle* lockAddr, |
| CG_OpndHandle* oldLoc) = 0; |
| // null-check dependence is threaded through oldLock from tau_optimisticBalancedMonitorEnter |
| virtual void incRecursionCount(CG_OpndHandle* obj, CG_OpndHandle* oldLock) = 0; |
| virtual void monitorEnterFence(CG_OpndHandle* obj) = 0; |
| virtual void monitorExitFence(CG_OpndHandle* obj) = 0; |
| virtual void typeMonitorEnter(NamedType *type) = 0; |
| virtual void typeMonitorExit(NamedType *type) = 0; |
| |
| virtual CG_OpndHandle* tau_staticCast(ObjectType *toType, CG_OpndHandle* obj, |
| CG_OpndHandle* tauIsType) = 0; |
| virtual CG_OpndHandle* tau_cast(ObjectType *toType, CG_OpndHandle* obj, |
| CG_OpndHandle* tauCheckedNull) = 0; |
| virtual CG_OpndHandle* tau_asType(ObjectType* type, CG_OpndHandle* obj, |
| CG_OpndHandle* tauCheckedNull) = 0; |
| virtual CG_OpndHandle* tau_instanceOf(ObjectType *type, CG_OpndHandle* obj, |
| CG_OpndHandle* tauCheckedNull) = 0; |
| virtual void initType(Type* type) = 0; |
| virtual CG_OpndHandle* box(ObjectType * dstType, CG_OpndHandle* val) = 0; |
| virtual CG_OpndHandle* unbox(Type * dstType, CG_OpndHandle* obj) = 0; |
| virtual CG_OpndHandle* ldValueObj(Type* objType, CG_OpndHandle *srcAddr) = 0; |
| virtual void stValueObj(CG_OpndHandle *dstAddr, CG_OpndHandle *src) = 0; |
| virtual void initValueObj(Type* objType, CG_OpndHandle *objAddr) = 0; |
| virtual void copyValueObj(Type* objType, CG_OpndHandle *dstAddr, CG_OpndHandle *srcAddr) = 0; |
| virtual CG_OpndHandle* copy(CG_OpndHandle *src) = 0; |
| virtual CG_OpndHandle* catchException(Type * exceptionType) = 0; |
| virtual void prefetch(CG_OpndHandle *addr) = 0; |
| |
| virtual void pseudoInst() = 0; |
| |
| virtual void methodEntry(MethodDesc* mDesc) = 0; |
| virtual void methodEnd(MethodDesc* mDesc, CG_OpndHandle* retVallue = NULL) = 0; |
| |
| // Set the current persistent instruction id associated with any subsequently generated instructions. |
| virtual void setCurrentPersistentId(PersistentInstructionId persistentId) = 0; |
| |
| // Clear the current persistent instruction id. |
| // Any subsequently generated instructions have no associated ID. |
| virtual void clearCurrentPersistentId() = 0; |
| // Set current HIR instruction bytecode offset |
| virtual void setCurrentHIRInstBCOffset(uint16 val) = 0; |
| virtual uint16 getCurrentHIRInstBCOffset() const = 0; |
| private: |
| }; |
| |
| // |
| // interface for generating code for a variable |
| // |
| class VarCodeSelector { |
| public: |
| virtual ~VarCodeSelector() {} |
| class Callback { |
| public: |
| virtual ~Callback() {} |
| virtual U_32 defVar(Type* varType,bool isAddressTaken,bool isPinned) = 0; |
| virtual void setManagedPointerBase(U_32 managedPtrVarNum, U_32 baseVarNum) = 0; |
| }; |
| virtual void genCode(Callback&) = 0; |
| }; |
| |
| // |
| // interface for generating code for a basic block |
| // |
| class BlockCodeSelector { |
| public: |
| virtual ~BlockCodeSelector() {} |
| virtual void genCode(InstructionCallback&) = 0; |
| }; |
| |
| // |
| // interface for generating code for a control-flow graph |
| // |
| class CFGCodeSelector { |
| public: |
| virtual ~CFGCodeSelector() {} |
| class Callback { |
| public: |
| enum BlockKind {Prolog, InnerBlock, Epilog}; |
| virtual ~Callback() {} |
| virtual U_32 genDispatchNode(U_32 numInEdges,U_32 numOutEdges, const StlVector<MethodDesc*>& inlineEndMarkers, double cnt) = 0; |
| virtual U_32 genBlock(U_32 numInEdges,U_32 numOutEdges, BlockKind blockKind, |
| BlockCodeSelector&, double cnt) = 0; |
| virtual U_32 genUnwindNode(U_32 numInEdges, U_32 numOutEdges,double cnt) = 0; |
| virtual U_32 genExitNode(U_32 numInEdges, double cnt) = 0; |
| virtual void genUnconditionalEdge(U_32 tailNodeId,U_32 headNodeId,double prob) = 0; |
| virtual void genTrueEdge(U_32 tailNodeId,U_32 headNodeId,double prob) = 0; |
| virtual void genFalseEdge(U_32 tailNodeId,U_32 headNodeId, double prob) = 0; |
| virtual void genSwitchEdges(U_32 tailNodeId, U_32 numTargets, |
| U_32 *targets, double *probs, U_32 defaultTarget) = 0; |
| virtual void genExceptionEdge(U_32 tailNodeId, U_32 headNodeId, double prob) = 0; |
| virtual void genCatchEdge(U_32 tailNodeId,U_32 headNodeId, |
| U_32 priority,Type* exceptionType, double prob) = 0; |
| |
| // Set the persistent block ID for a given block. |
| virtual void setPersistentId(U_32 nodeId, U_32 persistentId) = 0; |
| }; |
| virtual void genCode(Callback&) = 0; |
| }; |
| // |
| // interface for generating code for a method |
| // |
| class MethodCodeSelector { |
| public: |
| MethodCodeSelector() {} |
| virtual ~MethodCodeSelector() {} |
| class Callback { |
| public: |
| virtual void genVars(U_32 numLocals,VarCodeSelector&) = 0; |
| virtual void setMethodDesc(MethodDesc * desc) = 0; |
| virtual void genCFG(U_32 numNodes,CFGCodeSelector&,bool useProfile) = 0; |
| virtual ~Callback() {} |
| }; |
| virtual void selectCode(Callback&) = 0; |
| }; |
| |
| class SessionAction; |
| class CodeGenerator { |
| public: |
| virtual ~CodeGenerator() {} |
| virtual void genCode(SessionAction* sa, MethodCodeSelector&) = 0; |
| }; |
| |
| class CodeGeneratorFactory { |
| public: |
| virtual ~CodeGeneratorFactory() {} |
| virtual CodeGenerator* getCodeGenerator(MemoryManager &mm, |
| CompilationInterface& compInterface) = 0; |
| }; |
| |
| } |
| #endif // _CODEGENINTFC_H_ |
