/*
 *  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, Konstantin M. Anisimov, Igor V. Chebykin
 *
 */

#include "IpfRuntimeInterface.h"
#include "IpfEncoder.h"
#include "IpfType.h"
#include "IpfOpndManager.h"

using namespace std;

namespace Jitrino {
namespace IPF {

//========================================================================================//
// RuntimeInterface
//========================================================================================//

void RuntimeInterface::unwindStack(MethodDesc      *methodDesc, 
                                   JitFrameContext *jitFrameContext, 
                                   bool            isFirst) {

    // cout << "IPF::RuntimeInterface::unwindStack "  << methodDesc->getName() << endl;

    U_8*      infoBlock = methodDesc->getInfoBlock();    // get method infoBlock
    StackInfo stackInfo  = *((StackInfo*) infoBlock);     // read StackInfo structure

    uint64 sp            = jitFrameContext->sp;           // get current frame sp 
    uint64 addr          = sp + stackInfo.savedBase;      // mem stack offset of first saved gr
    U_32 savedGrMask   = stackInfo.savedGrMask;         // mask of preserved grs saved on stack
    U_32 savedFrMask   = stackInfo.savedFrMask;         // mask of preserved frs saved on stack
    U_32 savedBrMask   = stackInfo.savedBrMask;         // mask of preserved frs saved on stack

    // Restore preserved general registers
    if(savedGrMask != 0) {
        for(U_32 i=0; i<32; i++) {
            if((savedGrMask & 1) == 1) {
                jitFrameContext->p_gr[i] = (uint64 *)addr;
                addr += 8;
            }
            savedGrMask >>= 1;
        }
    }
    
    // Restore preserved floating registers
    if(savedFrMask != 0) {
        for(U_32 i=0; i<32; i++) {
            if((savedFrMask & 1) == 1) {
                jitFrameContext->p_fp[i] = (uint64 *)addr;
                addr += 16;
            }
            savedFrMask >>= 1;
        }
    }

    // Restore preserved branch registers
    if(savedBrMask != 0) {
        for(U_32 i=0; i<8; i++) {
            if((savedBrMask & 1) == 1) {
                jitFrameContext->p_br[i] = (uint64 *)addr;
                addr += 8;
            }
            savedBrMask >>= 1;
        }
    }

    // restore sp
    jitFrameContext->sp += stackInfo.memStackSize;

    // Restore return pointer
    I_32 rpBak = stackInfo.rpBak;
    if(rpBak != LOCATION_INVALID) {
        if(rpBak >= S_BASE) jitFrameContext->p_eip = (uint64 *)(sp + rpBak - S_BASE);
        else                jitFrameContext->p_eip = jitFrameContext->p_gr[rpBak];
    }

    // Restore prs
    I_32 prBak = stackInfo.prBak;
    if(prBak != LOCATION_INVALID) {
        if(prBak >= S_BASE) jitFrameContext->preds = *((uint64 *)(sp + prBak - S_BASE));
        else                jitFrameContext->preds = *(jitFrameContext->p_gr[prBak]);
    }

    // Restore pfs
    I_32 pfsBak = stackInfo.pfsBak;
    if(pfsBak != LOCATION_INVALID) {
        if(pfsBak >= S_BASE) jitFrameContext->p_ar_pfs = (uint64 *)(sp + pfsBak - S_BASE);
        else                 jitFrameContext->p_ar_pfs = jitFrameContext->p_gr[pfsBak];
    }

    // Restore unat
    I_32 unatBak = stackInfo.unatBak;
    if(unatBak != LOCATION_INVALID) {
        if(unatBak >= S_BASE) jitFrameContext->ar_unat = *((uint64 *)(sp + unatBak - S_BASE));
        else                  jitFrameContext->ar_unat = *(jitFrameContext->p_gr[unatBak]);
    }

//    cout << "  sp " << hex << jitFrameContext->sp << dec << " frame size " << stackInfo.memStackSize << endl;
//    if(savedGrMask != 0) cout << "  savedGrMask " << hex << savedGrMask << dec << endl;
//    if(savedFrMask != 0) cout << "  savedFrMask " << hex << savedFrMask << dec << endl;
//    if(savedBrMask != 0) cout << "  savedBrMask " << hex << savedBrMask << dec << endl;
//    if(pfsBak != LOCATION_INVALID) cout << "  pfsBak " << pfsBak << " " << hex << *(jitFrameContext->p_ar_pfs) << dec << endl;
//    if(rpBak  != LOCATION_INVALID) cout << "  rpBak  " << rpBak << " " << hex << *(jitFrameContext->p_eip) << dec << endl;
//    if(prBak  != LOCATION_INVALID) cout << "  prBak  " << prBak << " " << hex << jitFrameContext->preds << dec<< endl;
}

//----------------------------------------------------------------------------------------//

void RuntimeInterface::getGCRootSet(MethodDesc            *methodDesc, 
                                    GCInterface           *gcInterface_, 
                                    const JitFrameContext *context_, 
                                    bool                  isFirst) {

    // cout << "IPF::RuntimeInterface::getGCRootSet" << endl;

    gcInterface      = gcInterface_;
    context          = context_;
    U_8*   infoBlock = methodDesc->getInfoBlock();
    U_8*   gcInfo    = infoBlock + sizeof(StackInfo);
    uint64 currIp    = *context->p_eip;
    U_32 gcSize    = *((U_32 *)gcInfo);

//    cout << "getGCRootSet for ip " << hex << currIp << dec << " method " << methodDesc->getName() << endl;
    U_8* safePoint = findSafePoint(gcInfo, gcSize, currIp);
    enumerateRootSet(gcInterface, context, safePoint);
}

//----------------------------------------------------------------------------------------//

U_32 RuntimeInterface::getInlineDepth(InlineInfoPtr ptr, U_32 offset) {

    std::cout << "FIXME: IPF::RuntimeInterface::getInlineDepth" << endl;
    return 0;
}

//----------------------------------------------------------------------------------------//

Method_Handle RuntimeInterface::getInlinedMethod(InlineInfoPtr ptr, 
                                                 U_32        offset, 
                                                 U_32        inline_depth) {

    std::cout << "FIXME: IPF::RuntimeInterface::getInlinedMethod" << endl;
    return NULL;
}

//----------------------------------------------------------------------------------------//

void RuntimeInterface::fixHandlerContext(MethodDesc *methodDesc, JitFrameContext *context, bool isFirst) {
   //std::cout << "FIXME: IPF::RuntimeInterface::fixHandlerContext " << methodDesc->getName() << endl;
}

//----------------------------------------------------------------------------------------//

void* RuntimeInterface::getAddressOfThis(MethodDesc              *methodDesc, 
                                         const ::JitFrameContext *jitFrameContext, 
                                         bool                    isFirst) {

//    cout << "IPF::RuntimeInterface::getAddressOfThis" << endl;
    assert(!methodDesc->isStatic());
    return jitFrameContext->p_gr[G_INARG_BASE];
}

//----------------------------------------------------------------------------------------//

bool RuntimeInterface::recompiledMethodEvent(MethodDesc               *methodDesc, 
                                             void                     *data) {
    //std::cout << "IPF::RuntimeInterface::recompiledMethodEvent " << methodDesc->getName() << endl;

    char *callAddr      = (char *)(~(((uint64)0x4cafe) << 32) & (uint64)data);
    char **indirectAddr = (char **)methodDesc->getIndirectAddress();
    char *methodAddr    = *indirectAddr;

    return Encoder::patchCallAddr(callAddr, methodAddr);
}

//----------------------------------------------------------------------------------------//

bool RuntimeInterface::getBcLocationForNative(MethodDesc *methodDesc, POINTER_SIZE_INT native_pc, uint16 *bc_pc) {

    std::cout << "FIXME: IPF::RuntimeInterface::getBcLocationForNative " << methodDesc->getName() << endl;
//    assert(0);
//    return false;
    return true;
}

//----------------------------------------------------------------------------------------//

bool RuntimeInterface::getNativeLocationForBc(MethodDesc *methodDesc,  uint16 bc_pc, POINTER_SIZE_INT *native_pc) {

    std::cout << "FIXME: IPF::RuntimeInterface::getNativeLocationForBc " << methodDesc->getName() << endl;
    assert(0);
    return false;
}

//----------------------------------------------------------------------------------------//
// GC Root Set 
//----------------------------------------------------------------------------------------//

U_8* RuntimeInterface::findSafePoint(U_8* info, U_32 size, uint64 currIp)
{
    U_32 offset    = ROOT_SET_HEADER_SIZE;
    U_8*   safePoint = NULL;
    U_32 spSize    = 0;
    uint64 spAddress = 0;

    while (offset < size) {
        safePoint = info + offset;
        spSize    = *((U_32 *)safePoint);
        spAddress = *((uint64 *)(safePoint + sizeof(U_32)));

        if (spAddress == currIp) return safePoint;
        offset += spSize;
    }

    IPF_ERR << " No safe point found";
    return NULL;
}

//----------------------------------------------------------------------------------------//
// 

void RuntimeInterface::enumerateRootSet(GCInterface*           gcInterface,
                                        const JitFrameContext* context,
                                        U_8*                   safePoint)
{
    U_32 size   = *((U_32 *)(safePoint));
    I_32* ptr    = (I_32 *)(safePoint + SAFE_POINT_HEADER_SIZE);
    I_32* maxPtr = (I_32 *)(safePoint + size);

    while (ptr < maxPtr) {
        if (isMptr(*ptr)) reportMptr(*(ptr++), *(ptr++));
        else              reportBase(*(ptr++));
    }
}

//----------------------------------------------------------------------------------------//

void** RuntimeInterface::getContextValue(I_32 location) {
    
    if (location < 0) {
        location = - (location + 1);              // if location refers mptr - restore it
    }

    void** ptr = NULL;
    if (location >= NUM_G_REG) {                  // this location points in memory stack
        I_32 offset = location - NUM_G_REG;      // calc memory stack offset
        ptr = (void **)(context->sp + offset);    // get pointer on stack value
    } else {                                      // general register
        ptr = (void **)(context->p_gr[location]); // get pointer on reg value
    }
    return ptr;                                   // return value
}

//----------------------------------------------------------------------------------------//

void RuntimeInterface::reportMptr(I_32 mptr, I_32 base) {

    void **mptrPtr = getContextValue(mptr);
    void **basePtr = getContextValue(base);

    uint64 *u1    = (uint64 *)basePtr;
    uint64 *u2    = (uint64 *)mptrPtr;
    assert(*u2 >= *u1);
    size_t offset = *u2 - *u1;
//    cout << "  report mptr: " << - (mptr+1) << flush; 
//    cout << " " << u2 << flush;
//    cout << " " << hex << *u2 << dec << flush;
//    cout << " base: " << base << flush;
//    cout << " " << u1 << flush;
//    cout << " " << hex << *u1  << dec; // << endl;
//    cout << " offset " << offset << endl;
    
    gcInterface->enumerateRootManagedReference(mptrPtr, offset);
}

//----------------------------------------------------------------------------------------//

void RuntimeInterface::reportBase(I_32 base) {

    void** basePtr = getContextValue(base);   
//    uint64 *u1 = (uint64 *)basePtr;
//    cout << "  report base: " << base << flush;
//    cout << " " << u1 << flush;
//    cout << " " << hex << *u1  << dec << endl;

    gcInterface->enumerateRootReference(basePtr);
}

//----------------------------------------------------------------------------------------//

bool RuntimeInterface::isMptr(I_32 ptr) { return ptr < 0; }

} // IPF
} // Jitrino