| /* |
| * 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, Nikolay A. Sidelnikov |
| */ |
| |
| #ifndef _IA32_STACK_INFO_H_ |
| #define _IA32_STACK_INFO_H_ |
| |
| #include "CodeGenIntfc.h" |
| #include "MemoryManager.h" |
| #include "VMInterface.h" |
| #include "Type.h" |
| #include "Ia32Constraint.h" |
| #include "Ia32IRManager.h" |
| namespace Jitrino |
| { |
| namespace Ia32 { |
| |
| /** |
| * struct StackDepthInfo performs access to information about call |
| * instruction. It contains callee save registers masks |
| * and stack depth for this instruction |
| */ |
| |
| struct StackDepthInfo { |
| U_32 calleeSaveRegs; |
| U_32 stackDepth; |
| U_32 callSize; |
| |
| StackDepthInfo(U_32 sd=0) : calleeSaveRegs(0), stackDepth(sd), callSize(0) {} |
| StackDepthInfo(U_32 e, U_32 sd=0, U_32 cz=0) : calleeSaveRegs(e), stackDepth(sd), callSize(cz) {} |
| }; |
| |
| struct DepthEntry { |
| POINTER_SIZE_INT eip; |
| StackDepthInfo info; |
| DepthEntry * next; |
| |
| DepthEntry(POINTER_SIZE_INT ip, StackDepthInfo i, DepthEntry * n) : eip(ip), info(i), next(n) {} |
| }; |
| |
| /** |
| * map DepthMap contains StackDepthInfos indexed by EIP of corresponded call |
| * instruction |
| */ |
| typedef StlMap<POINTER_SIZE_INT, StackDepthInfo> DepthMap; |
| |
| //======================================================================================== |
| // class StackInfo |
| //======================================================================================== |
| /** |
| * class StackInfo performs stack unwinding and fixing handler context. |
| * It can be saved and restored from memory block |
| * |
| * This class ensures that |
| * |
| * 1) All fields of a JitFrameContext object contain appropriate information |
| * |
| * 2) All useful information from StackInfo object saves and restores |
| * properly |
| * |
| * The principle of the filling fields of a JitFrameContext object is a |
| * hard-coded enumeration of registers. |
| * |
| * The implementation of this class is located in file Ia32StackInfo.cpp |
| * |
| */ |
| |
| class StackInfo { |
| public: |
| StackInfo(MemoryManager& mm) |
| : byteSize(0), hashTableSize(0), frameSize(0), |
| itraceMethodExitString(0), |
| eipOffset(0), |
| icalleeMask(0),icalleeOffset(0), |
| fcallee(0),foffset(0), |
| acallee(0),aoffset(0), |
| localOffset(0), |
| calleeSaveRegsMask(0), |
| stackDepth(-1), |
| offsetOfThis(0), |
| soeCheckAreaOffset(0) |
| { stackDepthInfo = new(mm) DepthMap(mm);} |
| |
| StackInfo() |
| : byteSize(0), hashTableSize(0), frameSize(0), |
| itraceMethodExitString(0), |
| eipOffset(0), |
| icalleeMask(0),icalleeOffset(0), |
| fcallee(0),foffset(0), |
| acallee(0),aoffset(0), |
| localOffset(0), |
| stackDepthInfo(NULL), |
| calleeSaveRegsMask(0), |
| stackDepth(-1),offsetOfThis(0),soeCheckAreaOffset(0) {} |
| |
| /** writes StackInfo data into memory |
| */ |
| void write(U_8* output); |
| |
| /** reads StackInfo data from MethodDesc |
| */ |
| void read(MethodDesc* pMethodDesc, POINTER_SIZE_INT eip, bool isFirst); |
| |
| /** Loads JitFrameContext with the next stack frame according to StackInfo |
| */ |
| void unwind(MethodDesc* pMethodDesc, JitFrameContext* context, bool isFirst) const; |
| |
| /** Changes ESP to point to the start of stack frame |
| */ |
| void fixHandlerContext(JitFrameContext* context); |
| |
| /** stores into StackInfo information about calls instructions such as |
| * eip, stack depth and callee-save registers masks |
| * The algorithm takes one-pass over CFG. |
| */ |
| void registerInsts(IRManager& irm); |
| |
| /** sets method exit string which was created during itrace pass |
| and is alive during runtime |
| */ |
| void setMethodExitString(IRManager& irm); |
| |
| /** returns register offset for previos stack frame. |
| MUST be called before unwind() |
| */ |
| POINTER_SIZE_INT * getRegOffset(const JitFrameContext* context, RegName reg) const; |
| |
| /** returns stack depth |
| */ |
| POINTER_SIZE_INT getStackDepth() const { |
| assert(stackDepth>=0); |
| return stackDepth; |
| } |
| |
| U_32 getFrameSize() const {return frameSize;} |
| |
| I_32 getRetEIPOffset() const {return eipOffset;} |
| |
| U_32 getIntCalleeMask() const {return icalleeMask;} |
| |
| I_32 getIntCalleeOffset() const {return icalleeOffset;} |
| |
| U_32 getFPCalleeMask() const {return fcallee;} |
| |
| I_32 getFPCalleeOffset() const {return foffset;} |
| |
| U_32 getApplCalleeMask() const {return acallee;} |
| |
| I_32 getApplCalleeOffset() const {return aoffset;} |
| |
| I_32 getLocalOffset() const {return localOffset;} |
| |
| U_32 getOffsetOfThis() const {return offsetOfThis;} |
| |
| U_32 getSOECheckAreaOffset() const {return soeCheckAreaOffset;} |
| |
| void setSOECheckAreaOffset(U_32 v) {soeCheckAreaOffset = v;} |
| |
| /** returns byte size of StackInfo data |
| */ |
| POINTER_SIZE_INT getByteSize() const; |
| |
| static POINTER_SIZE_INT getByteSize(MethodDesc* md); |
| |
| /** read byte size from info block |
| * |
| */ |
| POINTER_SIZE_INT readByteSize(const U_8* input) const; |
| |
| private: |
| POINTER_SIZE_INT byteSize; |
| U_32 hashTableSize; |
| I_32 frameSize; |
| |
| const char * itraceMethodExitString; |
| |
| I_32 eipOffset; |
| |
| U_32 icalleeMask; |
| I_32 icalleeOffset; |
| |
| U_32 fcallee; |
| I_32 foffset; |
| |
| U_32 acallee; |
| I_32 aoffset; |
| |
| I_32 localOffset; |
| |
| DepthMap * stackDepthInfo; |
| |
| U_32 calleeSaveRegsMask; |
| I_32 stackDepth; |
| U_32 offsetOfThis; |
| U_32 soeCheckAreaOffset; |
| |
| friend class StackLayouter; |
| }; |
| |
| }}//namespace |
| #endif /* _IA32_STACK_INFO_H_ */ |