/*
 *  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 Implementation of tracing and logging utilities.
 */
#include "trace.h"
#include "compiler.h"

#include "../shared/mkernel.h"
#include "open/vm_class_manipulation.h"
#include "open/vm_ee.h"
#include "jit_intf.h"

#ifdef _WIN32
    #include <windows.h>
    #define snprintf    _snprintf
#else
    #include <dlfcn.h>
#endif // defined(_WIN32)

#include <stdio.h>
#include <stdarg.h>
#include "enc.h"
#include "Log.h"


namespace Jitrino
{
namespace Jet
{

unsigned g_tbreak_id = NOTHING;


/**
 * @defgroup LWDIS Disassembling routine for Jitrino.JET
 *
 * Jitrino.JET does not include disassembler. Instead, it may call 
 * external disassembling routine provided via exported function in 
 * dynamic library.
 *
 * To add such possibility, the library must export \e stdcall (where 
 * applicable) routine with the given signature.
 * 
 * The library must be named lwdis (which is lwdis.dll on Windows and 
 * <b>lib</b>lwdis.so on Linux). The library must be accessible via regular
 * library loading routines. On Windows it's normally PATH, System32 or 
 * application main module's folder. On Linux it's LD_LIBRARY_PATH.
 * 
 * Also, on Linux an attempt will be made to load the library from the 
 * application main module's folder first (regardless of LD_LIBRARY_PATH).
 *
 * lwdis stands for <b>l</b>ight-<b>w</b>eight <b>dis</b>assembler.
 * 
 * @see DISFUNC
 * @{
 * @}
 */
/**
 * @brief Disassembling function prototype.
 * 
 * @param[in] kode - code buffer to disassemble
 * @param[out] buf - buffer to write disassembled string into
 * @param buf_len - max length of the \c buf
 * @return length of disassembled instruction, or 0 to indicate error.
 * @see LWDIS
 */
typedef unsigned (*DISFUNC)(const char *kode, char *buf, unsigned buf_len);


/**
 * @brief Returns directory of currently running module, ended with file 
 *        separator.
 *
 * The function returns path to a directory, where the currently running 
 * module is located. The path guaranteed to end with file separator for 
 * current platform (that is '/' on Linux and '\\' on Windows).
 *
 * The function never fails. If it fails to find true path for the module, 
 * it returns a path pointing to current directory - './' or '.\\'.
 *
 * The function always returns the same address which points to internal 
 * static buffer. The buffer get initialized once, on the first call. 
 *
 * @note If called from within dynamic library, the function returns path
 *       for the 'main' executable module, not for the library itself.
 * 
 * @return directory of currently running module, ended with file separator
 */
const char * get_exe_dir(void)
{
#ifdef PLATFORM_POSIX
    static char buf[PATH_MAX+1];
    static const char FSEP = '/';
#else
    static char buf[_MAX_PATH+1];
    static const char FSEP = '\\';
#endif // ~PLATFORM_POSIX
    
    static bool path_done = false;
    if (path_done) {
        return buf;
    }
    
#ifdef PLATFORM_POSIX
    static const char self_path[] = "/proc/self/exe";
    // Resolve full path to module
    memset(buf, 0, sizeof(buf));
    if (readlink(self_path, buf, sizeof(buf)-1) < 0) {
#else
    if (!GetModuleFileName(NULL, buf, sizeof(buf))) {
#endif
        // Something wrong happened. Trying last resort path.
        // buf <= "./"
        buf[0] = '.'; buf[1] = FSEP; buf[2] = '\0';
    }
    else {
        // Extract directory path
        char * slash = strrchr(buf, FSEP);
        if (NULL == slash) { // Huh ? How comes ?
            // Trying last resort path.
            // buf <= "./"
            buf[0] = '.'; buf[1] = FSEP; buf[2] = '\0';
        }
        else {
            *(slash+1) = '\0';
        }
    }
    path_done = true;
    return buf;
}

void dbg(const char *frmt, ...)
{
    /* due to PMF integration
    static FILE *fout = fopen(LOG_FILE_NAME, "w");
    assert(fout != NULL);
    va_list valist;
    va_start(valist, frmt);
    vfprintf(fout, frmt, valist);
    fflush(fout);
    */
    char buf[1024];
    va_list valist;
    va_start(valist, frmt);
    vsnprintf(buf, sizeof(buf)-1, frmt, valist);
    LogStream& log = Log::log(LogStream::CT);
    log.printf(buf);
    log.flush();
}

/* due to PMF integration
static FILE *rtf = NULL;
static Mutex rtf_mutex;
*/
static int cnt = 0;
static int depth = 0;

void dbg_rt(const char * frmt, ...) 
{
    char buf[1024];
    va_list valist;
    va_start(valist, frmt);
    int len = vsnprintf(buf, sizeof(buf)-1, frmt, valist);
    
    if (buf[len-1] < ' ') {
        buf[len-1] = ' ';
    }
    if (buf[len-2] < ' ') {
        buf[len-2] = ' ';
    }
    dbg_rt_out(buf);
}

void __stdcall dbg_rt_out(const char *msg)
{
    /* due to PMF integration
    if (rtf == NULL) {
        rtf_mutex.lock();
        rtf = fopen(RUNTIME_LOG_FILE_NAME, "w");
        rtf_mutex.unlock();
        assert(rtf);
    }
    */
    ++cnt;
    if (!strncmp(msg, "enter", 5)) {
        ++depth;
    }
    // print out:
    // [call depth] message <total count>
    // precede the whole string with several spaces, so elements 
    // with big differences in the depth will be visually separated
    /* due to PMF integration
    fprintf(rtf, "%*c [%u] %s <%u>\n", depth%10, ' ', depth, msg, cnt);
    fflush(rtf);
    */
    char buf[1024*5];
    snprintf(buf, sizeof(buf)-1, "%*c [%u] %s <%u>\n", 
             depth%10, ' ', depth, msg, cnt);
    LogStream& log = Log::log(LogStream::RT);
    log.printf(buf);
    log.flush();
        
    if (!strncmp(msg, "exit", 4)) {
        --depth;
    }
    if (depth<0) {
        depth = 0;
    }
    if (g_tbreak_id != NOTHING && g_tbreak_id == (unsigned)cnt) {
        Encoder::debug();
    }
}

/**
 * @brief Returns a pointer to a disassembling function.
 * @return - pointer to disassembling function, or NULL if disassembling 
 *           is not supported/presented.
 * @todo document lwdis
 */
static DISFUNC get_disfunc(void)
{
#if !defined(PLATFORM_POSIX)
    static HMODULE hDll = LoadLibrary("lwdis.dll");
    static void *disfunc =
    hDll == NULL ? NULL : GetProcAddress(hDll, "disasm");
#else // if !platform_posix
    static bool load_done = false;
    static void *disfunc = NULL;
    if (!load_done) {
        char buf[PATH_MAX+1];
        snprintf(buf, sizeof(buf), "%sliblwdis.so", get_exe_dir());
        void * handle = dlopen(buf, RTLD_NOW);
        // An access with full path failed - let's try LD_LIBRARY_PATH.
        if (handle==NULL) {
            handle = dlopen("liblwdis.so", RTLD_NOW);
        }
        disfunc = handle == NULL ? NULL : dlsym(handle, "disasm");
        load_done = true;
    }
#endif
    return (DISFUNC)disfunc;
}

static ::std::string toStr(int i)
{
    char buf[20];
    snprintf(buf, sizeof(buf)-1, "%d", i);
    return buf;
}

::std::string CodeGen::toStr2(const Val& s, bool is_stack) const
{
    ::std::string str;
    if (false && s.jt() == jvoid) {
        str = "[x]";
        return str;
    }
    str += "[";

    if (s.has(VA_NOT_NEG)) {
        str += '+';
    };
    if (s.jt() != jvoid) {
        str += jtypes[s.jt()].name;
    }
    
    if (s.is_imm()) {
        str += ",imm=";
        char buf[50] = {0};
        if (s.jt()<=i32) { snprintf(buf, sizeof(buf), "%d(0x%X)", s.ival(), s.ival()); }
        if (s.jt()==flt32) { snprintf(buf, sizeof(buf), "%g", (double)s.fval()); }
        if (s.jt()==dbl64) { snprintf(buf, sizeof(buf), "%g", s.dval()); }
        if (s.jt()==jobj) { snprintf(buf, sizeof(buf), "%p", s.pval()); }
        if (s.jt()==i64) {
            if (is_big(i64)) {
                snprintf(buf, sizeof(buf), "%d(0x%X)", s.ival(), s.ival());
            }
            else {
                snprintf(buf, sizeof(buf), "%"FMT64"d(0x%"FMT64"X)", s.lval(), s.lval());
            }
        }
        str += buf;
        if (s.caddr() != NULL) {
            snprintf(buf, sizeof(buf), "[@%p]", s.caddr());
            str += buf;
        }
    }
    else if (s.is_reg()) {
        str += "@";
        str += Encoder::to_str(s.reg());
    }
    else {
        assert(s.is_mem());
        int l = vvar_idx(s);
        if (s.is_dummy()) {
            str += "----";
        }
        if (is_stack && l != -1) {
            str += "@var#" + toStr(l);
        }
        else if (vis_stack(s) && is_stack) {
            // no op - do not printout stack's offset
        }
        else if (l != -1 && !is_stack) {
            // no op - do not printout local's offset
        }
        else {
            str += "@";
            str += Encoder::to_str(s.base(), s.disp(), s.index(), s.scale());
        }
    }
        
    if (s.has(VA_NZ)) {
        str += ",nz";
    }
    
    str += "]";
    return str;
}

::std::string trim(const char *p) {
    const char *start = NULL, *end = NULL;
    for (const char *pp = p; *pp; pp++) {
        if (!isspace(*pp)) {
            if (start == NULL) {
                start = pp;
            }
            end = pp;
        }
    }
    ::std::string s;
    if (!start) {
        return s;
    }
    s.assign(start, end - start + 1);
    return s;
}

void dump_frame(const JitFrameContext* ctx, const MethodInfoBlock& info)
{
    assert(false); // obsolete, need update
    StackFrame sframe(info.get_num_locals(),
                      info.get_stack_max(), 
                      info.get_in_slots());
    // Not yet implemented
    assert(!(info.get_flags() & JMF_SP_FRAME));
    
    void *** pbp = devirt(bp, ctx);
    char * bp_val = (char*)(**pbp);
    
    dbg_rt("****************************************");
#define PRN(nam, frmt, type, meth_nam)  \
    dbg_rt(#nam "= " #frmt "\n", *(type*)(bp_val+sframe.meth_nam()))
    
    PRN(retIP, %p, void*, ret);
    PRN(info_gc_stack_depth, %d, int, info_gc_stack_depth);
    PRN(info_gc_locals, %d, int, info_gc_locals);
    PRN(thiz, %p, void*, thiz);
    
    unsigned num_locals = info.get_num_locals();
    for (unsigned i=0; i<num_locals; i++) {
        //dbg_rt("local#%d = %p (%d)\n", i, )
    }
    
#undef PRN
    //int ret(void) const
    //unsigned size(void) const
    //int spill(unsigned i) const
    //int (void) const
    //int (void) const
    //int info_gc_args(void) const
    //int info_gc_stack(void) const
    //int info_gc_regs(void) const
    //int (void) const
    //int scratch(void) const
    //int scratch(AR ar) const
    //int dbg_sp(void) const
    //int local(unsigned i) const
    //int stack_bot(void) const
    //int stack_slot(unsigned Val) const
    //int stack_max(void) const
    //int native_stack_bot(void) const
#if 0
    unsigned num_locals = rtinfo.get_num_locals();
    unsigned stack_max = rtinfo.get_stack_max();

    unsigned stack_depth = *(p + stackframe.info_gc_stack_depth());

    dbg("EBP             = %p\n", p);
    dbg("NUM_LOCALS      = %d\n", num_locals);
    dbg("MAX_STACK_DEPTH = %d\n", stack_max);
    dbg("NUM_IN_SLOTS    = %d\n", rtinfo.get_in_slots());
    dbg("GC_STACK_DEPTH  = %d\n", stack_depth);
    dbg("counted.esp     = %X (*ESP=%d/%X)\n",
    p + stackframe.native_stack_bot(),
    *(int *) (p + stackframe.native_stack_bot()),
    *(int *) (p + stackframe.native_stack_bot()));

    dbg("GC.Locals: %X @ %X =>", *(p + stackframe.info_gc_locals()),
    p + stackframe.info_gc_locals());
    for (unsigned i = 0; i < num_locals; i++) {
        unsigned bit = bit_no(i);
        unsigned off = word_no(i);
        //unsigned data = *(p+frame.info_gc_locals() + off);
        bool b = 0 != ((1 << bit) & *(p + stackframe.info_gc_locals() + off));
        dbg(b ? "*" : ".");
        if (i && !(i % 5)) {
            dbg(" | ");
        }
        if (i > 65536) {
            assert(false);
        }
    }
    dbg("\n");
    dbg("GC.Stack:       =>");
    for (unsigned i = 0; i < stack_depth; i++) {
        unsigned bit = bit_no(i);
        unsigned off = word_no(i);
        //unsigned data = *(p+frame.info_gc_stack() + off);
        bool b = (1 << bit) & *(p + stackframe.info_gc_stack() + off);
        dbg(b ? "*" : ".");
        if (i && !(i % 5)) {
            dbg(" | ");
        };
        if (i > 65536) {
            assert(false);
        }
    }
    dbg("\n");
    //
    //
    dbg("===========================\n");
    for (unsigned i = 0; i < num_locals; i++) {
        dbg("local.%d = %d (%X)\n", 
                i, *(p + stackframe.local(i)), *(p + stackframe.local(i)));
    }
    dbg("===========================\n");
    dbg("note: the stack is printed from bottom (=0) to top(=max_stack)\n");
    for (unsigned i = 0; i < stack_depth; i++) {
        dbg("(%d) = %d (%X)\n", 
                i, 
                *(p + stackframe.native_stack_bot() + i), 
                *(p + stackframe.native_stack_bot() + i));
    }
    dbg("===========================\n");
#endif
}

void Compiler::dbg_trace_comp_start(void)
{
    // start ; counter ; klass::method ; bytecode size ; signature
    dbg("start |%5d| %s::%s | bc.size=%d | %s\n",
        m_methID,
        class_get_name(m_klass), method_get_name(m_method),
        method_get_bytecode_length(m_method),
        method_get_descriptor(m_method));
}

void Compiler::dbg_trace_comp_end(bool success, const char * reason)
{
    // end   ; counter ; klass::method ; 
    //          [REJECTED][code start ; code end ; code size] ; signature

    dbg("end   |%5d| %s::%s | ", 
        m_methID, class_get_name(m_klass), method_get_name(m_method));
        
    if (success) {
        unsigned size = method_get_code_block_size_jit(m_method, m_hjit);
        void * start = size ? method_get_code_block_jit(m_method, m_hjit) : NULL;

        dbg("code.begin=%p | code.end=%p | code.size=%d",
             start, (char*)start + size, size);
    }
    else {
        dbg("[REJECTED:%s]", reason);
    }
    dbg("| %s\n", method_get_descriptor(m_method));
}


::std::string Compiler::toStr(const JInst & jinst, bool show_names)
{
    char tmp0[1024] = { 0 }, tmp1[1024] = { 0 };
    
    if (jinst.op0 != (int) NOTHING) {
        const char * lpClass = NULL;
        const char * lpItem = NULL;
        const char * lpDesc = NULL;
        if (show_names) {
            const JavaByteCodes opc = jinst.opcode;
            
            switch(opc) {
            case OPCODE_INVOKESPECIAL:
            case OPCODE_INVOKESTATIC:
            case OPCODE_INVOKEVIRTUAL:
            case OPCODE_INVOKEINTERFACE:
            case OPCODE_GETFIELD:
            case OPCODE_PUTFIELD:
            case OPCODE_GETSTATIC:
            case OPCODE_PUTSTATIC:
                lpClass = class_cp_get_entry_class_name(m_klass, jinst.op0);
                lpItem = class_cp_get_entry_name(m_klass, jinst.op0);
                lpDesc = class_cp_get_entry_descriptor(m_klass, jinst.op0);
                break;
            case OPCODE_NEW:
            case OPCODE_INSTANCEOF:
            case OPCODE_CHECKCAST:
                lpClass = class_cp_get_class_name(m_klass, jinst.op0);
                break;
            default: break;
            }
        }
        if (lpClass || lpItem || lpDesc) {
            snprintf(tmp0, sizeof(tmp0)-1, "%-2d {%s%s%s %s}",
                jinst.op0, 
                lpClass ? lpClass : "", lpClass ? "::" : "",
                lpItem ? lpItem : "", 
                lpDesc ? lpDesc : "");
        }
        else if (jinst.is_branch()) {
            sprintf(tmp0, "->%d<-", jinst.get_target(0));
        }
        else {
            sprintf(tmp0, "%-2d", jinst.op0);
        }
    }

    if (jinst.op1 != (int) NOTHING) {
        sprintf(tmp1, " %d ", jinst.op1);
    }
    
    char total[10240] = {0}, buf0[10240] = {0}, buf1[100] = {0};
    snprintf(buf0, sizeof(buf0)-1, "%c%2d) %-15s %-6s %-6s",
        jinst.flags & OPF_STARTS_BB ? '@' : ' ', 
        jinst.pc, instrs[jinst.opcode].name, tmp0, tmp1);
        
    if (jinst.ref_count != 1 && jinst.ref_count != 0) {
        //snprintf(buf1, sizeof(buf1)-1, "| id=%2d, rc=%d", jinst.id, jinst.ref_count);
        snprintf(buf1, sizeof(buf1)-1, "| rc=%d", jinst.ref_count);
    }
    else {
        //snprintf(buf1, sizeof(buf1)-1, "| id=%2d", jinst.id);
        //snprintf(buf1, sizeof(buf1)-1, "| id=%2d", jinst.id);
    }
    snprintf(total, sizeof(total)-1, "%-40s %s", buf0, buf1);
    return ::std::string(total);
}

void Compiler::dbg_dump_bbs(void)
{
    static const char *bb_delim = "======================================\n";

    const unsigned bc_size = m_infoBlock.get_bc_size();
    for (unsigned pc=0; pc<bc_size; pc++) {
        JInst& jinst = m_insts[pc];
        if (jinst.id == 0) continue;
        bool bb_head = jinst.flags & OPF_STARTS_BB;
        bool jsr_target = false;
        if (bb_head) {
            assert(m_bbs.find(jinst.pc) != m_bbs.end());
            dbg(bb_delim);
            jsr_target = m_bbs[jinst.pc].jsr_target;
        }
        if (bb_head) {
            dbg("ref.count=%d, %s\n", jinst.ref_count, 
                                      jsr_target ? "#JSR#" : "");
        }
        dbg("%s\n", toStr(jinst, true).c_str());
    }
    dbg(bb_delim);
}

void CodeGen::dbg_dump_state(const char *name, BBState * pState)
{
    JFrame& jframe = pState->jframe;
    dbg("\n;;State: %s\n;;\n", name);
    //
    unsigned num_locals = jframe.num_vars();
    dbg(";; locals.total=%d\n;; ", num_locals);
    
    // Dump local variables first - by 5 in a row ...
    for (unsigned i = 0; i < num_locals; i++) {
        if (i && !(i % 5)) {
            dbg("\n;;  ");
        }
        Val& s = jframe.var(i);
        dbg(" %d)%s", i, toStr2(s, false).c_str());
        if (i>=128) {
            dbg("\ntoo many locals, enough to dump.\n");
            break;
        }
    }
    
    dbg("\n;;\n");
    // ... and stack after that
    dbg(";; stack.size=%d\n;;  ", jframe.size());
    for (unsigned i = 0; i < jframe.size(); i++) {
        //if (i && !(i % 5)) {
        //    dbg("\n;;  ");
        //}
        const Val& s = jframe.at(i);
        dbg(" %s", toStr2(s, true).c_str());
        dbg("\n;;  ");
    }
    if (m_bbstate == pState) {
        dbg("\n;;\n");
        dbg(";; regs: ");
        bool not_first = false;
        for (unsigned i=0; i<ar_num; i++) {
            AR ar = _ar(i);
            if (rrefs(ar) != 0 || rlocks(ar) != 0) {
                if (not_first) {
                    dbg(",");
                }
                if (rlocks(ar)!=0) { dbg(">"); }
                dbg("%s[%d]", Encoder::to_str(ar).c_str(), rrefs(ar));
                if (rlocks(ar)!=0) { dbg("<,%d", rlocks(ar)); }
                not_first = true;
            }
        }
    }
    dbg("\n;;\n");
}

void Compiler::dbg_dump_code(const char *code, unsigned length, 
                             const char *name)
{
    if (name != NULL) {
        dbg("; .%s.start\n", name);
    }

    DISFUNC disf = get_disfunc();
    if (disf != NULL) {
    for (unsigned i = 0; i < length; /**/) {
        char buf[1024];
        unsigned bytes = (disf) (code + i, buf, sizeof(buf));
        if (bytes==0) {
            // unknown instruction
            unsigned char b = *(unsigned char*)(code+i);
            dbg("\tdb 0x%x (%d, %c)\n", b, b, b<33 || b>127 ? '.' : b);
            i += 1; // cant be 0, or we'll fall into infinite loop
        }
        else {
            dbg("\t%s\n", buf);
            i += bytes;
        }
    }
    }
    else {
        // if disassembler shared library not present, simply 
        // dump out the code
        dbg("\t");
        for (unsigned i = 0; i < length; i++) {
            dbg(" %02X", (unsigned) (unsigned char) code[i]);
            unsigned pos = (i + 1) % 16;
            if (0 == pos) {
                // output by 16 bytes per line
                dbg("\n\t");
            }
            else if (7 == pos) {
                // additional space in the middle of the output
                dbg(" ");
            }
        }
    }
    dbg("\n");
    if (name != NULL) {
        dbg("; .%s.end\n", name);
    }
}

void Compiler::dbg_dump_code_bc(const char * code, unsigned codeLen)
{
    if (codeLen == 0) {
        dbg("no code\n");
        return;
    }
    unsigned pc = NOTHING;
    DISFUNC disf = get_disfunc();
    const char * first_inst = m_infoBlock.get_ip(0);
        
    for (unsigned i=0; i<codeLen; /**/) {
        const char * ip = code + i;
        unsigned tmp = m_infoBlock.get_pc(ip);
        if (ip>=first_inst && pc != tmp) {
            // we just passed to a new byte code instruction, print it out
            pc = tmp;
            JInst jinst;
            memset(&jinst, 0, sizeof(jinst));
            unsigned next_pc = fetch(pc, jinst);
            dbg(";; %s\n", toStr(jinst, true).c_str());
            // Dump all instructions that do have the same IP.
            // check whether we have a code for this instruction - read next
            // item and compare its IP. If they are the same, then 'jinst' 
            // represents an empty instruction with no real code - NOP, POP, 
            // etc. In this case, switch to the nearest instruction with a 
            // code.
            for(;next_pc<m_infoBlock.get_bc_size();) {
                const char * next_ip = m_infoBlock.get_ip(next_pc);
                if (next_ip != ip) {
                    break;
                }
                memset(&jinst, 0, sizeof(jinst));
                next_pc = fetch(next_pc, jinst);
                dbg(";; %s\n", toStr(jinst, true).c_str());
            }
        }
        if (disf) {
            char buf[1024];
            unsigned bytes = disf(code + i, buf, sizeof(buf));
            if (bytes==0) {
                // unknown instruction
                unsigned char b = *(unsigned char*)(code+i);
                dbg("0x%p\tdb 0x%x (%d, %c)\n", code+i, b, b, b<33 || b>127 ? '.' : b);
                i += 1; // cant be 0, or we'll fall into infinite loop
            }
            else {
                dbg("0x%p\t%s\n", code + i, buf);
                i += bytes;
            }
            
        }
        else {
            i += 1;
        }
    }
}

}
};  // ~namespace Jitrino::Jet