/*
 *  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
 */

#include "Ia32IRManager.h"
#include "Stl.h"
#include "Ia32StackInfo.h"
#include "Ia32RuntimeInterface.h"
#include "Ia32InternalTrace.h"
#include <math.h>


namespace Jitrino
{
namespace Ia32 {

//========================================================================================
//  class StackInfoInstRegistrar
//========================================================================================
/**
 *  class StackInfoInstRegistrar performs calling of StackInfo method which
 *  performes saving information about call instructions for stack unwinding
 *
 *  This transformer ensures that it calls the proper method
 *
 *  This transformer must inserted after Code Emitter, because it needs
 *  EIP value for instructions.
 */

class StackInfoInstRegistrar : public SessionAction {
    void runImpl()
    { 
        StackInfo * stackInfo = (StackInfo*)irManager->getInfo(STACK_INFO_KEY);
        assert(stackInfo!=NULL);
        stackInfo->registerInsts(*irManager);
        stackInfo->setMethodExitString(*irManager);
    }
    U_32 getNeedInfo()const{ return 0; }
    U_32 getSideEffects()const{ return 0; }
    bool isIRDumpEnabled(){ return false; }
};


static ActionFactory<StackInfoInstRegistrar> _si_insts("si_insts");

#define CALL_MIN_SIZE 2
#define CALL_MAX_SIZE 6

POINTER_SIZE_INT hashFunc(POINTER_SIZE_INT key, U_32 hashTableSize) {
    return (key % hashTableSize);
}

    StackDepthInfo hashGet(DepthEntry** entries, POINTER_SIZE_INT key, U_32 hashTableSize) {
        DepthEntry * e = entries[hashFunc(key,hashTableSize)];
        assert(e);
        for(;e !=NULL;) {
            if(e->eip == key) 
                return e->info;
            else
                e = e->next;
            assert(e);
        }
        return e->info;
    }

    void hashSet(DepthEntry** entries, POINTER_SIZE_INT eip, U_32 hashTableSize,StackDepthInfo info, MemoryManager& mm) {
        POINTER_SIZE_INT key = hashFunc(eip,hashTableSize);
        DepthEntry * e = entries[key];
        if(!e) {
            entries[key] = new(mm) DepthEntry(eip, info, NULL);
        } else {
            for(;e->next!=NULL;e = e->next) ;
            e->next =  new(mm) DepthEntry(eip, info, NULL);
        }
    }

POINTER_SIZE_INT StackInfo::getByteSize() const     {
    return byteSize ? 
            byteSize : 
            (sizeof(StackInfo)+(stackDepthInfo?stackDepthInfo->size()*sizeof(DepthEntry):0))+hashTableSize*sizeof(POINTER_SIZE_INT);
}

POINTER_SIZE_INT StackInfo::getByteSize(MethodDesc* md) {
    U_8* data =  md->getInfoBlock();
    return *(POINTER_SIZE_INT*)data;
}

POINTER_SIZE_INT StackInfo::readByteSize(const U_8* bytes) const{
    POINTER_SIZE_INT* data = (POINTER_SIZE_INT *) bytes;
    POINTER_SIZE_INT sizeInBytes = *data;

    return sizeInBytes;
}

typedef DepthEntry * EntryPtr;

void StackInfo::write(U_8* bytes) {
    U_8* data = bytes;
    StackInfo* serializedInfo = (StackInfo*)data;
    *serializedInfo = *this;
    serializedInfo->byteSize = getByteSize();
    data+=sizeof(StackInfo);
    MemoryManager mm("DepthInfo");
    EntryPtr * entries = new(mm) EntryPtr[hashTableSize];
    for(U_32 i = 0; i< hashTableSize; i++)
        entries[i] = NULL;
    for(DepthMap::iterator dmit = stackDepthInfo->begin(); dmit != stackDepthInfo->end(); dmit++) {
        hashSet(entries, dmit->first, hashTableSize, dmit->second, mm);
    }
    U_8* next = data + hashTableSize * sizeof(POINTER_SIZE_INT);
    for(U_32 i = 0; i< hashTableSize; i++) {
        DepthEntry * e = entries[i];
        POINTER_SIZE_INT serializedEntryAddr = 0;
        if(entries[i]) {
            serializedEntryAddr = (POINTER_SIZE_INT)next;
            for(; e != NULL; e = e->next) {
                DepthEntry* serialized = (DepthEntry*)next;
                *serialized = *e;
                next+=sizeof(DepthEntry);
                serialized->next = e->next ? (DepthEntry*)next : NULL;
            }
        }
        *((POINTER_SIZE_INT*)data)= serializedEntryAddr;
        data+=sizeof(POINTER_SIZE_INT);
    }
    assert(getByteSize() == (POINTER_SIZE_INT) (((U_8*)next) - bytes));
}

DepthEntry * getHashEntry(U_8* data, POINTER_SIZE_INT eip, U_32 size) 
{
    if(!size)
        return NULL;
    POINTER_SIZE_INT key = hashFunc(eip,size);
    data += sizeof(StackInfo) + key * sizeof(POINTER_SIZE_INT);
    DepthEntry * entry = (DepthEntry *)*(POINTER_SIZE_INT*)data;
    for(;entry && entry->eip != eip; entry = entry->next) {
        assert(entry!=entry->next);
    }
    return entry;
}

void StackInfo::read(MethodDesc* pMethodDesc, POINTER_SIZE_INT eip, bool isFirst) {
    U_8* data = pMethodDesc->getInfoBlock();
    byteSize = ((StackInfo *)data)->byteSize;
    hashTableSize = ((StackInfo *)data)->hashTableSize;
    frameSize = ((StackInfo *)data)->frameSize;
    icalleeOffset = ((StackInfo *)data)->icalleeOffset;
    icalleeMask = ((StackInfo *)data)->icalleeMask;
    localOffset = ((StackInfo *)data)->localOffset;
    offsetOfThis = ((StackInfo *)data)->offsetOfThis;
    itraceMethodExitString = ((StackInfo *)data)->itraceMethodExitString;
    soeCheckAreaOffset = ((StackInfo *)data)->soeCheckAreaOffset;
    
    if (!isFirst){
        DepthEntry * entry = getHashEntry(data, eip, hashTableSize);
        assert(entry);
        if (!entry){
            if (Log::cat_rt()->isEnabled())
                Log::cat_rt()->out()<<"eip=0x"<<(void*)eip<<" not found during stack unwinding!"<<::std::endl;
            ::std::cerr<<"eip=0x"<<(void*)eip<<" not found during stack unwinding!"<<::std::endl;
        }
        calleeSaveRegsMask = entry->info.calleeSaveRegs;
        stackDepth = entry->info.stackDepth;
    }else{
        assert(eip >= (POINTER_SIZE_INT)pMethodDesc->getCodeBlockAddress(0));
        POINTER_SIZE_INT eipOffset = eip - (POINTER_SIZE_INT)pMethodDesc->getCodeBlockAddress(0);
        assert(fit32(eipOffset));
        if (eipOffset <= soeCheckAreaOffset) {
            stackDepth = 0; //0 depth -> stack overflow error
        } else {
            DepthEntry * entry = NULL;
            U_32 i = CALL_MIN_SIZE;
            for (; i<= CALL_MAX_SIZE; i++) {
                entry = getHashEntry(data, eip + i, hashTableSize);
                if(entry)
                    break;
            }
            if (entry && (entry->info.callSize == i)) {
                stackDepth = entry->info.stackDepth; //call site's depth
            } else {
                stackDepth = frameSize; //hardware NPE's depth
            }
        }

        if (Log::cat_rt()->isEnabled())
            Log::cat_rt()->out()<<"Hardware exception from eip=0x"<<(void*)eip<<::std::endl;
    }
}


void StackInfo::unwind(MethodDesc* pMethodDesc, JitFrameContext* context, bool isFirst) const {
   

    POINTER_SIZE_INT offset_step = sizeof(POINTER_SIZE_INT);
#ifdef _EM64T_
    if (itraceMethodExitString!=NULL){
        Log::cat_rt()->out()<<"__UNWIND__:"
            <<(itraceMethodExitString!=(const char*)1?itraceMethodExitString:"")
            <<"; unwound from EIP="<<(void*)*context->p_rip
            <<::std::endl;
    }

    context->rsp += stackDepth;
    assert((context->rsp & 0xf) == 0x8);

    POINTER_SIZE_INT offset = context->rsp;
    context->p_rip = (POINTER_SIZE_INT *) (offset);

    offset += icalleeOffset;

    if(stackDepth != 0) {
        if(getRegMask(RegName_R15) & icalleeMask) {
            context->p_r15 = (POINTER_SIZE_INT *)  offset;
            offset += offset_step;
        }
        if(getRegMask(RegName_R14) & icalleeMask) {
            context->p_r14 = (POINTER_SIZE_INT *)  offset;
            offset += offset_step;
        }
        if(getRegMask(RegName_R13) & icalleeMask) {
            context->p_r13 = (POINTER_SIZE_INT *)  offset;
            offset += offset_step;
        }
        if(getRegMask(RegName_R12) & icalleeMask) {
            context->p_r12 = (POINTER_SIZE_INT *)  offset;
            offset += offset_step;
        }
        if(getRegMask(RegName_RDI) & icalleeMask) {
            context->p_rdi = (POINTER_SIZE_INT *)  offset;
            offset += offset_step;
        }
        if(getRegMask(RegName_RSI) & icalleeMask) {
            context->p_rsi = (POINTER_SIZE_INT *)  offset;
            offset += offset_step;
        }
        if(getRegMask(RegName_RBP) & icalleeMask) {
            context->p_rbp = (POINTER_SIZE_INT *)  offset;
            offset += offset_step;
        }
        if(getRegMask(RegName_RBX) & icalleeMask) {
            context->p_rbx = (POINTER_SIZE_INT *)  offset;
        }
    }
    context->rsp += offset_step; //IP register size
#else
    if (itraceMethodExitString!=NULL){
        Log::cat_rt()->out()<<"__UNWIND__:"
            <<(itraceMethodExitString!=(const char*)1?itraceMethodExitString:"")
            <<"; unwound from EIP="<<(void*)*context->p_eip
            <<::std::endl;
    }

    context->esp += stackDepth;

    U_32 offset = context->esp;
    context->p_eip = (POINTER_SIZE_INT *) offset;

    offset += icalleeOffset;
    if(stackDepth != 0) {
        if(getRegMask(RegName_EDI) & icalleeMask) {
            context->p_edi = (POINTER_SIZE_INT *)  offset;
            offset += offset_step;
        }
        if(getRegMask(RegName_ESI) & icalleeMask) {
            context->p_esi = (POINTER_SIZE_INT *)  offset;
            offset += offset_step;
        }
        if(getRegMask(RegName_EBP) & icalleeMask) {
            context->p_ebp = (POINTER_SIZE_INT *)  offset;
            offset += offset_step;
        }
        if(getRegMask(RegName_EBX) & icalleeMask) {
            context->p_ebx = (POINTER_SIZE_INT *)  offset;
        }
    }
    context->esp += offset_step; //IP register size
#endif
}

POINTER_SIZE_INT* StackInfo::getRegOffset(const JitFrameContext* context, RegName reg) const
{
    assert(stackDepth >=0);
    if(calleeSaveRegsMask & getRegMask(reg)) { //callee save regs
        //regnames are hardcoded -> unwind() has hardcoded regs too.
        //return register offset for previous stack frame. 
        //MUST be called before unwind()
        switch(reg) {
#ifdef _EM64T_
            case RegName_R15:
                return context->p_r15;
            case RegName_R14:
                return context->p_r14;
            case RegName_R13:
                return context->p_r13;
            case RegName_R12:
                return context->p_r12;
            case RegName_RBP:
                return context->p_rbp;
            case RegName_RBX:
                return context->p_rbx;
#ifdef _WIN64
            case RegName_RSI:
                return context->p_rsi;
            case RegName_RDI:
                return context->p_rdi;
#endif
#else
            case RegName_ESI:
                return context->p_esi;
            case RegName_EDI:
                return context->p_edi;
            case RegName_EBP:
                return context->p_ebp;
            case RegName_EBX:
                return context->p_ebx;
#endif
        default:
        assert(0);
        return NULL;
        }
    } else { //caller save regs
        assert(0);
        VERIFY_OUT("Caller save register requested!");
        exit(1);
    }
}

void StackInfo::fixHandlerContext(JitFrameContext* context)
{
#ifdef _EM64T_
    if (itraceMethodExitString!=NULL){
        Log::cat_rt()->out()<<"__CATCH_HANDLER__:"
            <<(itraceMethodExitString!=(const char*)1?itraceMethodExitString:"")
            <<"; unwound from EIP="<<(void*)*context->p_rip
            <<::std::endl;
    }
    context->rsp -= frameSize - stackDepth;
#else
    if (itraceMethodExitString!=NULL){
        Log::cat_rt()->out()<<"__CATCH_HANDLER__:"
            <<(itraceMethodExitString!=(const char*)1?itraceMethodExitString:"")
            <<"; unwound from EIP="<<(void*)*context->p_eip
            <<::std::endl;
    }
    context->esp -= frameSize - stackDepth;
#endif
}

void StackInfo::registerInsts(IRManager& irm) 
{
    MethodDesc& md = irm.getMethodDesc();
    if (!md.isStatic()) {
#ifdef _EM64T_
        if ((md.isSynchronized() || md.isParentClassIsLikelyExceptionType())) {
            EntryPointPseudoInst * entryPointInst = irm.getEntryPointInst();
            offsetOfThis = (U_32)entryPointInst->thisOpnd->getMemOpndSubOpnd(MemOpndSubOpndKind_Displacement)->getImmValue();
        } else {
            offsetOfThis = 0;
        }
#else
        EntryPointPseudoInst * entryPointInst = irm.getEntryPointInst();
        offsetOfThis = (U_32)entryPointInst->getOpnd(0)->getMemOpndSubOpnd(MemOpndSubOpndKind_Displacement)->getImmValue();
#endif
    }
    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->getFirstInst(); inst!=NULL; inst=inst->getNextInst()){
                if(inst->getMnemonic() == Mnemonic_CALL) {
                    (*stackDepthInfo)[(POINTER_SIZE_INT)inst->getCodeStartAddr()+inst->getCodeSize()]=
                        StackDepthInfo(((CallInst *)inst)->getCallingConventionClient().getCallingConvention()->getCalleeSavedRegs(OpndKind_GPReg).getMask(), 
                        inst->getStackDepth(),
                        inst->getCodeSize());
                } 
            }
        }
    }
    hashTableSize = (U_32)stackDepthInfo->size();
}

void StackInfo::setMethodExitString(IRManager& irm)
{
    ConstantAreaItem * cai=(ConstantAreaItem *)irm.getInfo("itraceMethodExitString");
    if (cai!=NULL){
        itraceMethodExitString=(const char*)cai->getAddress();
        if (itraceMethodExitString==NULL)
            itraceMethodExitString=(const char*)1;
    }
}


}} //namespace