| /* |
| * Copyright (c) 2008, 2016, Oracle and/or its affiliates. All rights reserved. |
| * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| * |
| * This code is free software; you can redistribute it and/or modify it |
| * under the terms of the GNU General Public License version 2 only, as |
| * published by the Free Software Foundation. |
| * |
| * This code is distributed in the hope that it will be useful, but WITHOUT |
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
| * version 2 for more details (a copy is included in the LICENSE file that |
| * accompanied this code). |
| * |
| * You should have received a copy of the GNU General Public License version |
| * 2 along with this work; if not, write to the Free Software Foundation, |
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
| * |
| * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
| * or visit www.oracle.com if you need additional information or have any |
| * questions. |
| * |
| */ |
| |
| #include "precompiled.hpp" |
| #include "assembler_arm.inline.hpp" |
| #include "code/codeCache.hpp" |
| #include "memory/resourceArea.hpp" |
| #include "nativeInst_arm.hpp" |
| #include "oops/oop.inline.hpp" |
| #include "runtime/handles.hpp" |
| #include "runtime/sharedRuntime.hpp" |
| #include "runtime/stubRoutines.hpp" |
| #include "utilities/ostream.hpp" |
| #ifdef COMPILER1 |
| #include "c1/c1_Runtime1.hpp" |
| #endif |
| #include "code/icBuffer.hpp" |
| |
| int NativeMovRegMem::offset() const { |
| switch (kind()) { |
| case instr_ldr_str: |
| return encoding() & 0xfff; |
| case instr_ldrh_strh: |
| return (encoding() & 0x0f) | ((encoding() >> 4) & 0xf0); |
| case instr_fld_fst: |
| return (encoding() & 0xff) << 2; |
| default: |
| ShouldNotReachHere(); |
| return 0; |
| } |
| } |
| |
| void NativeMovRegMem::set_offset(int x) { |
| assert(x >= 0 && x < 65536, "encoding constraint"); |
| const int Rt = Rtemp->encoding(); |
| |
| // If offset is too large to be placed into single ldr/str instruction, we replace |
| // ldr Rd, [Rn, #offset] |
| // nop |
| // with |
| // add Rtemp, Rn, #offset_hi |
| // ldr Rd, [Rtemp, #offset_lo] |
| switch (kind()) { |
| case instr_ldr_str: |
| if (x < 4096) { |
| set_encoding((encoding() & 0xfffff000) | x); |
| } else { |
| NativeInstruction* next = nativeInstruction_at(next_raw_instruction_address()); |
| assert(next->is_nop(), "must be"); |
| next->set_encoding((encoding() & 0xfff0f000) | Rt << 16 | (x & 0xfff)); |
| this->set_encoding((encoding() & 0x000f0000) | Rt << 12 | x >> 12 | 0xe2800a00); |
| } |
| break; |
| case instr_ldrh_strh: |
| if (x < 256) { |
| set_encoding((encoding() & 0xfffff0f0) | (x & 0x0f) | (x & 0xf0) << 4); |
| } else { |
| NativeInstruction* next = nativeInstruction_at(next_raw_instruction_address()); |
| assert(next->is_nop(), "must be"); |
| next->set_encoding((encoding() & 0xfff0f0f0) | Rt << 16 | (x & 0x0f) | (x & 0xf0) << 4); |
| this->set_encoding((encoding() & 0x000f0000) | Rt << 12 | x >> 8 | 0xe2800c00); |
| } |
| break; |
| case instr_fld_fst: |
| if (x < 1024) { |
| set_encoding((encoding() & 0xffffff00) | (x >> 2)); |
| } else { |
| NativeInstruction* next = nativeInstruction_at(next_raw_instruction_address()); |
| assert(next->is_nop(), "must be"); |
| next->set_encoding((encoding() & 0xfff0ff00) | Rt << 16 | ((x >> 2) & 0xff)); |
| this->set_encoding((encoding() & 0x000f0000) | Rt << 12 | x >> 10 | 0xe2800b00); |
| } |
| break; |
| default: |
| ShouldNotReachHere(); |
| } |
| } |
| |
| intptr_t NativeMovConstReg::data() const { |
| RawNativeInstruction* next = next_raw(); |
| if (is_movw()) { |
| // Oop embedded in movw/movt instructions |
| assert(VM_Version::supports_movw(), "must be"); |
| return (this->encoding() & 0x00000fff) | (this->encoding() & 0x000f0000) >> 4 | |
| (next->encoding() & 0x00000fff) << 16 | (next->encoding() & 0x000f0000) << 12; |
| } else { |
| // Oop is loaded from oops section or inlined in the code |
| int oop_offset; |
| if (is_ldr_literal()) { |
| // ldr Rd, [PC, #offset] |
| oop_offset = ldr_offset(); |
| } else { |
| assert(next->is_ldr(), "must be"); |
| oop_offset = (this->encoding() & 0xff) << 12 | (next->encoding() & 0xfff); |
| if (is_add_pc()) { |
| // add Rd, PC, #offset_hi |
| // ldr Rd, [Rd, #offset_lo] |
| assert(next->encoding() & (1 << 23), "sign mismatch"); |
| // offset OK (both positive) |
| } else { |
| assert(is_sub_pc(), "must be"); |
| // sub Rd, PC, #offset_hi |
| // ldr Rd, [Rd, -#offset_lo] |
| assert(!(next->encoding() & (1 << 23)), "sign mismatch"); |
| // negative offsets |
| oop_offset = -oop_offset; |
| } |
| } |
| return *(int*)(instruction_address() + 8 + oop_offset); |
| } |
| } |
| |
| void NativeMovConstReg::set_data(intptr_t x, address pc) { |
| // Find and replace the oop corresponding to this instruction in oops section |
| RawNativeInstruction* next = next_raw(); |
| oop* oop_addr = NULL; |
| Metadata** metadata_addr = NULL; |
| CodeBlob* cb = CodeCache::find_blob(instruction_address()); |
| if (cb != NULL) { |
| nmethod* nm = cb->as_nmethod_or_null(); |
| if (nm != NULL) { |
| RelocIterator iter(nm, instruction_address(), next->instruction_address()); |
| while (iter.next()) { |
| if (iter.type() == relocInfo::oop_type) { |
| oop_addr = iter.oop_reloc()->oop_addr(); |
| *oop_addr = cast_to_oop(x); |
| break; |
| } else if (iter.type() == relocInfo::metadata_type) { |
| metadata_addr = iter.metadata_reloc()->metadata_addr(); |
| *metadata_addr = (Metadata*)x; |
| break; |
| } |
| } |
| } |
| } |
| |
| if (is_movw()) { |
| // data embedded in movw/movt instructions |
| assert(VM_Version::supports_movw(), "must be"); |
| unsigned int lo = (unsigned int)x; |
| unsigned int hi = (unsigned int)(x >> 16); |
| this->set_encoding((this->encoding() & 0xfff0f000) | (lo & 0xf000) << 4 | (lo & 0xfff)); |
| next->set_encoding((next->encoding() & 0xfff0f000) | (hi & 0xf000) << 4 | (hi & 0xfff)); |
| } else if (oop_addr == NULL & metadata_addr == NULL) { |
| // A static ldr_literal (without oop or metadata relocation) |
| assert(is_ldr_literal(), "must be"); |
| int offset = ldr_offset(); |
| oop_addr = (oop*)(instruction_address() + 8 + offset); |
| *oop_addr = cast_to_oop(x); |
| } else { |
| // data is loaded from oop or metadata section |
| int offset; |
| |
| address addr = oop_addr != NULL ? (address)oop_addr : (address)metadata_addr; |
| |
| if(pc == 0) { |
| offset = addr - instruction_address() - 8; |
| } else { |
| offset = addr - pc - 8; |
| } |
| |
| int sign = (offset >= 0) ? (1 << 23) : 0; |
| int delta = (offset >= 0) ? offset : (-offset); |
| assert(delta < 0x100000, "within accessible range"); |
| if (is_ldr_literal()) { |
| // fix the ldr with the real offset to the oop/metadata table |
| assert(next->is_nop(), "must be"); |
| if (delta < 4096) { |
| // ldr Rd, [PC, #offset] |
| set_encoding((encoding() & 0xff7ff000) | delta | sign); |
| assert(ldr_offset() == offset, "check encoding"); |
| } else { |
| int cc = encoding() & 0xf0000000; |
| int Rd = (encoding() >> 12) & 0xf; |
| int Rt = Rd; |
| assert(Rt != 0xf, "Illegal destination register"); // or fix by using Rtemp |
| // move the ldr, fixing delta_lo and the source register |
| next->set_encoding((encoding() & 0xff70f000) | (Rt << 16) | (delta & 0xfff) | sign); |
| assert(next->is_ldr(), "must be"); |
| if (offset > 0) { |
| // add Rt, PC, #delta_hi |
| // ldr Rd, [Rt, #delta_lo] |
| this->set_encoding((Rt << 12) | (delta >> 12) | 0x028f0a00 | cc); |
| assert(is_add_pc(), "must be"); |
| } else { |
| // sub Rt, PC, #delta_hi |
| // ldr Rd, [Rt, -#delta_lo] |
| this->set_encoding((Rt << 12) | (delta >> 12) | 0x024f0a00 | cc); |
| assert(is_sub_pc(), "must be"); |
| } |
| } |
| } else { |
| assert(is_pc_rel(), "must be"); |
| assert(next->is_ldr(), "must be"); |
| if (offset > 0) { |
| // add Rt, PC, #delta_hi |
| this->set_encoding((this->encoding() & 0xf00ff000) | 0x02800a00 | (delta >> 12)); |
| assert(is_add_pc(), "must be"); |
| } else { |
| // sub Rt, PC, #delta_hi |
| this->set_encoding((this->encoding() & 0xf00ff000) | 0x02400a00 | (delta >> 12)); |
| assert(is_sub_pc(), "must be"); |
| } |
| // ldr Rd, Rt, #delta_lo (or -#delta_lo) |
| next->set_encoding((next->encoding() & 0xff7ff000) | (delta & 0xfff) | sign); |
| } |
| } |
| } |
| |
| void NativeMovConstReg::set_pc_relative_offset(address addr, address pc) { |
| int offset; |
| if (pc == 0) { |
| offset = addr - instruction_address() - 8; |
| } else { |
| offset = addr - pc - 8; |
| } |
| |
| RawNativeInstruction* next = next_raw(); |
| |
| int sign = (offset >= 0) ? (1 << 23) : 0; |
| int delta = (offset >= 0) ? offset : (-offset); |
| assert(delta < 0x100000, "within accessible range"); |
| if (is_ldr_literal()) { |
| if (delta < 4096) { |
| // ldr Rd, [PC, #offset] |
| set_encoding((encoding() & 0xff7ff000) | delta | sign); |
| assert(ldr_offset() == offset, "check encoding"); |
| } else { |
| assert(next->is_nop(), "must be"); |
| int cc = encoding() & 0xf0000000; |
| int Rd = (encoding() >> 12) & 0xf; |
| int Rt = Rd; |
| assert(Rt != 0xf, "Illegal destination register"); // or fix by using Rtemp |
| // move the ldr, fixing delta_lo and the source register |
| next->set_encoding((encoding() & 0xff70f000) | (Rt << 16) | (delta & 0xfff) | sign); |
| assert(next->is_ldr(), "must be"); |
| if (offset > 0) { |
| // add Rt, PC, #delta_hi |
| // ldr Rd, [Rt, #delta_lo] |
| this->set_encoding((Rt << 12) | (delta >> 12) | 0x028f0a00 | cc); |
| assert(is_add_pc(), "must be"); |
| } else { |
| // sub Rt, PC, #delta_hi |
| // ldr Rd, [Rt, -#delta_lo] |
| this->set_encoding((Rt << 12) | (delta >> 12) | 0x024f0a00 | cc); |
| assert(is_sub_pc(), "must be"); |
| } |
| } |
| } else { |
| assert(is_pc_rel(), "must be"); |
| assert(next->is_ldr(), "must be"); |
| if (offset > 0) { |
| // add Rt, PC, #delta_hi |
| this->set_encoding((this->encoding() & 0xf00ff000) | 0x02800a00 | (delta >> 12)); |
| assert(is_add_pc(), "must be"); |
| } else { |
| // sub Rt, PC, #delta_hi |
| this->set_encoding((this->encoding() & 0xf00ff000) | 0x02400a00 | (delta >> 12)); |
| assert(is_sub_pc(), "must be"); |
| } |
| // ldr Rd, Rt, #delta_lo (or -#delta_lo) |
| next->set_encoding((next->encoding() & 0xff7ff000) | (delta & 0xfff) | sign); |
| } |
| } |
| |
| void RawNativeJump::check_verified_entry_alignment(address entry, address verified_entry) { |
| } |
| |
| void RawNativeJump::patch_verified_entry(address entry, address verified_entry, address dest) { |
| assert(dest == SharedRuntime::get_handle_wrong_method_stub(), "should be"); |
| int *a = (int *)verified_entry; |
| a[0] = zombie_illegal_instruction; // always illegal |
| ICache::invalidate_range((address)&a[0], sizeof a[0]); |
| } |
| |
| void NativeGeneralJump::insert_unconditional(address code_pos, address entry) { |
| int offset = (int)(entry - code_pos - 8); |
| assert(offset < 0x2000000 && offset > -0x2000000, "encoding constraint"); |
| nativeInstruction_at(code_pos)->set_encoding(0xea000000 | ((unsigned int)offset << 6 >> 8)); |
| } |
| |
| static address raw_call_for(address return_address) { |
| CodeBlob* cb = CodeCache::find_blob(return_address); |
| nmethod* nm = cb->as_nmethod_or_null(); |
| if (nm == NULL) { |
| ShouldNotReachHere(); |
| return NULL; |
| } |
| // Look back 4 instructions, to allow for ic_call |
| address begin = MAX2(return_address - 4*NativeInstruction::instruction_size, nm->code_begin()); |
| RelocIterator iter(nm, begin, return_address); |
| while (iter.next()) { |
| Relocation* reloc = iter.reloc(); |
| if (reloc->is_call()) { |
| address call = reloc->addr(); |
| if (nativeInstruction_at(call)->is_call()) { |
| if (nativeCall_at(call)->return_address() == return_address) { |
| return call; |
| } |
| } else { |
| // Some "calls" are really jumps |
| assert(nativeInstruction_at(call)->is_jump(), "must be call or jump"); |
| } |
| } |
| } |
| return NULL; |
| } |
| |
| bool RawNativeCall::is_call_before(address return_address) { |
| return (raw_call_for(return_address) != NULL); |
| } |
| |
| NativeCall* rawNativeCall_before(address return_address) { |
| address call = raw_call_for(return_address); |
| assert(call != NULL, "must be"); |
| return nativeCall_at(call); |
| } |
| |
