/*
 *  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 Vyacheslav P. Shakin
 */

#include "Ia32InternalTrace.h"
#include "Log.h"
#include "Ia32Printer.h"
#include "Ia32GCMap.h"

namespace Jitrino
{
namespace Ia32{

//========================================================================================
// class InternalTrace
//========================================================================================

static ActionFactory<InternalTrace> _itrace("itrace");

//_________________________________________________________________________________________________
static inline void m_assert(bool cond)  {
#ifdef _DEBUG
        assert(cond);
#else
    #ifdef _WIN32 // any windows
        if(!cond) {
            DebugBreak();
        }
    #endif
#endif    
    }

static MemoryManager mm("printRuntimeOpndInternalHelper");
static TypeManager *tm = NULL;
void __stdcall methodEntry(const char * methodName, U_32 argInfoCount, CallingConvention::OpndInfo * argInfos)
{

    JitFrameContext context;
#ifdef _EM64T_
    context.rsp=(POINTER_SIZE_INT)(&methodName+sizeof(POINTER_SIZE_INT)); // must point to the beginning of incoming stack args
#else
    context.esp=(POINTER_SIZE_INT)(&methodName+sizeof(POINTER_SIZE_INT)); // must point to the beginning of incoming stack args
#endif
    ::std::ostream & os=Log::cat_rt()->out(); 
    os<<"__METHOD_ENTRY__:"<<methodName<<::std::endl;
    os<<"\t(";
    printRuntimeArgs(os, argInfoCount, argInfos, &context);
    os<<")"<<::std::endl;

    if (tm == NULL) {
        tm = new (mm) TypeManager(mm); tm->init();
    }
    for (U_32 i=0; i<argInfoCount; i++){
        CallingConvention::OpndInfo & info=argInfos[i];
        U_32 cb=0;
        U_8 arg[4*sizeof(U_32)]; 
        for (U_32 j=0; j<info.slotCount; j++){
            if (!info.isReg){
#ifdef _EM64T_
                *(POINTER_SIZE_INT*)(arg+cb)=((POINTER_SIZE_INT*)context.rsp)[info.slots[j]];
#else
                *(U_32*)(arg+cb)=((U_32*)context.esp)[info.slots[j]];
#endif
                cb+=sizeof(U_32);
            }else{
                m_assert(info.isReg);
                m_assert(0);                    
            }   
        }
        if (Type::isObject((Type::Tag)info.typeTag)){
            GCMap::checkObject(*tm, *(const void**)(const void*)arg);
        }
    }
}

//____________________________ _____________________________________________________________________
void __stdcall methodExit(const char * methodName)
{
    ::std::ostream & os=Log::cat_rt()->out();
    os<<"__METHOD_EXIT__:"<<methodName<<::std::endl;
}

//_________________________________________________________________________________________________
void __stdcall fieldWrite(const void * address)
{   
    ::std::ostream & os=Log::cat_rt()->out();
    os<<"__FIELD_WRITE__:"<<address<<" at "<<*(void**)(&address-1)<<::std::endl;
    void * heapBase = VMInterface::getHeapBase();
    void * heapCeiling = VMInterface::getHeapCeiling();
    if (address<heapBase || address>=heapCeiling){
        os<<"PROBABLY STATIC OR INVALID ADDRESS. DYNAMIC ADDRESSES MUST BE IN ["<<heapBase<<","<<heapCeiling<<")"<<::std::endl;
    }
}   

//_________________________________________________________________________________________________
void InternalTrace::runImpl()
{
    MemoryManager mm("InternalTrace");

    irManager->registerInternalHelperInfo("itrace_method_entry", IRManager::InternalHelperInfo((void*)&methodEntry, &CallingConvention_STDCALL));
    irManager->registerInternalHelperInfo("itrace_method_exit", IRManager::InternalHelperInfo((void*)&methodExit, &CallingConvention_STDCALL));
    irManager->registerInternalHelperInfo("itrace_field_write", IRManager::InternalHelperInfo((void*)&fieldWrite, &CallingConvention_STDCALL));

    char methodFullName[0x1000]="";
    MethodDesc & md=irManager->getMethodDesc();
    strcat(methodFullName, md.getParentType()->getName());
    strcat(methodFullName, ".");
    strcat(methodFullName, md.getName());
    strcat(methodFullName, " ");
    strcat(methodFullName, md.getSignatureString());

    Opnd * methodNameOpnd=irManager->newInternalStringConstantImmOpnd(methodFullName);
    irManager->setInfo("itraceMethodExitString", methodNameOpnd->getRuntimeInfo()->getValue(0));

    Node* prolog=irManager->getFlowGraph()->getEntryNode();

    Inst * inst=(Inst*)prolog->getFirstInst();
    if (inst->hasKind(Inst::Kind_EntryPointPseudoInst)){
        EntryPointPseudoInst * entryPointPseudoInst = (EntryPointPseudoInst *)inst;
        entryPointPseudoInst->getCallingConventionClient().finalizeInfos(Inst::OpndRole_Def, CallingConvention::ArgKind_InArg);
        const StlVector<CallingConvention::OpndInfo> & infos=((const EntryPointPseudoInst *)entryPointPseudoInst)->getCallingConventionClient().getInfos(Inst::OpndRole_Def);
        Opnd * argInfoOpnd=irManager->newBinaryConstantImmOpnd((U_32)infos.size()*sizeof(CallingConvention::OpndInfo), &infos.front());
        Opnd * args[3]={ methodNameOpnd, 
            irManager->newImmOpnd(irManager->getTypeManager().getInt32Type(), infos.size()), 
            argInfoOpnd,
        };
        Inst * internalTraceInst=irManager->newInternalRuntimeHelperCallInst("itrace_method_entry", 3, args, NULL);
        internalTraceInst->insertBefore(inst);
    }else{
        Opnd * args[3]={ methodNameOpnd, 
            irManager->newImmOpnd(irManager->getTypeManager().getInt32Type(), 0), 
            irManager->newImmOpnd(irManager->getTypeManager().getUnmanagedPtrType(irManager->getTypeManager().getIntPtrType()), 0),
        };
        Inst * internalTraceInst=irManager->newInternalRuntimeHelperCallInst("itrace_method_entry", 3, args, NULL);
        prolog->prependInst(internalTraceInst);
    }

    const Edges& inEdges = irManager->getFlowGraph()->getExitNode()->getInEdges();
    for (Edges::const_iterator ite = inEdges.begin(), ende = inEdges.end(); ite!=ende; ++ite) {
        Edge* edge = *ite;
        if (irManager->isEpilog(edge->getSourceNode())) {
            Node* epilog = edge->getSourceNode();
            Inst * retInst=(Inst*)epilog->getLastInst();
            assert(retInst->hasKind(Inst::Kind_RetInst));
            Opnd * args[1]={ methodNameOpnd };
            Inst * internalTraceInst=irManager->newInternalRuntimeHelperCallInst("itrace_method_exit", 1, args, NULL);
            internalTraceInst->insertBefore(retInst);
        }
    }

#ifdef IA32_EXTENDED_TRACE
    const Nodes& nodes = irManager->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_MOV){
                    Opnd * dest=inst->getOpnd(0);
                    if (dest->isPlacedIn(OpndKind_Memory) && dest->getMemOpndKind()==MemOpndKind_Heap){
                        Opnd * opnd=irManager->newOpnd(Type::UnmanagedPtr);
                        Inst* newIns = irManager->newInst(Mnemonic_LEA, opnd, dest);
                        newIns->insertBefore(inst);
                        Opnd * args[1]={ opnd };
                        newIns = irManager->newInternalRuntimeHelperCallInst("itrace_field_write", 1, args, NULL);
                        newIns->insertBefore(inst);
                    }
                }
            }
        }
    }
#endif
}

}}; //namespace Ia32