| /* |
| * 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. |
| */ |
| |
| #ifndef _RTINTFC_H_ |
| #define _RTINTFC_H_ |
| |
| #include "open/types.h" |
| #include "Type.h" |
| #include "Jitrino.h" |
| #include "VMInterface.h" |
| #include "Stl.h" |
| |
| namespace Jitrino |
| { |
| |
| /** |
| * Class responsible for runtime operations the JIT (CG in particular) performs: |
| * stack unwinding, root set enumeration, and code patching. |
| */ |
| class RuntimeInterface { |
| public: |
| virtual ~RuntimeInterface() {} |
| virtual void unwindStack(MethodDesc* methodDesc, ::JitFrameContext* context, bool isFirst) = 0; |
| |
| virtual void getGCRootSet(MethodDesc* methodDesc, GCInterface* gcInterface, |
| const ::JitFrameContext* context, bool isFirst) = 0; |
| |
| virtual void fixHandlerContext(MethodDesc* methodDesc, ::JitFrameContext* context, bool isFirst) = 0; |
| |
| virtual void* getAddressOfThis(MethodDesc* methodDesc, const ::JitFrameContext* context, bool isFirst) = 0; |
| virtual bool isSOEArea(MethodDesc* methodDesc, const ::JitFrameContext* context, bool isFirst) {return false;} |
| |
| virtual bool getBcLocationForNative(MethodDesc* method, POINTER_SIZE_INT native_pc, uint16 *bc_pc) = 0; |
| virtual bool getNativeLocationForBc(MethodDesc* method, uint16 bc_pc, POINTER_SIZE_INT *native_pc) = 0; |
| |
| virtual bool recompiledMethodEvent(MethodDesc * methodDesc, void * data) = 0; |
| |
| virtual U_32 getInlineDepth(InlineInfoPtr ptr, U_32 offset) { return 0; } |
| virtual Method_Handle getInlinedMethod(InlineInfoPtr ptr, U_32 offset, U_32 inline_depth) { return NULL; } |
| virtual uint16 getInlinedBc(InlineInfoPtr ptr, U_32 offset, U_32 inline_depth) = 0; |
| |
| }; |
| |
| /** |
| * Registry of bytecode<->native mapping for inlined methods within a compiled method. |
| * Allows to record the mapping at compile time and extract/query it at runtime. |
| */ |
| class InlineInfoMap { |
| public: |
| /* |
| * Inline info for a single call site or instruction, |
| * linked to a chain of inlined calls. |
| */ |
| class Entry { |
| public: |
| Entry(Entry* parent, uint16 _bcOffset, Method_Handle _method) |
| : parentEntry(parent), bcOffset(_bcOffset), method(_method){} |
| |
| Entry* parentEntry; |
| uint16 bcOffset; |
| Method_Handle method; |
| |
| /** |
| * Counts number of inlined calls in the chain, including this. |
| */ |
| U_32 getInlineDepth() const { |
| return (parentEntry == 0) ? 1 : 1 + parentEntry->getInlineDepth(); |
| } |
| }; |
| |
| InlineInfoMap(MemoryManager& mm) : memManager(mm), entries(mm), entryByOffset(mm){} |
| |
| /** |
| * Creates a loose entry, not registered at the map. |
| */ |
| Entry* newEntry(Entry* parent, Method_Handle mh, uint16 bcOffset); |
| |
| /** |
| * Records unique mapping of a top-level entry to the specified native offset. |
| * Parent entries are added to a common list for future references. |
| */ |
| void registerEntry(Entry* entry, U_32 nativeOff); |
| |
| bool isEmpty() const { return entries.empty();} |
| U_32 getImageSize() const; |
| void write(InlineInfoPtr output); |
| |
| static const Entry* getEntryWithMaxDepth(InlineInfoPtr ptr, U_32 nativeOffs); |
| static const Entry* getEntry(InlineInfoPtr ptr, U_32 nativeOffs, U_32 inlineDepth); |
| private: |
| MemoryManager& memManager; |
| /** |
| * List of all entries w/o duplicates |
| */ |
| StlVector<Entry*> entries; |
| /** |
| * Unique mapping of native offset -> top-level entry |
| */ |
| StlMap<U_32, Entry*> entryByOffset; |
| }; |
| |
| } |
| #endif // _RTINTFC_H_ |