/* * 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 #endif #include #include #include #include #include /** * @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