1 /*
   2  * Copyright (c) 1997, 2010, Oracle and/or its affiliates. All rights reserved.
   3  * Copyright (c) 2014, 2018, Red Hat Inc. All rights reserved.
   4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   5  *
   6  * This code is free software; you can redistribute it and/or modify it
   7  * under the terms of the GNU General Public License version 2 only, as
   8  * published by the Free Software Foundation.
   9  *
  10  * This code is distributed in the hope that it will be useful, but WITHOUT
  11  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  12  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  13  * version 2 for more details (a copy is included in the LICENSE file that
  14  * accompanied this code).
  15  *
  16  * You should have received a copy of the GNU General Public License version
  17  * 2 along with this work; if not, write to the Free Software Foundation,
  18  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  19  *
  20  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  21  * or visit www.oracle.com if you need additional information or have any
  22  * questions.
  23  *
  24  */
  25 
  26 #include "precompiled.hpp"
  27 #include "asm/macroAssembler.hpp"
  28 #include "memory/resourceArea.hpp"
  29 #include "nativeInst_aarch64.hpp"
  30 #include "oops/oop.inline.hpp"
  31 #include "runtime/handles.hpp"
  32 #include "runtime/sharedRuntime.hpp"
  33 #include "runtime/stubRoutines.hpp"
  34 #include "utilities/ostream.hpp"
  35 #ifdef COMPILER1
  36 #include "c1/c1_Runtime1.hpp"
  37 #endif
  38 
  39 void NativeCall::verify() { ; }
  40 
  41 address NativeCall::destination() const {
  42   address addr = (address)this;
  43   address destination = instruction_address() + displacement();
  44 
  45   // Do we use a trampoline stub for this call?
  46   CodeBlob* cb = CodeCache::find_blob_unsafe(addr);   // Else we get assertion if nmethod is zombie.
  47   assert(cb && cb->is_nmethod(), "sanity");
  48   nmethod *nm = (nmethod *)cb;
  49   if (nm->stub_contains(destination) && is_NativeCallTrampolineStub_at(destination)) {
  50     // Yes we do, so get the destination from the trampoline stub.
  51     const address trampoline_stub_addr = destination;
  52     destination = nativeCallTrampolineStub_at(trampoline_stub_addr)->destination();
  53   }
  54 
  55   return destination;
  56 }
  57 
  58 // Similar to replace_mt_safe, but just changes the destination. The
  59 // important thing is that free-running threads are able to execute this
  60 // call instruction at all times.
  61 //
  62 // Used in the runtime linkage of calls; see class CompiledIC.
  63 //
  64 // Add parameter assert_lock to switch off assertion
  65 // during code generation, where no patching lock is needed.
  66 void NativeCall::set_destination_mt_safe(address dest, bool assert_lock) {
  67   assert(!assert_lock ||
  68          (Patching_lock->is_locked() || SafepointSynchronize::is_at_safepoint()),
  69          "concurrent code patching");
  70 
  71   ResourceMark rm;
  72   int code_size = NativeInstruction::instruction_size;
  73   address addr_call = addr_at(0);
  74   assert(NativeCall::is_call_at(addr_call), "unexpected code at call site");
  75 
  76   // Patch the constant in the call's trampoline stub.
  77   address trampoline_stub_addr = get_trampoline();
  78   if (trampoline_stub_addr != NULL) {
  79     assert (! is_NativeCallTrampolineStub_at(dest), "chained trampolines");
  80     nativeCallTrampolineStub_at(trampoline_stub_addr)->set_destination(dest);
  81   }
  82 
  83   // Patch the call.
  84   if (Assembler::reachable_from_branch_at(addr_call, dest)) {
  85     set_destination(dest);
  86   } else {
  87     assert (trampoline_stub_addr != NULL, "we need a trampoline");
  88     set_destination(trampoline_stub_addr);
  89   }
  90 
  91   ICache::invalidate_range(addr_call, instruction_size);
  92 }
  93 
  94 address NativeCall::get_trampoline() {
  95   address call_addr = addr_at(0);
  96 
  97   CodeBlob *code = CodeCache::find_blob(call_addr);
  98   assert(code != NULL, "Could not find the containing code blob");
  99 
 100   address bl_destination
 101     = MacroAssembler::pd_call_destination(call_addr);
 102   if (code->contains(bl_destination) &&
 103       is_NativeCallTrampolineStub_at(bl_destination))
 104     return bl_destination;
 105 
 106   // If the codeBlob is not a nmethod, this is because we get here from the
 107   // CodeBlob constructor, which is called within the nmethod constructor.
 108   return trampoline_stub_Relocation::get_trampoline_for(call_addr, (nmethod*)code);
 109 }
 110 
 111 // Inserts a native call instruction at a given pc
 112 void NativeCall::insert(address code_pos, address entry) { Unimplemented(); }
 113 
 114 //-------------------------------------------------------------------
 115 
 116 void NativeMovConstReg::verify() {
 117   // make sure code pattern is actually mov reg64, imm64 instructions
 118 }
 119 
 120 
 121 intptr_t NativeMovConstReg::data() const {
 122   // das(uint64_t(instruction_address()),2);
 123   address addr = MacroAssembler::target_addr_for_insn(instruction_address());
 124   if (maybe_cpool_ref(instruction_address())) {
 125     return *(intptr_t*)addr;
 126   } else {
 127     return (intptr_t)addr;
 128   }
 129 }
 130 
 131 void NativeMovConstReg::set_data(intptr_t x) {
 132   if (maybe_cpool_ref(instruction_address())) {
 133     address addr = MacroAssembler::target_addr_for_insn(instruction_address());
 134     *(intptr_t*)addr = x;
 135   } else {
 136     // Store x into the instruction stream.
 137     MacroAssembler::pd_patch_instruction(instruction_address(), (address)x);
 138     ICache::invalidate_range(instruction_address(), instruction_size);
 139   }
 140 
 141   // Find and replace the oop/metadata corresponding to this
 142   // instruction in oops section.
 143   CodeBlob* cb = CodeCache::find_blob(instruction_address());
 144   nmethod* nm = cb->as_nmethod_or_null();
 145   if (nm != NULL) {
 146     RelocIterator iter(nm, instruction_address(), next_instruction_address());
 147     while (iter.next()) {
 148       if (iter.type() == relocInfo::oop_type) {
 149         oop* oop_addr = iter.oop_reloc()->oop_addr();
 150         *oop_addr = cast_to_oop(x);
 151         break;
 152       } else if (iter.type() == relocInfo::metadata_type) {
 153         Metadata** metadata_addr = iter.metadata_reloc()->metadata_addr();
 154         *metadata_addr = (Metadata*)x;
 155         break;
 156       }
 157     }
 158   }
 159 }
 160 
 161 void NativeMovConstReg::print() {
 162   tty->print_cr(PTR_FORMAT ": mov reg, " INTPTR_FORMAT,
 163                 p2i(instruction_address()), data());
 164 }
 165 
 166 //-------------------------------------------------------------------
 167 
 168 address NativeMovRegMem::instruction_address() const      { return addr_at(instruction_offset); }
 169 
 170 int NativeMovRegMem::offset() const  {
 171   address pc = instruction_address();
 172   unsigned insn = *(unsigned*)pc;
 173   if (Instruction_aarch64::extract(insn, 28, 24) == 0b10000) {
 174     address addr = MacroAssembler::target_addr_for_insn(pc);
 175     return *addr;
 176   } else {
 177     return (int)(intptr_t)MacroAssembler::target_addr_for_insn(instruction_address());
 178   }
 179 }
 180 
 181 void NativeMovRegMem::set_offset(int x) {
 182   address pc = instruction_address();
 183   unsigned insn = *(unsigned*)pc;
 184   if (maybe_cpool_ref(pc)) {
 185     address addr = MacroAssembler::target_addr_for_insn(pc);
 186     *(long*)addr = x;
 187   } else {
 188     MacroAssembler::pd_patch_instruction(pc, (address)intptr_t(x));
 189     ICache::invalidate_range(instruction_address(), instruction_size);
 190   }
 191 }
 192 
 193 void NativeMovRegMem::verify() {
 194 #ifdef ASSERT
 195   address dest = MacroAssembler::target_addr_for_insn(instruction_address());
 196 #endif
 197 }
 198 
 199 //--------------------------------------------------------------------------------
 200 
 201 void NativeJump::verify() { ; }
 202 
 203 
 204 void NativeJump::check_verified_entry_alignment(address entry, address verified_entry) {
 205 }
 206 
 207 
 208 address NativeJump::jump_destination() const          {
 209   address dest = MacroAssembler::target_addr_for_insn(instruction_address());
 210 
 211   // We use jump to self as the unresolved address which the inline
 212   // cache code (and relocs) know about
 213 
 214   // return -1 if jump to self
 215   dest = (dest == (address) this) ? (address) -1 : dest;
 216   return dest;
 217 }
 218 
 219 void NativeJump::set_jump_destination(address dest) {
 220   // We use jump to self as the unresolved address which the inline
 221   // cache code (and relocs) know about
 222   if (dest == (address) -1)
 223     dest = instruction_address();
 224 
 225   MacroAssembler::pd_patch_instruction(instruction_address(), dest);
 226   ICache::invalidate_range(instruction_address(), instruction_size);
 227 };
 228 
 229 //-------------------------------------------------------------------
 230 
 231 address NativeGeneralJump::jump_destination() const {
 232   NativeMovConstReg* move = nativeMovConstReg_at(instruction_address());
 233   address dest = (address) move->data();
 234 
 235   // We use jump to self as the unresolved address which the inline
 236   // cache code (and relocs) know about
 237 
 238   // return -1 if jump to self
 239   dest = (dest == (address) this) ? (address) -1 : dest;
 240   return dest;
 241 }
 242 
 243 void NativeGeneralJump::set_jump_destination(address dest) {
 244   NativeMovConstReg* move = nativeMovConstReg_at(instruction_address());
 245 
 246   // We use jump to self as the unresolved address which the inline
 247   // cache code (and relocs) know about
 248   if (dest == (address) -1) {
 249     dest = instruction_address();
 250   }
 251 
 252   move->set_data((uintptr_t) dest);
 253 };
 254 
 255 //-------------------------------------------------------------------
 256 
 257 bool NativeInstruction::is_safepoint_poll() {
 258   // a safepoint_poll is implemented in two steps as either
 259   //
 260   // adrp(reg, polling_page);
 261   // ldr(zr, [reg, #offset]);
 262   //
 263   // or
 264   //
 265   // mov(reg, polling_page);
 266   // ldr(zr, [reg, #offset]);
 267   //
 268   // or
 269   //
 270   // ldr(reg, [rthread, #offset]);
 271   // ldr(zr, [reg, #offset]);
 272   //
 273   // however, we cannot rely on the polling page address load always
 274   // directly preceding the read from the page. C1 does that but C2
 275   // has to do the load and read as two independent instruction
 276   // generation steps. that's because with a single macro sequence the
 277   // generic C2 code can only add the oop map before the mov/adrp and
 278   // the trap handler expects an oop map to be associated with the
 279   // load. with the load scheuled as a prior step the oop map goes
 280   // where it is needed.
 281   //
 282   // so all we can do here is check that marked instruction is a load
 283   // word to zr
 284   return is_ldrw_to_zr(address(this));
 285 }
 286 
 287 bool NativeInstruction::is_adrp_at(address instr) {
 288   unsigned insn = *(unsigned*)instr;
 289   return (Instruction_aarch64::extract(insn, 31, 24) & 0b10011111) == 0b10010000;
 290 }
 291 
 292 bool NativeInstruction::is_ldr_literal_at(address instr) {
 293   unsigned insn = *(unsigned*)instr;
 294   return (Instruction_aarch64::extract(insn, 29, 24) & 0b011011) == 0b00011000;
 295 }
 296 
 297 bool NativeInstruction::is_ldrw_to_zr(address instr) {
 298   unsigned insn = *(unsigned*)instr;
 299   return (Instruction_aarch64::extract(insn, 31, 22) == 0b1011100101 &&
 300           Instruction_aarch64::extract(insn, 4, 0) == 0b11111);
 301 }
 302 
 303 bool NativeInstruction::is_general_jump() {
 304   if (is_movz()) {
 305     NativeInstruction* inst1 = nativeInstruction_at(addr_at(instruction_size * 1));
 306     if (inst1->is_movk()) {
 307       NativeInstruction* inst2 = nativeInstruction_at(addr_at(instruction_size * 2));
 308       if (inst2->is_movk()) {
 309         NativeInstruction* inst3 = nativeInstruction_at(addr_at(instruction_size * 3));
 310         if (inst3->is_blr()) {
 311           return true;
 312         }
 313       }
 314     }
 315   }
 316   return false;
 317 }
 318 
 319 bool NativeInstruction::is_movz() {
 320   return Instruction_aarch64::extract(int_at(0), 30, 23) == 0b10100101;
 321 }
 322 
 323 bool NativeInstruction::is_movk() {
 324   return Instruction_aarch64::extract(int_at(0), 30, 23) == 0b11100101;
 325 }
 326 
 327 bool NativeInstruction::is_sigill_zombie_not_entrant() {
 328   return uint_at(0) == 0xd4bbd5a1; // dcps1 #0xdead
 329 }
 330 
 331 void NativeIllegalInstruction::insert(address code_pos) {
 332   *(juint*)code_pos = 0xd4bbd5a1; // dcps1 #0xdead
 333 }
 334 
 335 //-------------------------------------------------------------------
 336 
 337 // MT-safe inserting of a jump over a jump or a nop (used by
 338 // nmethod::make_not_entrant_or_zombie)
 339 
 340 void NativeJump::patch_verified_entry(address entry, address verified_entry, address dest) {
 341 
 342   assert(dest == SharedRuntime::get_handle_wrong_method_stub(), "expected fixed destination of patch");
 343   assert(nativeInstruction_at(verified_entry)->is_jump_or_nop()
 344          || nativeInstruction_at(verified_entry)->is_sigill_zombie_not_entrant(),
 345          "Aarch64 cannot replace non-jump with jump");
 346 
 347   // Patch this nmethod atomically.
 348   if (Assembler::reachable_from_branch_at(verified_entry, dest)) {
 349     ptrdiff_t disp = dest - verified_entry;
 350     guarantee(disp < 1 << 27 && disp > - (1 << 27), "branch overflow");
 351 
 352     unsigned int insn = (0b000101 << 26) | ((disp >> 2) & 0x3ffffff);
 353     *(unsigned int*)verified_entry = insn;
 354   } else {
 355     // We use an illegal instruction for marking a method as
 356     // not_entrant or zombie.
 357     NativeIllegalInstruction::insert(verified_entry);
 358   }
 359 
 360   ICache::invalidate_range(verified_entry, instruction_size);
 361 }
 362 
 363 void NativeGeneralJump::verify() {  }
 364 
 365 void NativeGeneralJump::insert_unconditional(address code_pos, address entry) {
 366   NativeGeneralJump* n_jump = (NativeGeneralJump*)code_pos;
 367 
 368   CodeBuffer cb(code_pos, instruction_size);
 369   MacroAssembler a(&cb);
 370 
 371   a.movptr(rscratch1, entry);
 372   a.br(rscratch1);
 373 
 374   ICache::invalidate_range(code_pos, instruction_size);
 375 }
 376 
 377 // MT-safe patching of a long jump instruction.
 378 void NativeGeneralJump::replace_mt_safe(address instr_addr, address code_buffer) {
 379   ShouldNotCallThis();
 380 }
 381 
 382 address NativeCallTrampolineStub::destination(nmethod *nm) const {
 383   return ptr_at(data_offset);
 384 }
 385 
 386 void NativeCallTrampolineStub::set_destination(address new_destination) {
 387   set_ptr_at(data_offset, new_destination);
 388   OrderAccess::release();
 389 }
 390 
 391 // Generate a trampoline for a branch to dest.  If there's no need for a
 392 // trampoline, simply patch the call directly to dest.
 393 address NativeCall::trampoline_jump(CodeBuffer &cbuf, address dest) {
 394   MacroAssembler a(&cbuf);
 395   address stub = NULL;
 396 
 397   if (a.far_branches()
 398       && ! is_NativeCallTrampolineStub_at(instruction_address() + displacement())) {
 399     stub = a.emit_trampoline_stub(instruction_address() - cbuf.insts()->start(), dest);
 400   }
 401 
 402   if (stub == NULL) {
 403     // If we generated no stub, patch this call directly to dest.
 404     // This will happen if we don't need far branches or if there
 405     // already was a trampoline.
 406     set_destination(dest);
 407   }
 408 
 409   return stub;
 410 }