/*
 *  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 Alexander Astapchuk
 */
 
 /**
  * @file
  * @brief Contains platform-independent routines for runtime support.
  */
#include "open/vm_method_access.h"
#include "compiler.h"
#include "trace.h"

#include "jet.h"

#include "jit_import_rt.h"
#include "open/vm_ee.h"

#include "port_threadunsafe.h"
#include "EMInterface.h"

#if !defined(_IPF_)
#include "enc_ia32.h"
#endif

namespace Jitrino {
namespace Jet {


bool rt_check_method(JIT_Handle jit, Method_Handle method)
{
    char * pinfo = (char*)method_get_info_block_jit(method, jit);
    return MethodInfoBlock::is_valid_data(pinfo);
}

static JitFrameContext* dummyCTX = NULL;
static POINTER_SIZE_INT sp_off = (char*)devirt(sp, dummyCTX) - (char*)dummyCTX;
static POINTER_SIZE_INT ip_off = (char*)devirt(gr_x, dummyCTX) - (char*)dummyCTX;

static const POINTER_SIZE_INT bp_off = (char*)devirt(bp, dummyCTX) - (char*)dummyCTX;
static const unsigned bp_idx = ar_idx(bp);
static const unsigned bp_bytes = word_no(bp_idx)*WORD_SIZE/CHAR_BIT;
static const unsigned bp_mask  = 1<<bit_no(bp_idx);
static const int bp_spill_off = ((StackFrame*)NULL)->spill(bp);

#ifdef _IA32_
//
static AR ebx = virt(RegName_EBX);
static const unsigned ebx_idx = ar_idx(ebx);
static const unsigned ebx_bytes = word_no(ebx_idx)*WORD_SIZE/CHAR_BIT;
static const unsigned ebx_mask  = 1<<bit_no(ebx_idx);
static const int      ebx_spill_off = ((StackFrame*)NULL)->spill(ebx);
//
static AR esi = virt(RegName_ESI);
static const unsigned esi_idx = ar_idx(esi);
static const unsigned esi_bytes = word_no(esi_idx)*WORD_SIZE/CHAR_BIT;
static const unsigned esi_mask  = 1<<bit_no(esi_idx);
static const int      esi_spill_off = ((StackFrame*)NULL)->spill(esi);
//
static AR edi = virt(RegName_EDI);
static const unsigned edi_idx = ar_idx(edi);
static const unsigned edi_bytes = word_no(edi_idx)*WORD_SIZE/CHAR_BIT;
static const unsigned edi_mask  = 1<<bit_no(edi_idx);
static const int      edi_spill_off = ((StackFrame*)NULL)->spill(edi);
//
#endif // _IA32_


/**
 * @brief Prints out a message to identify a program location.
 *
 * The message includes method name and class, IP and PC of the location.
 * Message is preceded with the specified \c name.
 * The function uses #dbg and does not print out new-line character.
 */
static void rt_trace(const char * name, Method_Handle meth, 
                     const MethodInfoBlock& infoBlock,
                     const JitFrameContext * context)
{
    void *** pip = devirt(gr_x, context);
    char * ip = (char*)**pip;
    char * where = ip;
    if (context->is_ip_past) {
        --where;
    }
    dbg_rt("%s @ %s::%s @ %p/%u: ", 
        name,
        class_get_name(method_get_class(meth)), method_get_name(meth),
        ip, infoBlock.get_pc(where));
}

void rt_unwind(JIT_Handle jit, Method_Handle method, 
               JitFrameContext * context)
{
    char * pinfo = (char*)method_get_info_block_jit(method, jit);
    
    assert(MethodInfoBlock::is_valid_data(pinfo));

    MethodInfoBlock infoBlock(pinfo);
    StackFrame sframe(infoBlock.get_num_locals(),
                      infoBlock.get_stack_max(), 
                      infoBlock.get_in_slots());
                      
    JitFrameContext saveContextForLogs;
    if (infoBlock.get_flags() & DBG_TRACE_RT) {
        saveContextForLogs= *context;
    }
                      
    //void ** psp = (void**)devirt(sp, context);
    void ** psp = (void**)((char*)context + sp_off);
    char * sp_val = (char*)*psp;
    
    // here, gr_x means 'IP'
    //void *** pip = devirt(gr_x, context);
    void *** pip = (void***)((char*)context + ip_off);
    
    char * where = (char*)**pip;
    if (context->is_ip_past) {
        --where;
    }
    
    // A special processing - mostly for StackOverflowError:
    // if something terrible happens during the stack preparation sequence,
    // then the registers are not saved yet, so we can't restore them from 
    // the JitFrameContext. The good news is that the callee-save registers 
    // are also untouched yet, so we only need to restore SP and IP
    char * meth_start = infoBlock.get_code_start();
    unsigned whereLen = (unsigned)(where - meth_start);
    if (whereLen<infoBlock.get_warmup_len()) {
        *psp = sp_val + sframe.size();
        // Now, [sp] = retIP
        sp_val = (char*)*psp;
        *pip = (void**)sp_val;
        sp_val += STACK_SLOT_SIZE; // pop out the retIP
        *psp = sp_val;
        return;
    }
    
    //void *** pbp = devirt(bp, context);
    void *** pbp = (void***)((char*)context + bp_off);
    char * bp_val = (char*)(**pbp);
    
    assert(!(infoBlock.get_flags() & JMF_SP_FRAME)); // not yet 
    
    // restore sp
    sp_val = bp_val;
    // ^^^ now, sp has the same value as it was on method's entrance (points
    // to retIP)
    *pip = (void**)sp_val;
    
    //
    // restore callee-save regs
    //
#ifdef _DEBUG
    UNSAFE_REGION_START
    // presumption: only GP registers can be callee-save
    static bool do_check = true;
    for (unsigned i=0; do_check && i<ar_num; i++) {
        AR ar = _ar(i);
        assert(!is_callee_save(ar) || is_gr(ar));
    }
    do_check = false;
    UNSAFE_REGION_END
#endif

#if defined(_EM64T_) || defined(_IPF_)
    // Common version for all platforms but IA32
    for (unsigned i=0; i<gr_num; i++) {
        AR ar = _gr(i);
        if (infoBlock.is_saved(ar)) {
            void *** preg = devirt(ar, context);
            assert(preg && *preg);
            *preg = (void**)(sp_val+sframe.spill(ar));
            if (infoBlock.get_flags() & DBG_TRACE_RT) {
                dbg_rt("\trt.unwind.%s.%s: [%p]=%p\n", 
                    Encoder::to_str(ar, false).c_str(),
                    Encoder::to_str(ar, true).c_str(), *preg, **preg);
            }
        }
    }
#else
    //
    // Highly optimized version for IA32 - the loop of 4 callee-save 
    // register is unrolled, every constant value is precomputed and 
    // cached.
    //
    unsigned map_off, mask;
    int spill_off;
    //
    const char * map = infoBlock.saved_map();
    //
    //
    map_off = bp_bytes; mask = bp_mask; spill_off = bp_spill_off;
    // bp is always saved
    assert(*(unsigned*)(map+map_off) & mask);
    {
        context->p_ebp = (unsigned*)(sp_val + spill_off);
    }
    //
    //
    map_off = ebx_bytes; mask = ebx_mask; spill_off = ebx_spill_off;
    if (*(unsigned*)(map+map_off) & mask) {
        context->p_ebx = (unsigned*)(sp_val + spill_off);
    }
    //
    //
    map_off = esi_bytes; mask = esi_mask;  spill_off = esi_spill_off;
    if (*(unsigned*)(map+map_off) & mask) {
        context->p_esi = (unsigned*)(sp_val + spill_off);
    }
    //
    //
    map_off = edi_bytes; mask = edi_mask;  spill_off = edi_spill_off;
    if (*(unsigned*)(map+map_off) & mask) {
        context->p_edi = (unsigned*)(sp_val + spill_off);
    }
#endif
    // When needed, restore the whole context including scratch registers
    // (normally, under JVMTI for PopFrame functionality)
    if (infoBlock.get_compile_params().exe_restore_context_after_unwind) {
        for (unsigned i=0; i<ar_num; i++) {
            AR ar = _ar(i);
            if (is_callee_save(ar) || ar==sp) {
                continue;
            }
            void *** preg = devirt(ar, context);
            //FIXME: JVMTI-popframe // assert(preg && *preg);
            // ^^ temporarily disabling the assert, will need to uncomment
            // when VM also supports all the registers to restore
            // Currently, XMM regs are not restored as there are no proper
            // fields in JitFrameContext
            if (preg && *preg) {
                *preg = (void**)(sp_val+sframe.jvmti_register_spill_offset(ar));
                if (infoBlock.get_flags() & DBG_TRACE_RT) {
                    dbg_rt("\trt.JVMTI.unwind.%s.%s: [%p]=%p\n",
                        Encoder::to_str(ar, false).c_str(),
                        Encoder::to_str(ar, true).c_str(), *preg, **preg);
                }
            } // ~if (*preg)
        }
    }

    sp_val += STACK_SLOT_SIZE; // pop out retIP
    *psp = sp_val;

    if (infoBlock.get_flags() & DBG_TRACE_RT) {
        void *** pip = devirt(gr_x, context);
        rt_trace("rt.unwind", method, infoBlock, &saveContextForLogs);
        dbg_rt("\t=>=> %p; SP=%p\n", **pip, sp_val);
    }
}

void rt_enum(JIT_Handle jit, Method_Handle method, 
             GC_Enumeration_Handle henum, JitFrameContext * context)
{
    if (!context->is_ip_past && !StaticConsts::g_jvmtiMode) {
        // The IP points directly to the instructions - this must be a 
        // hardware NPE happened. 
        // A special case is SOE, which is allowed to happen only at the method start.
        // Check the presumptions:
        assert(method_get_exc_handler_number(method) == 0 || rt_is_soe_area(jit, method, context));
#ifdef _DEBUG
        bool sync = method_is_synchronized(method);
        bool inst = !method_is_static(method);
        assert(!(sync && inst));
#endif
        // Nothing to report here - the method is about to exit.
        return;
    }
    char * pinfo = (char*)method_get_info_block_jit(method, jit);
    assert(MethodInfoBlock::is_valid_data(pinfo));

    MethodInfoBlock infoBlock(pinfo);
    assert(!(infoBlock.get_flags() & JMF_SP_FRAME)); // not yet 
    
    void *** pip = (void***)((char*)context + ip_off);
    char * where = (char*)**pip;
    char * meth_start = infoBlock.get_code_start();
    unsigned whereLen = (unsigned)(where - meth_start);
    if (whereLen<infoBlock.get_warmup_len()) {
        return;
    }

    if (DBG_TRACE_RT & infoBlock.get_flags()) {
        rt_trace("rt.enum.start", method, infoBlock, context);
    }
    StackFrame frame(infoBlock.get_num_locals(), infoBlock.get_stack_max(), 
                  infoBlock.get_in_slots() );
    char * ebp = (char*)**devirt(bp, context);
    //
    //
    //
    unsigned * map = (unsigned*)(ebp + frame.info_gc_locals());
    for (unsigned i=0; i<infoBlock.get_num_locals(); i++) {
        if (!tst(map, i)) {
            continue;
        }
        void **p_obj = (void**)(ebp + frame.local(i));
        if (DBG_TRACE_RT & infoBlock.get_flags()) {
            //rt_trace("gc.item", method, infoBlock, context);
            dbg_rt("\tlocal#%d=>%p (%p)\n", i, p_obj, *p_obj);
        }
        vm_enumerate_root_reference(p_obj, FALSE);
    }
    //
    // Report input args with objects in it
    //    
    map = (unsigned*)(ebp + frame.info_gc_args());
    for (unsigned i=0; i<infoBlock.get_in_slots(); i++) {
        if (!tst(map, i)) {
            continue;
        }
        void **p_obj = (void**)(ebp + frame.inargs()+i*STACK_SLOT_SIZE);
        if (DBG_TRACE_RT & infoBlock.get_flags()) {
            dbg_rt("\tin_arg#%d=>%p (%p)\n", i, p_obj, *p_obj);
        }
        vm_enumerate_root_reference(p_obj, FALSE);
    }
    //
    //
    //
    map = (unsigned*)(ebp + frame.info_gc_regs());
    unsigned obj_regs = *map;
    // only one word is allocated to store a GC map for registers
    assert(gr_num < WORD_SIZE);
    for (unsigned i=0; i<WORD_SIZE; i++) {
        if (obj_regs & 1) {
            AR ar = _ar(i);
            assert(is_gr(ar) && is_callee_save(ar));
            void ** p_obj;
            p_obj = *devirt(ar, context);
            if (DBG_TRACE_RT & infoBlock.get_flags()) {
                //rt_trace("gc.item", method, infoBlock, context);
                dbg_rt("\treg#%s#%s=>%p (%p)\n", 
                Encoder::to_str(ar, false).c_str(), 
                Encoder::to_str(ar, true).c_str(),
                p_obj, *p_obj);
            }
            vm_enumerate_root_reference(p_obj, FALSE);
        }
        obj_regs >>= 1;
    }
    
    map = (unsigned*)(ebp + frame.info_gc_stack());
    unsigned rt_stack_depth = *(unsigned*)(ebp+frame.info_gc_stack_depth());
    
    for (unsigned i=0; i<rt_stack_depth; i++) {
        if (!tst(map, i)) {
            continue;
        }
        void ** p_obj;
        p_obj = (void**)(ebp + frame.stack_slot(i));
        if (DBG_TRACE_RT & infoBlock.get_flags()) {
            //rt_trace("gc.item", method, infoBlock, context);
            dbg_rt("\tstack#%d=>%p (%p)\n", i, p_obj, *p_obj);
        }
        vm_enumerate_root_reference(p_obj, FALSE);
    }

    if (infoBlock.get_flags() & JMF_REPORT_THIS) {
        void ** p_obj = (void**)rt_get_address_of_this(jit, method, context);
        if (DBG_TRACE_RT & infoBlock.get_flags()) {
            //rt_trace("gc.item", method, infoBlock, context);
            dbg_rt("\tin.this#=>%p (%p)\n", p_obj, *p_obj);
        }
        vm_enumerate_root_reference(p_obj, FALSE);
    }
    if (DBG_TRACE_RT & infoBlock.get_flags()) {
        rt_trace("rt.enum.done", method, infoBlock, context);
    }
}

void rt_fix_handler_context(JIT_Handle jit, Method_Handle method, 
                            JitFrameContext * context)
{
    char * pinfo = (char*)method_get_info_block_jit(method, jit);

    assert(MethodInfoBlock::is_valid_data(pinfo));
    //
    MethodInfoBlock infoBlock(pinfo);
    assert(!(infoBlock.get_flags() & JMF_SP_FRAME)); // not yet 
    
    void *** pip = (void***)((char*)context + ip_off);
    char * where = (char*)**pip;
    char * meth_start = infoBlock.get_code_start();

#ifdef _DEBUG
    unsigned meth_len = infoBlock.get_code_len();
    assert(meth_start <= where);
    assert(where < meth_start + meth_len);
#endif

    unsigned whereLen = (unsigned)(where - meth_start);
    if (whereLen<infoBlock.get_warmup_len()) {
        return;
    }
    
    StackFrame sframe(infoBlock.get_num_locals(),
                      infoBlock.get_stack_max(),
                      infoBlock.get_in_slots());

    unsigned frameSize = sframe.size();

    void ** psp = (void**)devirt(sp, context);
    void *** pbp = devirt(bp, context);
    char * bp_val = (char*)(**pbp);
    char * sp_val = bp_val - frameSize;
    if (infoBlock.get_flags() & DBG_TRACE_RT) {
        rt_trace("rt.fix_handler", method, infoBlock, context);
        dbg_rt("oldESP=%p ; newESP=%p\n", *psp, sp_val);
    }
    *psp = sp_val;
}

Boolean rt_is_soe_area(JIT_Handle jit, Method_Handle method, const JitFrameContext * context) {
    char * pinfo = (char*)method_get_info_block_jit(method, jit);

    assert(MethodInfoBlock::is_valid_data(pinfo));
    
    MethodInfoBlock infoBlock(pinfo);
    assert(!(infoBlock.get_flags() & JMF_SP_FRAME)); // not yet 

    void *** pip = (void***)((char*)context + ip_off);
    char * where = (char*)**pip;
    char * meth_start = infoBlock.get_code_start();
    unsigned whereLen = (unsigned)(where - meth_start);
    if (whereLen<infoBlock.get_warmup_len()) {
        return 1;
    }
    return 0;

}

void * rt_get_address_of_this(JIT_Handle jit, Method_Handle method,
                              const JitFrameContext * context)
{
    char * pinfo = (char*)method_get_info_block_jit(method, jit);

    assert(MethodInfoBlock::is_valid_data(pinfo));
    //
    MethodInfoBlock infoBlock(pinfo);
    assert(!(infoBlock.get_flags() & JMF_SP_FRAME)); // not yet 
    
    void *** pip = (void***)((char*)context + ip_off);
    char * where = (char*)**pip;
    char * meth_start = infoBlock.get_code_start();
    unsigned whereLen = (unsigned)(where - meth_start);
    if (whereLen<infoBlock.get_warmup_len()) {
        return NULL;
    }
    
    // We did not store 'this' specially
    if (!(infoBlock.get_flags() & JMF_REPORT_THIS)) {
        return NULL;
    }
    StackFrame stackframe(infoBlock.get_num_locals(),
                          infoBlock.get_stack_max(),
                          infoBlock.get_in_slots());

    void *** pbp = devirt(bp, context);
    char * bp_val = (char*)(**pbp);
    void ** p_obj = (void**)(bp_val + stackframe.thiz());
    
    if (infoBlock.get_flags() & DBG_TRACE_RT) {
        void ** psp = (void**)devirt(sp, context);
        char * sp_val = (char*)*psp;
        rt_trace("rt.get_thiz", method, infoBlock, context);
        dbg_rt("p_thiz=%p, thiz=%p (sp=%p)\n", p_obj, p_obj ? *p_obj : NULL, sp_val);
    }
    return p_obj;
}

void rt_bc2native(JIT_Handle jit, Method_Handle method, unsigned short bc_pc,
                  void ** pip)
{
    char * pinfo = (char*)method_get_info_block_jit(method, jit);
    assert(MethodInfoBlock::is_valid_data(pinfo));

    MethodInfoBlock rtinfo(pinfo);
    assert(bc_pc < rtinfo.get_bc_size());
    *pip = (void*)rtinfo.get_ip(bc_pc); 
    if (rtinfo.get_flags() & DBG_TRACE_RT) {
        dbg_rt("rt.bc2ip: @ %u => %p\n", bc_pc, *pip);
    }
}

void rt_native2bc(JIT_Handle jit, Method_Handle method, const void * ip,
                  unsigned short * pbc_pc)
{
    char * pinfo = (char*)method_get_info_block_jit(method, jit);
    assert(MethodInfoBlock::is_valid_data(pinfo));

    MethodInfoBlock rtinfo(pinfo);
#ifdef _DEBUG
    char * where = (char*)ip;
    char * meth_start = rtinfo.get_code_start();
    unsigned meth_len = rtinfo.get_code_len();
    assert(meth_start <= where);
    assert(where < meth_start + meth_len);
#endif

    *pbc_pc = (unsigned short)rtinfo.get_pc((char*)ip);

    if (rtinfo.get_flags() & DBG_TRACE_RT) {
        dbg_rt("rt.ip2bc: @ 0x%p => %d\n", ip, *pbc_pc);
    }
}

::OpenExeJpdaError rt_get_local_var(JIT_Handle jit, Method_Handle method,
                                    const ::JitFrameContext *context,
                                    unsigned var_num, VM_Data_Type var_type,
                                    void *value_ptr)
{
    //
    //FIXME:
    // Current implementation will work incorrectly with local variables
    // cached on registers and with variables that reuse input args slots.
    //
    // Need to store regs=>locals into MethodInfo block and also  
    // locals=>input args (or invent a simple algorithm of how to detect
    // this mapping during runtime).
    //
           
    char * pinfo = (char*)method_get_info_block_jit(method, jit);
    assert(MethodInfoBlock::is_valid_data(pinfo));
    MethodInfoBlock infoBlock(pinfo);
    if (var_num >= infoBlock.get_num_locals()) {
        return EXE_ERROR_INVALID_SLOT;
    }
    StackFrame frame(infoBlock.get_num_locals(),
                     infoBlock.get_stack_max(),
                     infoBlock.get_in_slots());

    char * ebp = (char*)**devirt(bp, context);
    unsigned * map = (unsigned*)(ebp + frame.info_gc_locals());

    uint64* var_ptr_to_64;
    U_32* var_ptr_to32;

    switch(var_type) {
    case VM_DATA_TYPE_INT64:
    case VM_DATA_TYPE_UINT64:
    case VM_DATA_TYPE_F8:
        var_ptr_to_64 = (uint64*)value_ptr;
        *var_ptr_to_64 = *(uint64*)(ebp + frame.local(var_num));
        break;
    case VM_DATA_TYPE_ARRAY:
    case VM_DATA_TYPE_CLASS:
        if (!tst(map, var_num)) {
            return EXE_ERROR_TYPE_MISMATCH;
        }
#ifdef _EM64T_
    case VM_DATA_TYPE_STRING:
        var_ptr_to_64 = (uint64*)value_ptr;
        *var_ptr_to_64 = *(uint64*)(ebp + frame.local(var_num));
        break;
#endif
    default:
        var_ptr_to32 = (U_32*)value_ptr;
        *var_ptr_to32 = *(U_32*)(ebp + frame.local(var_num));
    }
    return EXE_ERROR_NONE;
}

::OpenExeJpdaError rt_set_local_var(JIT_Handle jit, Method_Handle method,
                                    const ::JitFrameContext *context,
                                    unsigned var_num, VM_Data_Type var_type,
                                    void *value_ptr)
{
    char * pinfo = (char*)method_get_info_block_jit(method, jit);
    assert(MethodInfoBlock::is_valid_data(pinfo));
    MethodInfoBlock infoBlock(pinfo);
    if (var_num >= infoBlock.get_num_locals()) {
        return EXE_ERROR_INVALID_SLOT;
    }
    StackFrame frame(infoBlock.get_num_locals(),
                     infoBlock.get_stack_max(),
                     infoBlock.get_in_slots());


    char * ebp = (char*)**devirt(bp, context);
    uint64* var_ptr_to_64;
    U_32* var_ptr_to32;
    
    switch(var_type) {
    case VM_DATA_TYPE_INT64:
    case VM_DATA_TYPE_UINT64:
    case VM_DATA_TYPE_F8:
#ifdef _EM64T_
    case VM_DATA_TYPE_ARRAY:
    case VM_DATA_TYPE_CLASS:
    case VM_DATA_TYPE_STRING:
#endif
        var_ptr_to_64 = (uint64*)(ebp + frame.local(var_num));
        *var_ptr_to_64 = *(uint64*)value_ptr;
        break;
    default:
        var_ptr_to32 = (U_32*)(ebp + frame.local(var_num));
        *var_ptr_to32 = *(U_32*)value_ptr;
    }

    return EXE_ERROR_NONE;
}


void rt_profile_notification_callback(JIT_Handle jit, PC_Handle pch, Method_Handle mh) 
{
   JITInstanceContext* jitContext = JITInstanceContext::getContextForJIT(jit);

   //heck that profiler type is EB, counters are patched only for Entry Backage profile
   if ((jitContext->getProfilingInterface())->getProfileType(pch) == EM_PCTYPE_ENTRY_BACKEDGE) {
       //Get MethodInfoBlock of the method to be patched
       char * pinfo = (char*)method_get_info_block_jit(mh, jit);
       assert(MethodInfoBlock::is_valid_data(pinfo));
       MethodInfoBlock infoBlock(pinfo);

       if (infoBlock.get_flags() & DBG_TRACE_RT) {
           const char* methodName = method_get_name(mh);
           const char* className = class_get_name(method_get_class(mh));
           dbg_rt("rt.patch_eb_counters: patching method %s.%s\n", className, methodName);
       }

       //Replace counters with nops in 3 steps:
       //1. Atomically replace first 2 bytes of counter instruction with jump to the 
       //next instruction
       //2. Replace all the remaining bytes of counter instruction with nops
       //3. Atomically replace jump with 2 nops
       U_8* methodAddr = method_get_code_block_jit(mh, jit);
       for (U_32 i = 0 ; i<infoBlock.num_profiler_counters; i++) {
           U_32 offsetInfo = infoBlock.profiler_counters_map[i];
           U_32 codeOffset = ProfileCounterInfo::getInstOffset(offsetInfo);
           U_32 patchedSize = ProfileCounterInfo::getInstSize(offsetInfo);

           U_8* patchedAddr = methodAddr + codeOffset;
           //1. Generate jump to the next instruction
           char* jmpIP = (char*)patchedAddr;
           char jmpOffset = (char)(patchedSize - 2);
           if (((POINTER_SIZE_INT)jmpIP)&0x1) {
               jmpIP++;
               jmpOffset--;
           }

           //to guarantee that first replacing will be atomic we have to 
           //manually write jmp instruction instead of using encoder
           *(uint16*)jmpIP = (uint16)((0xeb) | jmpOffset << 8);
           assert(((uint16)(int_ptr)(jmpIP) & 0x01)==0);

           //2. Put nops instead of inst, 1 byte nops are used here for asm 
           //readability
           char* ip = jmpIP + 2;
           for (int i=0; i<jmpOffset; i++) {
               EncoderBase::nops(ip+i, 1);
           }

           //3. Atomically replace jump with nop;
           *(uint16*)jmpIP = (uint16)0x9090; //2 nops atomically.
       }
      infoBlock.release();
   }
}

}};    // ~namespace Jitrino::Jet