/*
 *  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
 */
#include "compiler.h"
#include "trace.h"

#ifdef WIN32
#include <malloc.h>
#endif
#include <memory.h>
#include <assert.h>
#include <stdlib.h>

#include <open/vm_class_info.h>
#include <jit_import.h>

/**
 * @file
 * @brief CodeGen routines for PUSH/POP, LDC and LD/ST.
 */

namespace Jitrino {
namespace Jet {

void CodeGen::gen_ldc(void)
{
    jtype jtyp = to_jtype(class_cp_get_const_type(
                                m_klass, (unsigned short)m_curr_inst->op0));
    if (jtyp != jobj) { // if not loading String
        const void * p = class_cp_get_const_addr(m_klass, m_curr_inst->op0);
        assert(p);
        if (jtyp == dbl64 || jtyp == flt32) {
            gen_push(jtyp, p);
        }
        else if(jtyp == i64) {
            gen_push(*(jlong*)p);
        }
        else if(jtyp == i32) {
            gen_push(*(int*)p);
        }
        else if(jtyp == u16) {
            gen_push(*(unsigned short*)p);
        }
        else if(jtyp == i16) {
            gen_push(*(short*)p);
        }
        else {
            assert(jtyp == i8);
            gen_push(*(char*)p);
        }
        return;
    }
    assert(m_curr_inst->opcode != OPCODE_LDC2_W);
    gen_call_vm(ci_helper_oi, rt_helper_ldc_string, 0, m_klass, m_curr_inst->op0);
    gen_save_ret(ci_helper_oi);
    vstack(0).set(VA_NZ);
    m_bbstate->seen_gcpt = true;
}

void CodeGen::gen_push(int ival)
{
    vpush(Val(ival));
}

void CodeGen::gen_push(jlong lval)
{
    if (is_big(i64)) {
        vpush2(Val((jlong)lo32(lval)), Val((jlong)hi32(lval)));
    }
    else {
        vpush(Val(lval));
    }
}

void CodeGen::gen_push(jtype jt, const void *p)
{
    if (jt == dbl64) {
        vpush(Val(*(double*)p, p));
    }
    else if (jt == flt32) {
        vpush(Val(*(float*)p, p));
    }
    else {
        assert(jt==jobj);
        // This is for brand new 1.5's 'LDC object'.
        // The object loaded is marked as constant which can cross a call 
        // site, however must check with VM/GC guys whether this is indeed
        // true.
        // XXX: So, are the 'LDC object'-s pinned ?
        // For now, using conservative approach.
        vpush(Val(jobj, p)); // vpush(Val(jobj, p).long_live());
    }
}

void CodeGen::gen_pop(jtype jt)
{
    vpop();
}

void CodeGen::gen_pop2(void)
{
    jtype jt = m_jframe->top();
    if (is_wide(jt)) {
        vpop();
    }
    else {
        vpop();
        assert(!is_wide(m_jframe->top()));
        vpop();
    }
}

void CodeGen::gen_dup(JavaByteCodes opc)
{
    jtype jtop = m_jframe->top();

// Only need to take a special action if 's' is a stack item resides in 
// the stack memory area. If it points to 
// local/static/const/field/register/whatever then can simply duplicate it. 
#define COPY_SLOT(dst, src) \
    { \
    const Val& ssrc = vstack(src); \
    if (vis_stack(ssrc) && !ssrc.is_dummy()) { \
        vstack(src, true); \
    } \
    Val& sdst = vstack(dst); \
    rfree(sdst); \
    sdst = ssrc; \
    rref(sdst); \
    }
    
    if (opc == OPCODE_SWAP) {
        // stack: .. val1, val2 => val2, val1
        Val& val2 = vstack(0, vis_stack(0));
        rlock(val2);
        Val& val1 = vstack(1, vis_stack(1));
        runlock(val2);
        Val tmp = val1;
        val1 = val2;
        val2 = tmp;
        return;
    }
    
    if (opc == OPCODE_DUP) {
        // [.. val] => [.. val, val]
        vpush(jtop);
        COPY_SLOT(0, 1);
        return;
    }
    
    if (opc==OPCODE_DUP2) {
        // [.. val64] => [.. val64, val64]
        vpush(jtop);
        if (!is_wide(jtop)) {
            vpush(jtop);
        }
        COPY_SLOT(0, 2);
        COPY_SLOT(1, 3);
        return;
    }
    
    if (opc == OPCODE_DUP_X1) {
        // [..., value2, value1] => [.. value1, value2, value1]
        // 1. push(jtop)
        // result: val2, val1, typeof(val1)
        // 2. depth(0) = depth(1)
        // result: val2, val1, val1
        // 3. depth(1) = depth(2)
        // result: val2, val2, val1
        // 4. depth(2) = depth(0)
        // result: val1, val2, val1
        vpush(jtop);
        COPY_SLOT(0, 1);
        COPY_SLOT(1, 2);
        COPY_SLOT(2, 0);
        return;
    }
    
    // DUP_X2
    if (opc == OPCODE_DUP_X2) {
        // Form 1: .. val3, val2, val1 => val1, val3, val2, val1
        // Form 2: .. val2.hi, val2.lo, val1.32 =>  
        //                              ..val1, val2.hi, val2.lo, val1
        // form1:
        // 1. push(typeof(depth(0)))
        // result: val3, val2, val1, typeof(val1)
        // 2. depth(0) = depth(1)
        // result: val3, val2, val1, val1
        // 3. depth(1) = depth(2)
        // result: val3, val2, val2, val1
        // 4. depth(2) = depth(3)
        // result: val3, val3, val2, val1
        // 5. depth(3) = depth(0)
        // result: val1, val3, val2, val1
        vpush(jtop);
        COPY_SLOT(0, 1);
        COPY_SLOT(1, 2);
        COPY_SLOT(2, 3);
        COPY_SLOT(3, 0);
        return;
    }

    if (opc == OPCODE_DUP2_X1) {
        // Form 1: val3, val2, val1  => val2, val1, val3, val2, val1
        // Form 2: [..., val2.32, val1.64] => [.. val1, val2, val1]
        // A strategy:
        // 1. push(typeof(v1))
        // result: .. val2, val1.64, val1.64(unknown location)
        // 2. depth(0) = depth(2) ; depth(1) = depth(3)
        // result: .. val2, val1.64, val1.64
        // 3. depth(2) = depth(4) ; 
        // result: .. val2, zzz, val2, val1.64 
        //  zzz is former high part of val1
        // 4. depth(3) = depth(0)
        // result: .. val2, val1.lo, val2, val1.64 
        // 5. depth(4) = depth(1)
        // result: .. val1.hi, val1.lo, val2, val1.64 
        vpush(jtop);
        if (!is_wide(jtop)) {
            vpush(jtop);
        }
        COPY_SLOT(0, 2); COPY_SLOT(1, 3);
        COPY_SLOT(2, 4);
        COPY_SLOT(3, 0);
        COPY_SLOT(4, 1);
        return;
    }
    if (opc == OPCODE_DUP2_X2) {
        // [.. val2.64, val1.64] =>  [.. val1.64, val2.64, val1.64]
        //f1 .., val4, val3, val2, val1 => val2, val1, val4, val3, val2, val1
        //f2 .., val3, val2, val1 ..., val1, val3, val2, val1
        //f3 .., val3, val2, val1 ..., val2, val1, val3, val2, val1
        //f4 .., val2, val1 ..., val1, val2, val1
        // 
        // A strategy:
        // 1. push(any-wide-type)
        // result: val4, val3, val2, val1, xx, xx
        // 2. depth(0) = depth(2)
        // 3. depth(1) = depth(3)
        // result: val4, val3, val2, val1, val2, val1
        // 4. depth(2) = depth(4)
        // 5. depth(3) = depth(5)
        // result: val4, val3, val4, val3, val2, val1
        // 6. depth(4) = depth(0)
        // 7. depth(5) = depth(1)
        // result: val2, val1, val2, val1, val2, val1
        vpush(i64); // the type does not really matter
        // 2, 3
        COPY_SLOT(0, 2);
        COPY_SLOT(1, 3);
        // 4, 5
        COPY_SLOT(2, 4);
        COPY_SLOT(3, 5);
        // 6, 7
        COPY_SLOT(4, 0);
        COPY_SLOT(5, 1);
        return;
    }
    assert(false);
}


void CodeGen::gen_ld(jtype jt, unsigned idx)
{
    if (is_big(jt)) {
        Val vlo = vlocal(jt, idx, false);
        rlock(vlo);
        Val vhi = vlocal(jt, idx+1, false);
        vpush2(vlo, vhi);
        runlock(vlo);
    }
    else {
        Val& v = vlocal(jt, idx, false);
        vpush(v);
    }
}

void CodeGen::gen_st(jtype jt, unsigned idx)
{
    vvar_def(jt, idx);
    gen_gc_mark_local(jt, idx);
    //
    // v|s
    // -|-|-------------------------
    // r|m| move
    // r|i| move
    // r|r| move
    // m|m| allocate reg, then move
    // m|r| move
    // m|i| move
    //
    Val s0 = vstack(0);
    rlock(s0);
    Val& var = vlocal(jt, idx, true);
    runlock(s0);
    vunref(jt, var);
    if (var.is_mem() && s0.is_reg() && rrefs(s0.reg()) == 1) {
        // The local is on memory, though the stack item is on register
        vunref(jt, s0, 0);
        vassign(jt, idx, s0);
    }
    else {
        do_mov(var, s0);
    }
    var.attrs(s0.attrs());
    
    if (is_big(jt)) {
        //
        ++idx;
        //
        Val s0 = vstack(1);
        rlock(s0);
        Val& var = vlocal(jt, idx, true);
        runlock(s0);
        vunref(jt, var);
        if (var.is_mem() && s0.is_reg() &&  rrefs(s0.reg()) == 1) {
            // The local is on memory, though the stack item is on register
            vunref(jt, s0, 1);
            vassign(jt, idx, s0);
        }
        else {
            do_mov(var, s0);
        }
        var.attrs(s0.attrs());
    }
    vpop();
}


}}; // ~namespace Jitrino::Jet