| /* |
| * 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. |
| */ |
| |
| /** |
| * @file |
| * @brief Magics and WBs support for MMTk. |
| */ |
| |
| #include "compiler.h" |
| #include "enc_defs.h" |
| #include "enc.h" |
| |
| #include "open/vm_class_info.h" |
| #include "open/vm.h" |
| #include "jit_intf.h" |
| #include "VMMagic.h" |
| |
| #include <vector> |
| using std::vector; |
| |
| namespace Jitrino { |
| namespace Jet { |
| |
| |
| static size_t sizeof_jt(jtype jt) { |
| static size_t sizes[] = { |
| 1, //i8, |
| 2, //i16, |
| 2, //u16, |
| 4, //i32, |
| 8, //i64, |
| 4, //flt32, |
| 8, //dbl64, |
| sizeof(POINTER_SIZE_INT), //jobj, |
| sizeof(POINTER_SIZE_INT), //jvoid, |
| sizeof(POINTER_SIZE_INT), //jretAddr, |
| 0, //jtypes_count, |
| }; |
| size_t res= sizes[jt]; |
| assert(res >= 1 && res<=8 && (res%2==0 || res == 1)); |
| return res; |
| } |
| |
| /** creates new opnd with the specified type and generates move from old one to new one */ |
| static void vstack_replace_top_opnd(Compiler* c, jtype jt) { |
| Opnd src = c->vstack(0).as_opnd(); |
| Opnd dst(jt, c->valloc(jt)); |
| |
| size_t dstSize = sizeof_jt(dst.jt()); |
| size_t srcSize = sizeof_jt(src.jt()); |
| assert((srcSize==4 || srcSize == 8) && (dstSize == 4 || dstSize == 8)); |
| if (srcSize == dstSize) { //simple mov |
| c->mov(dst, src); |
| c->vpop(); //pop src |
| c->vpush(dst); |
| } else if (srcSize > dstSize) { //truncation |
| c->do_mov(dst, src); |
| c->vpop(); //lo&hi parts are popped with a single pop operation for i64 type |
| c->vpush(dst); //push result |
| } else { // expansion |
| assert(srcSize<dstSize); |
| c->do_mov(dst, src, true); //fill lower part -> dst |
| Opnd hi(jt, c->g_iconst_0); //fill hi part with 0 |
| c->vpop(); //pop old value |
| c->vpush2(dst, hi); //push new value |
| } |
| } |
| |
| bool Compiler::gen_magic(void) |
| { |
| const JInst& jinst = m_insts[m_pc]; |
| JavaByteCodes opkod = jinst.opcode; |
| |
| if (opkod != OPCODE_INVOKEVIRTUAL && |
| opkod != OPCODE_INVOKESTATIC && |
| opkod != OPCODE_INVOKESPECIAL) |
| { |
| return false; |
| } |
| |
| const char* kname = class_cp_get_entry_class_name(m_klass, (unsigned short)jinst.op0); |
| |
| if (!VMMagicUtils::isVMMagicClass(kname)) { |
| return false; |
| } |
| // This is a magic -> transform it |
| |
| const char* mname = class_cp_get_entry_name(m_klass, (unsigned short)jinst.op0); |
| |
| jtype magicType = iplatf; |
| |
| if (!strcmp(mname, "fromLong")) { |
| vstack_replace_top_opnd(this, magicType); |
| return true; |
| } |
| |
| if (!strcmp(mname, "toLong")) { |
| vstack_replace_top_opnd(this, i64); |
| return true; |
| } |
| return false; |
| |
| |
| /** Old IA32 implementation. This implementation is not GC safe, |
| it keeps all magic classes as objects and magics becomes a part of GC enumeration |
| This code must be refactored or removed |
| |
| |
| vector<jtype> args; |
| jtype retType; |
| bool is_static = opkod == OPCODE_INVOKESTATIC; |
| get_args_info(is_static, jinst.op0, args, &retType); |
| |
| // ADD, SUB, DIFF, etc - 2 args arithmetics |
| ALU oper = alu_count; |
| |
| if (!strcmp(mname, "add")) { oper = alu_add; } |
| else if (!strcmp(mname, "plus")) { oper = alu_add; } |
| else if (!strcmp(mname, "sub")) { oper = alu_sub; } |
| else if (!strcmp(mname, "minus")) { oper = alu_sub; } |
| else if (!strcmp(mname, "diff")) { oper = alu_sub; } |
| else if (!strcmp(mname, "or")) { oper = alu_or; } |
| else if (!strcmp(mname, "xor")) { oper = alu_xor; } |
| else if (!strcmp(mname, "and")) { oper = alu_and; } |
| if (oper != alu_count) { |
| Val& v0 = vstack(0, true); |
| Val& v1 = vstack(1, true); |
| Opnd newObj(jobj, valloc(jobj)); |
| mov(newObj, v1.as_opnd()); |
| alu(oper, newObj, v0.as_opnd()); |
| vpop(); |
| vpop(); |
| vpush(newObj); |
| return true; |
| } |
| |
| JavaByteCodes shiftOp = OPCODE_NOP; |
| if (!strcmp(mname, "lsh")) {shiftOp = OPCODE_ISHL;} |
| else if (!strcmp(mname, "rsha")) {shiftOp = OPCODE_ISHR;} |
| else if (!strcmp(mname, "rshl")) {shiftOp = OPCODE_IUSHR;} |
| |
| if (shiftOp != OPCODE_NOP) { |
| Opnd shiftAmount = vstack(0, false).as_opnd(i32); |
| shiftAmount = vstack(0, true).as_opnd(i32); |
| rlock(shiftAmount.reg()); |
| vpop(); |
| //changing type of obj opnd type to ia32 |
| vstack_replace_top_opnd(this, i32); |
| vpush(shiftAmount); |
| runlock(shiftAmount.reg()); |
| //processing as java bytecode and converting back to the obj type |
| gen_a(shiftOp, i32); |
| vstack_replace_top_opnd(this, jobj); |
| return true; |
| } |
| |
| if (!strcmp(mname, "not")) { |
| Opnd v1 = vstack(0, true).as_opnd(jobj); |
| rlock(v1.reg()); |
| Opnd v2(jobj, valloc(jobj)); |
| mov(v2, v1); |
| bitwise_not(v2); |
| runlock(v1.reg()); |
| vpop(); |
| vpush(v2); |
| return true; |
| } |
| |
| // |
| // EQ, GE, GT, LE, LT, sXX - 2 args compare |
| // |
| COND cm = cond_none; |
| if (!strcmp(mname, "EQ")) { cm = eq; } |
| if (!strcmp(mname, "equals")) { cm = eq; } |
| else if (!strcmp(mname, "NE")) { cm = ne; } |
| // unsigned compare |
| else if (!strcmp(mname, "GE")) { cm = ae; } |
| else if (!strcmp(mname, "GT")) { cm = above; } |
| else if (!strcmp(mname, "LE")) { cm = be;} |
| else if (!strcmp(mname, "LT")) { cm = below; } |
| // signed compare |
| else if (!strcmp(mname, "sGE")) { cm = ge; } |
| else if (!strcmp(mname, "sGT")) { cm = gt; } |
| else if (!strcmp(mname, "sLE")) { cm = le;} |
| else if (!strcmp(mname, "sLT")) { cm = lt; } |
| // |
| if (cm != cond_none) { |
| Opnd o1 = vstack(1, true).as_opnd(i32); |
| Opnd o2 = vstack(0, true).as_opnd(i32); |
| alu(alu_cmp, o1, o2); |
| vpop(); |
| vpop(); |
| Opnd boolResult(i32, valloc(i32)); |
| rlock(boolResult.reg()); |
| mov(boolResult, g_iconst_0); |
| cmovcc(cm, boolResult, vaddr(i32, &g_iconst_1)); |
| runlock(boolResult.reg()); |
| vpush(boolResult); |
| return true; |
| } |
| |
| // |
| // is<Smth> one arg testing |
| // |
| bool oneArgCmp = false; |
| int theConst = 0; |
| if (!strcmp(mname, "isZero")) { oneArgCmp = true; theConst = 0; } |
| else if (!strcmp(mname, "isMax")) { oneArgCmp = true; theConst = ~0; } |
| else if (!strcmp(mname, "isNull")) { oneArgCmp = true; theConst = 0; } |
| if (oneArgCmp) { |
| AR regVal = vstack(0, true).reg(); |
| rlock(regVal); |
| alu(alu_cmp, Opnd(jobj, regVal), theConst); |
| |
| //save the result |
| AR resultReg = valloc(i32); |
| rlock(resultReg); |
| mov(resultReg, Opnd(g_iconst_0)); |
| cmovcc(z, resultReg, vaddr(i32, &g_iconst_1)); |
| runlock(resultReg); |
| vpop(); |
| vpush(Opnd(i32, resultReg)); |
| |
| runlock(regVal); |
| return true; |
| } |
| |
| // |
| // fromXXX - static creation from something |
| // |
| if (strcmp(mname, "fromLong")) { |
| assert(0); |
| } |
| else if (!strcmp(mname, "fromIntSignExtend")) { |
| vstack_replace_top_opnd(this, jobj); |
| return true; |
| } |
| else if (!strcmp(mname, "fromIntZeroExtend")) { |
| vstack_replace_top_opnd(this, jobj); |
| return true; |
| } |
| else if (!strcmp(mname, "fromObject") || |
| !strcmp(mname, "toAddress") || |
| !strcmp(mname, "toObjectReference")) |
| { |
| vstack_replace_top_opnd(this, jobj); |
| return true; |
| } |
| |
| const char* msig = method_get_descriptor(meth); |
| // |
| // load<type> things |
| // |
| jtype jt = jvoid; |
| bool load = true; |
| bool has_offset = false; |
| |
| if (!strcmp(mname, "loadObjectReference")) { jt = jobj; } |
| else if (!strcmp(mname, "loadAddress")) { jt = jobj; } |
| else if (!strcmp(mname, "loadWord")) { jt = jobj; } |
| else if (!strcmp(mname, "loadByte")) { jt = i8; } |
| else if (!strcmp(mname, "loadChar")) { jt = u16; } |
| else if (!strcmp(mname, "loadDouble")) { jt = dbl64; } |
| else if (!strcmp(mname, "loadFloat")) { jt = flt32; } |
| else if (!strcmp(mname, "loadInt")) { jt = i32; } |
| else if (!strcmp(mname, "loadLong")) { jt = i64; } |
| else if (!strcmp(mname, "loadShort")) { jt = i16; } |
| else if (!strcmp(mname, "prepareWord")) { jt = i32; } |
| else if (!strcmp(mname, "prepareObjectReference")) { jt = jobj;} |
| else if (!strcmp(mname, "prepareAddress")) { jt = jobj;} |
| else if (!strcmp(mname, "prepareInt")) { jt = i32; } |
| else if (!strcmp(mname, "store")) { |
| load = false; |
| // store() must have at least one arg |
| assert(strlen(msig) > strlen("()V")); |
| char ch = msig[1]; // first symbol after '('. |
| VM_Data_Type vdt = (VM_Data_Type)ch; |
| switch(vdt) { |
| case VM_DATA_TYPE_BOOLEAN: // i8 |
| case VM_DATA_TYPE_INT8: jt = i8; break; |
| case VM_DATA_TYPE_INT16: jt = i16; break; |
| case VM_DATA_TYPE_CHAR: jt = u16; break; |
| case VM_DATA_TYPE_INT32: jt = i32; break; |
| case VM_DATA_TYPE_INT64: jt = i64; break; |
| case VM_DATA_TYPE_F4: jt = flt32; break; |
| case VM_DATA_TYPE_F8: jt = dbl64; break; |
| case VM_DATA_TYPE_ARRAY: // jobj |
| case VM_DATA_TYPE_CLASS: jt = jobj; break; |
| default: assert(false); |
| } |
| jtype retType; |
| vector<jtype> args; |
| get_args_info(meth, args, &retType); |
| assert(args.size()>=2); |
| has_offset = args.size() > 2; |
| } |
| if (jt != jvoid) { |
| size_t jt_size = sizeof_jt(jt); |
| if (load) { |
| // if loadXX() has any arg, then it's offset |
| if(strncmp(msig, "()", 2)) { |
| has_offset = true; |
| } |
| } |
| unsigned addr_depth = has_offset ? 1 : 0; |
| if (!load) { |
| ++addr_depth; |
| if (is_wide(jt)) { |
| ++addr_depth; |
| } |
| } |
| AR addrReg = vstack(addr_depth, true).reg(); |
| rlock(addrReg); |
| |
| if (has_offset) { |
| //Add offset. Save to the new location. |
| AR addrWithOffsetReg = valloc(jobj); |
| mov(addrWithOffsetReg, addrReg); |
| runlock(addrReg); |
| addrReg = addrWithOffsetReg; |
| rlock(addrReg); |
| |
| AR offsetReg = vstack(0, true).reg(); |
| vpop(); |
| alu(alu_add, addrReg, offsetReg); |
| } |
| |
| if (load) { |
| vpop(); |
| if (!is_big(jt)) { |
| AR resReg = valloc(jt); |
| ld(jt, resReg, addrReg); |
| Opnd resOpnd(jt, resReg); |
| if (jt_size < 4) { |
| Opnd extendedOpnd(i32, valloc(i32)); |
| if (jt == u16) { |
| zx2(extendedOpnd, resOpnd); |
| } else { |
| sx(extendedOpnd, resOpnd); |
| } |
| resOpnd = extendedOpnd; |
| } |
| vpush(resOpnd); |
| |
| } else { //code is taken from array element load -> TODO: avoid duplication |
| AR ar_lo = valloc(jt); |
| Opnd lo(jt, ar_lo); |
| rlock(lo); |
| |
| do_mov(lo, Opnd(i32, addrReg, 0)); |
| |
| AR ar_hi = valloc(jt); |
| Opnd hi(jt, ar_hi); |
| rlock(hi); |
| Opnd mem_hi(jt, Opnd(i32, addrReg, 4)); |
| do_mov(hi, mem_hi); |
| vpush2(lo, hi); |
| runlock(lo); |
| runlock(hi); |
| } |
| } else { |
| Opnd v0 = vstack(0, true).as_opnd(jt); |
| if (!is_big(jt)) { |
| mov(Opnd(jt, addrReg, 0), v0); |
| } else { |
| do_mov(Opnd(i32, addrReg, 0), v0); |
| Opnd v1 = vstack(1, true).as_opnd(jt); |
| do_mov(Opnd(i32, addrReg, 4), v1); |
| } |
| vpop(); // pop out value |
| vpop(); // pop out Address |
| } |
| runlock(addrReg); |
| return true; |
| } |
| // |
| // max, one, zero |
| // |
| bool loadConst = false; |
| if (!strcmp(mname, "max")) { loadConst = true; theConst = -1;} |
| else if (!strcmp(mname, "one")) { loadConst = true; theConst = 1;} |
| else if (!strcmp(mname, "zero")) { loadConst = true; theConst = 0;} |
| else if (!strcmp(mname, "nullReference")) |
| { loadConst = true; theConst = 0;} |
| if (loadConst) { |
| Opnd regOpnd(jobj, valloc(jobj)); |
| mov(regOpnd, theConst); |
| vpush(regOpnd); |
| return true; |
| } |
| // |
| // toInt, toLong, toObjectRef, toWord(), etc. |
| // |
| jt = jvoid; |
| if (!strcmp(mname, "toInt")) { jt = i32; } |
| else if (!strcmp(mname, "toLong")) { jt = i64; } |
| else if (!strcmp(mname, "toObjectRef")) { jt = jobj; } |
| else if (!strcmp(mname, "toWord")) { jt = jobj; } |
| else if (!strcmp(mname, "toAddress")) { jt = jobj; } |
| else if (!strcmp(mname, "toObject")) { jt = jobj; } |
| else if (!strcmp(mname, "toExtent")) { jt = jobj; } |
| else if (!strcmp(mname, "toOffset")) { jt = jobj; } |
| if (jt != jvoid) { |
| if (jt!=i64) { |
| vstack_replace_top_opnd(this, jt); |
| return true; |
| } |
| vstack_replace_top_opnd(this, i32); |
| |
| Opnd srcOpnd = vstack(0, true).as_opnd(i32); |
| Opnd lo(jt, valloc(jt)); |
| do_mov(lo, srcOpnd); |
| |
| Opnd hi(jt, g_iconst_0); |
| vpop(); |
| vpush2(lo, hi); |
| return true; |
| } |
| |
| if (!strcmp(mname, "attempt")) { |
| AR addrReg; |
| if (args.size() == 4) { //attempt with Offset |
| AR newAddressReg = valloc(jobj); |
| rlock(newAddressReg); |
| addrReg= vstack(3, true).reg(); |
| mov(newAddressReg, addrReg); |
| AR offsetReg= vstack(0, true).reg(); |
| alu(alu_add, newAddressReg, offsetReg); |
| runlock(newAddressReg); |
| addrReg = newAddressReg; |
| vpop(); |
| } else { |
| addrReg = vstack(2, true).reg(); |
| } |
| rlock(addrReg); |
| AR newReg = vstack(0, true).reg(); |
| rlock(newReg); |
| AR oldReg = vstack(1, true).reg(); |
| |
| cmpxchg(true, addrReg, newReg, oldReg); |
| |
| runlock(addrReg); |
| runlock(newReg); |
| |
| //save the result |
| AR resultReg = valloc(i32); |
| rlock(resultReg); |
| mov(resultReg, Opnd(g_iconst_0)); |
| cmovcc(z, resultReg, vaddr(i32, &g_iconst_1)); |
| runlock(resultReg); |
| |
| //fixing the stack and saving the result. |
| vpop(); |
| vpop(); |
| vpop(); |
| vpush(Opnd(i32, resultReg)); |
| |
| return true; |
| } |
| |
| // |
| // xArray stuff |
| // |
| if (!strcmp(mname, "create")) { |
| VM_Data_Type atype = VM_DATA_TYPE_INT32; |
| Class_Handle elem_class = class_get_class_of_primitive_type(atype); |
| assert(elem_class != NULL); |
| Class_Handle array_class = class_get_array_of_class(elem_class); |
| assert(array_class != NULL); |
| Allocation_Handle ah = class_get_allocation_handle(array_class); |
| gen_new_array(ah); |
| return true; |
| } |
| |
| if (!strcmp(mname, "get")) { |
| gen_arr_load(jobj); |
| return true; |
| } |
| |
| if (!strcmp(mname, "set")) { |
| gen_arr_store(jobj, false); |
| return true; |
| } |
| if (!strcmp(mname, "length")) { |
| gen_array_length(); |
| return true; |
| } |
| //assert(false); |
| return false; |
| |
| */ |
| } |
| |
| }}; // ~namespace Jitrino::Jet |
