| /* |
| * 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, Mikhail Y. Fursov |
| */ |
| |
| #include "Ia32GCMap.h" |
| #include "Ia32Inst.h" |
| #include "Ia32RuntimeInterface.h" |
| #include "Ia32StackInfo.h" |
| #include "Ia32GCSafePoints.h" |
| #include "XTimer.h" |
| #include "Ia32Printer.h" |
| |
| //#define ENABLE_GC_RT_CHECKS |
| |
| namespace Jitrino |
| { |
| namespace Ia32 { |
| |
| static ActionFactory<GCMapCreator> _gcmap("gcmap"); |
| static ActionFactory<InfoBlockWriter> _info("info"); |
| |
| //_______________________________________________________________________ |
| // GCMap |
| //_______________________________________________________________________ |
| |
| GCMap::GCMap(MemoryManager& memM) : mm(memM), gcSafePoints(mm), offsetsInfo(NULL) { |
| } |
| |
| void GCMap::registerInsts(IRManager& irm) { |
| assert(offsetsInfo == NULL); |
| assert(gcSafePoints.empty()); |
| offsetsInfo = new (mm) GCSafePointsInfo(mm, irm, GCSafePointsInfo::MODE_2_CALC_OFFSETS); |
| const Nodes& nodes = irm.getFlowGraph()->getNodes(); |
| for (Nodes::const_iterator it = nodes.begin(), end = nodes.end(); it!=end; ++it) { |
| Node* node = *it; |
| if (node->isBlockNode()) { |
| processBasicBlock(irm, node); |
| } |
| } |
| } |
| |
| void GCMap::processBasicBlock(IRManager& irm, const Node* block) { |
| assert(block->isBlockNode()); |
| POINTER_SIZE_INT safePointsInBlock = GCSafePointsInfo::getNumSafePointsInBlock(block); |
| if (safePointsInBlock == 0) { |
| return; |
| } |
| gcSafePoints.reserve(gcSafePoints.size() + safePointsInBlock); |
| BitSet ls(mm, irm.getOpndCount()); |
| irm.getLiveAtExit(block, ls); |
| for (Inst* inst = (Inst*)block->getLastInst(); inst!=NULL; inst = inst->getPrevInst()) { |
| if (IRManager::isGCSafePoint(inst)) { |
| registerGCSafePoint(irm, ls, inst); |
| #ifndef GCMAP_TRACK_IDS //for debug mode we collect all hardware exception points too |
| if (--safePointsInBlock == 0) { |
| break; |
| } |
| #else |
| } else if (isHardwareExceptionPoint(inst)){ //check if hardware exception point |
| registerHardwareExceptionPoint(inst); //save empty safe-point -> used for debugging and testing |
| #endif |
| } |
| irm.updateLiveness(inst, ls); |
| } |
| } |
| |
| |
| #ifdef _DEBUG |
| |
| static bool isUnmanagedFieldPtr(Opnd* opnd) { |
| if (opnd->getMemOpndKind()!=MemOpndKind_Heap) { |
| Log::out()<<"GCMap::isUnmanagedFieldPtr: not a heap opnd"<<std::endl; |
| return false; |
| } |
| Opnd* fieldOpnd = opnd->getMemOpndSubOpnd(MemOpndSubOpndKind_Displacement); |
| if (fieldOpnd==NULL) { |
| fieldOpnd = opnd->getMemOpndSubOpnd(MemOpndSubOpndKind_Base); |
| if (fieldOpnd == NULL) { |
| Log::out()<<"GCMap::isUnmanagedFieldPtr: memopnd base/displacement not found"<<std::endl; |
| return false; |
| } |
| } |
| Opnd::RuntimeInfo* info = fieldOpnd->getRuntimeInfo(); |
| if (info==NULL) { |
| Log::out()<<"GCMap::isUnmanagedFieldPtr: runtime info not found"<<std::endl; |
| return false; |
| } |
| FieldDesc* field = NULL; |
| if (info->getKind() != Opnd::RuntimeInfo::Kind_FieldOffset && info->getKind()!=Opnd::RuntimeInfo::Kind_StaticFieldAddress) { |
| Log::out()<<"GCMap::isUnmanagedFieldPtr: not a field kind"<<std::endl; |
| return false; |
| } |
| field = (FieldDesc*)info->getValue(0); |
| return field->isMagic(); |
| } |
| |
| static void checkManaged2UnmanagedConv(IRManager& irm, Opnd* opnd) { |
| const Nodes& nodes = irm.getFlowGraph()->getNodes(); |
| for (Nodes::const_iterator it = nodes.begin(), end = nodes.end(); it!=end; ++it) { |
| Node* node = *it; |
| if (node->isBlockNode()) { |
| for (Inst* inst = (Inst*)node->getLastInst(); inst!=NULL; inst = inst->getPrevInst()) { |
| if (inst->getMnemonic() != Mnemonic_MOV) { |
| continue; |
| } |
| Opnd* op0 = inst->getOpnd(0); |
| Opnd* op1 = inst->getOpnd(1); |
| if (op0!=opnd && op1!=opnd) { |
| continue; |
| } |
| if (GCSafePointsInfo::isManaged(op0)==GCSafePointsInfo::isManaged(op1)) { |
| continue; |
| } |
| Opnd* managedOpnd = GCSafePointsInfo::isManaged(op0)?op0:op1; |
| bool res = isUnmanagedFieldPtr(managedOpnd); |
| if (!res) { |
| Log::out()<<"GCMap::checkManaged2UnmanagedConv failure, managedOpnd="<<managedOpnd->getFirstId()<<std::endl; |
| #ifdef _IA32_ |
| // FIXME em64t |
| // TODO: Fails with genIdentityHashCode=true |
| // assert(0); |
| #endif |
| } |
| } |
| } |
| } |
| } |
| #endif |
| |
| void GCMap::registerGCSafePoint(IRManager& irm, const BitSet& ls, Inst* inst) { |
| POINTER_SIZE_INT eip = (POINTER_SIZE_INT)inst->getCodeStartAddr()+inst->getCodeSize(); |
| GCSafePoint* gcSafePoint = new (mm) GCSafePoint(mm, eip); |
| GCSafePointPairs& pairs = offsetsInfo->getGCSafePointPairs(inst); |
| const StlSet<Opnd*>& staticFieldsMptrs = offsetsInfo->getStaticFieldMptrs(); |
| |
| StlVector<int>* offsets = NULL; |
| StlVector<Opnd*>* basesAndMptrs = NULL; |
| bool loggingGCInst = Log::isEnabled(); |
| if (loggingGCInst) { |
| offsets = new (mm) StlVector<int>(mm); |
| basesAndMptrs = new (mm) StlVector<Opnd*>(mm); |
| } |
| #ifdef GCMAP_TRACK_IDS |
| gcSafePoint->instId = inst->getId(); |
| #endif |
| BitSet::IterB liveOpnds(ls); |
| assert(inst->hasKind(Inst::Kind_CallInst)); |
| |
| Opnd * callRes = inst->getOpndCount(Inst::OpndRole_AllDefs)>0 ? inst->getOpnd(0) : NULL; |
| for (int i = liveOpnds.getNext(); i != -1; i = liveOpnds.getNext()) { |
| Opnd* opnd = irm.getOpnd(i); |
| #ifdef _DEBUG |
| if (opnd->getType()->isUnmanagedPtr() && opnd != callRes ) { |
| checkManaged2UnmanagedConv(irm, opnd); |
| } |
| #endif |
| |
| if (callRes == opnd) { |
| continue; |
| } |
| Type* opndType = opnd->getType(); |
| if (!opndType->isManagedPtr() && !opndType->isObject()) { |
| continue; |
| } |
| if (staticFieldsMptrs.find(opnd) != staticFieldsMptrs.end()) { |
| continue; |
| } |
| if (opnd->getRefCount() == 0) { |
| continue; |
| } |
| //ok register this opnd |
| MPtrPair* pair = GCSafePointsInfo::findPairByMPtrOpnd(pairs, opnd); |
| I_32 offset = pair == NULL ? 0 : pair->getOffset(); |
| bool isObject = offset == 0; |
| #ifdef _EM64T_ |
| bool isCompressed = (opnd->getType()->tag <= Type::CompressedVTablePtr && opnd->getType()->tag >= Type::CompressedSystemObject); |
| #endif |
| GCSafePointOpnd* gcOpnd; |
| RegName reg = opnd->getRegName(); |
| if (reg != RegName_Null) { |
| #ifdef _EM64T_ |
| gcOpnd = new (mm) GCSafePointOpnd(isObject, TRUE, U_32(reg), offset, isCompressed); |
| #else |
| gcOpnd = new (mm) GCSafePointOpnd(isObject, TRUE, U_32(reg), offset); |
| #endif |
| } else if (opnd->getMemOpndKind() == MemOpndKind_StackAutoLayout) { |
| const Opnd* displOpnd = opnd->getMemOpndSubOpnd(MemOpndSubOpndKind_Displacement); |
| assert(displOpnd!=NULL); |
| assert(fit32(displOpnd->getImmValue()) && fit32(inst->getStackDepth())); |
| int offset_from_esp0 = (int)displOpnd->getImmValue(); //opnd saving offset from the esp on method call |
| int inst_offset_from_esp0 = (int)inst->getStackDepth(); |
| int ptrToAddrOffset = inst_offset_from_esp0 + offset_from_esp0; //opnd saving offset from the esp on inst |
| gcOpnd = new (mm) GCSafePointOpnd(isObject, false, ptrToAddrOffset, offset); |
| } else { |
| assert(opnd->getMemOpndKind() == MemOpndKind_Heap); |
| continue; |
| } |
| #ifdef GCMAP_TRACK_IDS |
| gcOpnd->firstId = opnd->getFirstId(); |
| #endif |
| gcSafePoint->gcOpnds.push_back(gcOpnd); |
| |
| if (loggingGCInst) { |
| basesAndMptrs->push_back(opnd); |
| offsets->push_back(gcOpnd->getMPtrOffset()); |
| } |
| } |
| gcSafePoints.push_back(gcSafePoint); |
| if (loggingGCInst && !offsets->empty()) { |
| GCInfoPseudoInst* gcInst = irm.newGCInfoPseudoInst(*basesAndMptrs); |
| gcInst->desc = "gcmap"; |
| gcInst->offsets.resize(offsets->size()); |
| std::copy(offsets->begin(), offsets->end(), gcInst->offsets.begin()); |
| gcInst->insertAfter(inst); |
| } |
| } |
| bool GCMap::isHardwareExceptionPoint(const Inst* inst) const { |
| Inst::Opnds opnds(inst, Inst::OpndRole_Explicit|Inst::OpndRole_UseDef); |
| for (Inst::Opnds::iterator it = opnds.begin(), end = opnds.end(); it!=end; it = opnds.next(it)) { |
| Opnd* opnd = inst->getOpnd(it); |
| if (opnd->isPlacedIn(OpndKind_Mem) && opnd->getMemOpndKind() == MemOpndKind_Heap) { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| void GCMap::registerHardwareExceptionPoint(Inst* inst) { |
| POINTER_SIZE_INT eip = (POINTER_SIZE_INT)inst->getCodeStartAddr(); |
| GCSafePoint* gcSafePoint = new (mm) GCSafePoint(mm, eip); |
| #ifdef GCMAP_TRACK_IDS |
| gcSafePoint->instId = inst->getId(); |
| gcSafePoint->hardwareExceptionPoint = true; |
| #endif |
| gcSafePoints.push_back(gcSafePoint); |
| } |
| |
| |
| POINTER_SIZE_INT GCMap::getByteSize() const { |
| POINTER_SIZE_INT slotSize = sizeof(POINTER_SIZE_INT); |
| POINTER_SIZE_INT size = slotSize/*byte number */ + slotSize/*number of safepoints*/ |
| + (POINTER_SIZE_INT)slotSize*gcSafePoints.size()/*space to save safepoints sizes*/; |
| for (int i=0, n = (int)gcSafePoints.size(); i<n;i++) { |
| GCSafePoint* gcSite = gcSafePoints[i]; |
| size+= slotSize*gcSite->getUint32Size(); |
| } |
| return size; |
| } |
| |
| POINTER_SIZE_INT GCMap::readByteSize(const U_8* input) { |
| POINTER_SIZE_INT* data = (POINTER_SIZE_INT*)input; |
| POINTER_SIZE_INT gcMapSizeInBytes; |
| |
| gcMapSizeInBytes = data[0]; |
| return gcMapSizeInBytes; |
| } |
| |
| |
| #ifdef GCMAP_TRACK_IDS |
| struct hwecompare { |
| bool operator() (const GCSafePoint* p1, const GCSafePoint* p2) const { |
| if (p1->isHardwareExceptionPoint() == p2->isHardwareExceptionPoint()) { |
| return p1 < p2; |
| } |
| return !p1->isHardwareExceptionPoint(); |
| } |
| }; |
| #endif |
| |
| void GCMap::write(U_8* output) { |
| POINTER_SIZE_INT* data = (POINTER_SIZE_INT*)output; |
| data[0] = getByteSize(); |
| data[1] = (POINTER_SIZE_INT)gcSafePoints.size(); |
| POINTER_SIZE_INT offs = 2; |
| |
| #ifdef GCMAP_TRACK_IDS |
| // make sure that hwe-points are after normal gcpoints |
| // this is depends on findGCSafePointStart algorithm -> choose normal gcpoint |
| // if both hwe and normal points are registered for the same IP |
| std::sort(gcSafePoints.begin(), gcSafePoints.end(), hwecompare()); |
| #endif |
| |
| for (int i=0, n = (int)gcSafePoints.size(); i<n;i++) { |
| GCSafePoint* gcSite = gcSafePoints[i]; |
| POINTER_SIZE_INT siteUint32Size = gcSite->getUint32Size(); |
| data[offs++] = siteUint32Size; |
| gcSite->write(data+offs); |
| offs+=siteUint32Size; |
| } |
| assert(sizeof(POINTER_SIZE_INT)*offs == getByteSize()); |
| } |
| |
| |
| const POINTER_SIZE_INT* GCMap::findGCSafePointStart(const POINTER_SIZE_INT* data, POINTER_SIZE_INT ip) { |
| POINTER_SIZE_INT nGCSafePoints = data[1]; |
| POINTER_SIZE_INT offs = 2; |
| for (POINTER_SIZE_INT i = 0; i < nGCSafePoints; i++) { |
| POINTER_SIZE_INT siteIP = GCSafePoint::getIP(data + offs + 1); |
| if (siteIP == ip) { |
| return data+offs+1; |
| } |
| POINTER_SIZE_INT siteSize = data[offs]; |
| offs+=1+siteSize; |
| } |
| return NULL; |
| } |
| |
| |
| //_______________________________________________________________________ |
| // GCSafePoint |
| //_______________________________________________________________________ |
| |
| GCSafePoint::GCSafePoint(MemoryManager& mm, const POINTER_SIZE_INT* image) : gcOpnds(mm) , ip(image[0]) { |
| POINTER_SIZE_INT nOpnds = image[1]; |
| gcOpnds.reserve(nOpnds); |
| POINTER_SIZE_INT offs = 2; |
| for (U_32 i = 0; i< nOpnds; i++, offs+=3) { |
| GCSafePointOpnd* gcOpnd= new (mm) GCSafePointOpnd(U_32(image[offs]), int(image[offs+1]), I_32(image[offs+2])); |
| #ifdef GCMAP_TRACK_IDS |
| gcOpnd->firstId = U_32(image[offs+3]); |
| offs++; |
| #endif |
| gcOpnds.push_back(gcOpnd); |
| } |
| #ifdef GCMAP_TRACK_IDS |
| instId = image[offs]; |
| hardwareExceptionPoint = (bool)image[offs+1]; |
| #endif |
| } |
| |
| POINTER_SIZE_INT GCSafePoint::getUint32Size() const { |
| POINTER_SIZE_INT size = 1/*ip*/+1/*nOpnds*/+GCSafePointOpnd::IMAGE_SIZE_UINT32 * (POINTER_SIZE_INT)gcOpnds.size()/*opnds images*/; |
| #ifdef GCMAP_TRACK_IDS |
| size++; //instId |
| size++; //hardwareExceptionPoint |
| #endif |
| return size; |
| } |
| |
| void GCSafePoint::write(POINTER_SIZE_INT* data) const { |
| POINTER_SIZE_INT offs=0; |
| data[offs++] = ip; |
| data[offs++] = (POINTER_SIZE_INT)gcOpnds.size(); |
| for (U_32 i = 0, n = (U_32)gcOpnds.size(); i<n; i++, offs+=3) { |
| GCSafePointOpnd* gcOpnd = gcOpnds[i]; |
| data[offs] = gcOpnd->flags; |
| data[offs+1] = gcOpnd->val; |
| data[offs+2] = gcOpnd->mptrOffset; |
| #ifdef GCMAP_TRACK_IDS |
| data[offs+3] = gcOpnd->firstId; |
| offs++; |
| #endif |
| } |
| #ifdef GCMAP_TRACK_IDS |
| data[offs++] = instId; |
| data[offs++] = (POINTER_SIZE_INT)hardwareExceptionPoint; |
| #endif |
| assert(offs == getUint32Size()); |
| } |
| |
| POINTER_SIZE_INT GCSafePoint::getIP(const POINTER_SIZE_INT* image) { |
| return image[0]; |
| } |
| |
| static inline void m_assert(bool cond) { |
| #ifdef GCMAP_TRACK_IDS |
| assert(cond); |
| #else |
| #ifdef _WIN32 // any windows |
| if (!cond) { |
| DebugBreak(); |
| } |
| #endif |
| #endif |
| } |
| |
| void GCMap::checkObject(TypeManager& tm, const void* p) { |
| if (p==NULL) return; |
| m_assert (!(p<(const void*)0x10000)); //(INVALID PTR) |
| m_assert((((POINTER_SIZE_INT)p)&0x3)==0); // check for valid alignment |
| POINTER_SIZE_INT vtableOffset = VMInterface::getVTableOffset(); |
| void * allocationHandle=*(void**)(((U_8*)p)+vtableOffset); |
| m_assert (!(allocationHandle<(void*)0x10000 || (((POINTER_SIZE_INT)allocationHandle)&0x3)!=0)); //INVALID VTABLE PTR |
| ObjectType * type=tm.getObjectTypeFromAllocationHandle(allocationHandle); |
| m_assert(type!=NULL); // UNRECOGNIZED VTABLE PTR; |
| } |
| |
| void GCSafePoint::enumerate(GCInterface* gcInterface, const JitFrameContext* context, const StackInfo& stackInfo) const { |
| #ifdef ENABLE_GC_RT_CHECKS |
| MemoryManager mm("tmp"); |
| TypeManager tm(mm); |
| #endif |
| //The algorithm of enumeration is |
| //1. Derive all offsets for MPTRs with offsets unknown during compile time. |
| //2. Report to VM |
| //We need this 2 steps behavior because some GCs move objects during enumeration. |
| //In this case it's impossible to derive valid base for mptr with unknown offset. |
| |
| //1. Derive all offsets. Use GCSafePointOpnd.mptrOffset to store the result. |
| for (U_32 i=0, n = (U_32)gcOpnds.size(); i<n; i++) { |
| GCSafePointOpnd* gcOpnd = gcOpnds[i]; |
| POINTER_SIZE_INT valPtrAddr = getOpndSaveAddr(context, stackInfo, gcOpnd); |
| if (gcOpnd->isObject() || gcOpnd->getMPtrOffset()!=MPTR_OFFSET_UNKNOWN) { |
| continue; |
| } |
| |
| POINTER_SIZE_INT mptrAddr = *((POINTER_SIZE_INT*)valPtrAddr); |
| //we looking for a base that a) located before mptr in memory b) nearest to mptr |
| GCSafePointOpnd* baseOpnd = NULL; |
| #ifdef ENABLE_GC_RT_CHECKS |
| POINTER_SIZE_INT basePtrAddr = 0; |
| #endif |
| POINTER_SIZE_INT baseAddr = 0; |
| for (U_32 j=0; j<n; j++) { |
| GCSafePointOpnd* tmpOpnd = gcOpnds[j]; |
| if (tmpOpnd->isObject()) { |
| POINTER_SIZE_INT tmpPtrAddr = getOpndSaveAddr(context, stackInfo, tmpOpnd); |
| POINTER_SIZE_INT tmpBaseAddr = *((POINTER_SIZE_INT*)tmpPtrAddr); |
| if (tmpBaseAddr <= mptrAddr) { |
| if (baseOpnd == NULL || tmpBaseAddr > baseAddr) { |
| baseOpnd = tmpOpnd; |
| #ifdef ENABLE_GC_RT_CHECKS |
| basePtrAddr = tmpPtrAddr; |
| #endif |
| baseAddr = tmpBaseAddr; |
| } |
| } |
| } |
| } |
| assert(baseOpnd!=NULL); |
| #ifdef ENABLE_GC_RT_CHECKS |
| GCMap::checkObject(tm, *(void**)basePtrAddr); |
| #endif |
| int offset = (int)(mptrAddr-baseAddr); |
| assert(offset>=0); |
| gcOpnd->getMPtrOffset(offset); |
| } |
| |
| //2. Report the results |
| for (U_32 i=0, n = (U_32)gcOpnds.size(); i<n; i++) { |
| GCSafePointOpnd* gcOpnd = gcOpnds[i]; |
| POINTER_SIZE_INT valPtrAddr = getOpndSaveAddr(context, stackInfo, gcOpnd); |
| if (gcOpnd->isObject()) { |
| #ifdef ENABLE_GC_RT_CHECKS |
| GCMap::checkObject(tm, *(void**)valPtrAddr); |
| #endif |
| #ifdef _EM64T_ |
| if(gcOpnd->isCompressed()) |
| gcInterface->enumerateCompressedRootReference((U_32*)valPtrAddr); |
| else |
| #endif |
| gcInterface->enumerateRootReference((void**)valPtrAddr); |
| } else { //mptr with offset |
| assert(gcOpnd->isMPtr()); |
| int offset = gcOpnd->getMPtrOffset(); |
| assert(offset>=0); |
| #ifdef ENABLE_GC_RT_CHECKS |
| char* mptrAddr = *(char**)valPtrAddr; |
| GCMap::checkObject(tm, mptrAddr - offset); |
| #endif |
| gcInterface->enumerateRootManagedReference((void**)valPtrAddr, (size_t)offset); |
| } |
| } |
| } |
| |
| POINTER_SIZE_INT GCSafePoint::getOpndSaveAddr(const JitFrameContext* ctx,const StackInfo& stackInfo,const GCSafePointOpnd *gcOpnd)const { |
| POINTER_SIZE_INT addr = 0; |
| if (gcOpnd->isOnRegister()) { |
| RegName regName = gcOpnd->getRegName(); |
| POINTER_SIZE_INT* stackPtr = stackInfo.getRegOffset(ctx, regName); |
| addr = (POINTER_SIZE_INT)stackPtr; |
| } else { |
| assert(gcOpnd->isOnStack()); |
| #ifdef _EM64T_ |
| addr = ctx->rsp + (POINTER_SIZE_INT)gcOpnd->getDistFromInstESP(); |
| #else |
| addr = ctx->esp + gcOpnd->getDistFromInstESP(); |
| #endif |
| } |
| return addr; |
| } |
| |
| |
| void GCMapCreator::runImpl() { |
| MemoryManager& mm=irManager->getMemoryManager(); |
| GCMap * gcMap=new(mm) GCMap(mm); |
| irManager->calculateOpndStatistics(); |
| gcMap->registerInsts(*irManager); |
| irManager->setInfo(GCMAP_INFO_KEY, gcMap); |
| |
| if (Log::isEnabled()) { |
| gcMap->getGCSafePointsInfo()->dump(getTagName()); |
| } |
| } |
| |
| |
| //_______________________________________________________________________ |
| // RuntimeInterface |
| //____________________________________________________ ___________________ |
| |
| static CountTime enumerateTimer("ia32::gcmap::rt_enumerate"); |
| void RuntimeInterface::getGCRootSet(MethodDesc* methodDesc, GCInterface* gcInterface, |
| const JitFrameContext* context, bool isFirst) |
| { |
| AutoTimer tm(enumerateTimer); |
| |
| if(Log::cat_rt()->isEnabled()) |
| Log::cat_rt()->out() << "ENUMERATE_STACK_FRAME(" << methodDesc << ")" << ::std::endl; |
| |
| // Compute stack information |
| U_32 stackInfoSize = (U_32)StackInfo::getByteSize(methodDesc); |
| U_8* infoBlock = methodDesc->getInfoBlock(); |
| U_8* gcBlock = infoBlock + stackInfoSize; |
| #ifdef _EM64T_ |
| const POINTER_SIZE_INT* gcPointImage = GCMap::findGCSafePointStart((POINTER_SIZE_INT*)gcBlock, *context->p_rip); |
| #else |
| const POINTER_SIZE_INT* gcPointImage = GCMap::findGCSafePointStart((POINTER_SIZE_INT*)gcBlock, *context->p_eip); |
| #endif |
| if (gcPointImage != NULL) { |
| MemoryManager mm("RuntimeInterface::getGCRootSet"); |
| GCSafePoint gcSite(mm, gcPointImage); |
| if (gcSite.getNumOpnds() > 0) { |
| //this is a performance filter for empty points |
| // and debug filter for hardware exception point that have no stack info assigned. |
| StackInfo stackInfo(mm); |
| #ifdef _EM64T_ |
| stackInfo.read(methodDesc, *context->p_rip, false); |
| #else |
| stackInfo.read(methodDesc, *context->p_eip, false); |
| #endif |
| gcSite.enumerate(gcInterface, context, stackInfo); |
| } |
| } else { |
| //hw NPE + GC -> nothing to enumerate for this frame; |
| //in debug mode all hardware exceptions are saved as empty gcsafepoints |
| // yet there are some issues with SOE: |
| // e.g. we are in trouble if SOE is caught in the same method... |
| } |
| } |
| |
| void InfoBlockWriter::runImpl() { |
| StackInfo * stackInfo = (StackInfo*)irManager->getInfo(STACK_INFO_KEY); |
| assert(stackInfo != NULL); |
| GCMap * gcMap = (GCMap*)irManager->getInfo(GCMAP_INFO_KEY); |
| assert(gcMap != NULL); |
| BcMap *bcMap = (BcMap*)irManager->getInfo(BCMAP_INFO_KEY); |
| assert(bcMap != NULL); |
| InlineInfoMap * inlineInfo = (InlineInfoMap*)irManager->getInfo(INLINE_INFO_KEY); |
| assert(inlineInfo !=NULL); |
| |
| CompilationInterface& compIntf = irManager->getCompilationInterface(); |
| |
| if ( !inlineInfo->isEmpty() ) { |
| inlineInfo->write(compIntf.allocateJITDataBlock(inlineInfo->getImageSize(), 8)); |
| } |
| |
| U_32 stackInfoSize = (U_32)stackInfo->getByteSize(); |
| U_32 gcInfoSize = (U_32)gcMap->getByteSize(); |
| U_32 bcMapSize = (U_32)bcMap->getByteSize(); // we should write at least the size of map in the info block |
| assert(bcMapSize >= 4); // minimum size for empty BCMap for all platforms |
| |
| U_8* infoBlock = compIntf.allocateInfoBlock(stackInfoSize + gcInfoSize + bcMapSize); |
| stackInfo->write(infoBlock); |
| gcMap->write(infoBlock+stackInfoSize); |
| |
| bcMap->write(infoBlock + stackInfoSize + gcInfoSize); |
| } |
| |
| }} //namespace |
