1 /*

     2  * Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.

     3  * Copyright 2012, 2013 SAP AG. 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.inline.hpp"

    28 #include "memory/resourceArea.hpp"

    29 #include "nativeInst_ppc.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 // We use an illtrap for marking a method as not_entrant or zombie iff !UseSIGTRAP

    40 // Work around a C++ compiler bug which changes 'this'

    41 bool NativeInstruction::is_sigill_zombie_not_entrant_at(address addr) {

    42   assert(!UseSIGTRAP, "precondition");

    43   if (*(int*)addr != 0 /*illtrap*/) return false;

    44   CodeBlob* cb = CodeCache::find_blob_unsafe(addr);

    45   if (cb == NULL || !cb->is_nmethod()) return false;

    46   nmethod *nm = (nmethod *)cb;

    47   // This method is not_entrant or zombie iff the illtrap instruction is

    48   // located at the verified entry point.

    49   return nm->verified_entry_point() == addr;

    50 }

    51 

    52 #ifdef ASSERT

    53 void NativeInstruction::verify() {

    54   // Make sure code pattern is actually an instruction address.

    55   address addr = addr_at(0);

    56   if (addr == 0 || ((intptr_t)addr & 3) != 0) {

    57     fatal("not an instruction address");

    58   }

    59 }

    60 #endif // ASSERT

    61 

    62 // Extract call destination from a NativeCall. The call might use a trampoline stub.

    63 address NativeCall::destination() const {

    64   address addr = (address)this;

    65   address destination = Assembler::bxx_destination(addr);

    66 

    67   // Do we use a trampoline stub for this call?

    68   CodeBlob* cb = CodeCache::find_blob_unsafe(addr);   // Else we get assertion if nmethod is zombie.

    69   assert(cb && cb->is_nmethod(), "sanity");

    70   nmethod *nm = (nmethod *)cb;

    71   if (nm->stub_contains(destination) && is_NativeCallTrampolineStub_at(destination)) {

    72     // Yes we do, so get the destination from the trampoline stub.

    73     const address trampoline_stub_addr = destination;

    74     destination = NativeCallTrampolineStub_at(trampoline_stub_addr)->destination();

    75   }

    76 

    77   return destination;

    78 }

    79 

    80 // Similar to replace_mt_safe, but just changes the destination. The

    81 // important thing is that free-running threads are able to execute this

    82 // call instruction at all times. Thus, the displacement field must be

    83 // instruction-word-aligned.

    84 //

    85 // Used in the runtime linkage of calls; see class CompiledIC.

    86 //

    87 // Add parameter assert_lock to switch off assertion

    88 // during code generation, where no patching lock is needed.

    89 void NativeCall::set_destination_mt_safe(address dest, bool assert_lock) {

    90   assert(!assert_lock ||

    91          (Patching_lock->is_locked() || SafepointSynchronize::is_at_safepoint()),

    92          "concurrent code patching");

    93 

    94   ResourceMark rm;

    95   int code_size = 1 * BytesPerInstWord;

    96   address addr_call = addr_at(0);

    97   assert(MacroAssembler::is_bl(*(int*)addr_call), "unexpected code at call-site");

    98 

    99   CodeBuffer cb(addr_call, code_size + 1);

   100   MacroAssembler* a = new MacroAssembler(&cb);

   101 

   102   // Patch the call.

   103   if (ReoptimizeCallSequences &&

   104       a->is_within_range_of_b(dest, addr_call)) {

   105     a->bl(dest);

   106   } else {

   107     address trampoline_stub_addr = get_trampoline();

   108 

   109     // We did not find a trampoline stub because the current codeblob

   110     // does not provide this information. The branch will be patched

   111     // later during a final fixup, when all necessary information is

   112     // available.

   113     if (trampoline_stub_addr == 0)

   114       return;

   115 

   116     // Patch the constant in the call's trampoline stub.

   117     NativeCallTrampolineStub_at(trampoline_stub_addr)->set_destination(dest);

   118 

   119     a->bl(trampoline_stub_addr);

   120   }

   121   ICache::invalidate_range(addr_call, code_size);

   122 }

   123 

   124 address NativeCall::get_trampoline() {

   125   address call_addr = addr_at(0);

   126 

   127   CodeBlob *code = CodeCache::find_blob(call_addr);

   128   assert(code != NULL, "Could not find the containing code blob");

   129 

   130   // There are no relocations available when the code gets relocated

   131   // because of CodeBuffer expansion.

   132   if (code->relocation_size() == 0)

   133     return NULL;

   134 

   135   address bl_destination = Assembler::bxx_destination(call_addr);

   136   if (code->content_contains(bl_destination) &&

   137       is_NativeCallTrampolineStub_at(bl_destination))

   138     return bl_destination;

   139 

   140   // If the codeBlob is not a nmethod, this is because we get here from the

   141   // CodeBlob constructor, which is called within the nmethod constructor.

   142   return trampoline_stub_Relocation::get_trampoline_for(call_addr, (nmethod*)code);

   143 }

   144 

   145 #ifdef ASSERT

   146 void NativeCall::verify() {

   147   address addr = addr_at(0);

   148 

   149   if (!NativeCall::is_call_at(addr)) {

   150     tty->print_cr("not a NativeCall at " PTR_FORMAT, addr);

   151     // TODO: PPC port: Disassembler::decode(addr - 20, addr + 20, tty);

   152     fatal(err_msg("not a NativeCall at " PTR_FORMAT, addr));

   153   }

   154 }

   155 #endif // ASSERT

   156 

   157 #ifdef ASSERT

   158 void NativeFarCall::verify() {

   159   address addr = addr_at(0);

   160 

   161   NativeInstruction::verify();

   162   if (!NativeFarCall::is_far_call_at(addr)) {

   163     tty->print_cr("not a NativeFarCall at " PTR_FORMAT, addr);

   164     // TODO: PPC port: Disassembler::decode(addr, 20, 20, tty);

   165     fatal(err_msg("not a NativeFarCall at " PTR_FORMAT, addr));

   166   }

   167 }

   168 #endif // ASSERT

   169 

   170 address NativeMovConstReg::next_instruction_address() const {

   171 #ifdef ASSERT

   172   CodeBlob* nm = CodeCache::find_blob(instruction_address());

   173   assert(!MacroAssembler::is_set_narrow_oop(addr_at(0), nm->content_begin()), "Should not patch narrow oop here");

   174 #endif

   175 

   176   if (MacroAssembler::is_load_const_from_method_toc_at(addr_at(0))) {

   177     return addr_at(load_const_from_method_toc_instruction_size);

   178   } else {

   179     return addr_at(load_const_instruction_size);

   180   }

   181 }

   182 

   183 intptr_t NativeMovConstReg::data() const {

   184   address   addr = addr_at(0);

   185   CodeBlob* cb = CodeCache::find_blob_unsafe(addr);

   186 

   187   if (MacroAssembler::is_load_const_at(addr)) {

   188     return MacroAssembler::get_const(addr);

   189   } else if (MacroAssembler::is_set_narrow_oop(addr, cb->content_begin())) {

   190     narrowOop no = (narrowOop)MacroAssembler::get_narrow_oop(addr, cb->content_begin());

   191     return (intptr_t)oopDesc::decode_heap_oop(no);

   192   } else {

   193     assert(MacroAssembler::is_load_const_from_method_toc_at(addr), "must be load_const_from_pool");

   194 

   195     address ctable = cb->content_begin();

   196     int offset = MacroAssembler::get_offset_of_load_const_from_method_toc_at(addr);

   197     return *(intptr_t *)(ctable + offset);

   198   }

   199 }

   200 

   201 address NativeMovConstReg::set_data_plain(intptr_t data, CodeBlob *cb) {

   202   address addr         = instruction_address();

   203   address next_address = NULL;

   204   if (!cb) cb = CodeCache::find_blob(addr);

   205 

   206   if (cb != NULL && MacroAssembler::is_load_const_from_method_toc_at(addr)) {

   207     // A load from the method's TOC (ctable).

   208     assert(cb->is_nmethod(), "must be nmethod");

   209     const address ctable = cb->content_begin();

   210     const int toc_offset = MacroAssembler::get_offset_of_load_const_from_method_toc_at(addr);

   211     *(intptr_t *)(ctable + toc_offset) = data;

   212     next_address = addr + BytesPerInstWord;

   213   } else if (cb != NULL &&

   214              MacroAssembler::is_calculate_address_from_global_toc_at(addr, cb->content_begin())) {

   215     // A calculation relative to the global TOC.

   216     const int invalidated_range =

   217       MacroAssembler::patch_calculate_address_from_global_toc_at(addr, cb->content_begin(),

   218                                                                  (address)data);

   219     const address start = invalidated_range < 0 ? addr + invalidated_range : addr;

   220     // FIXME:

   221     const int range = invalidated_range < 0 ? 4 - invalidated_range : 8;

   222     ICache::invalidate_range(start, range);

   223     next_address = addr + 1 * BytesPerInstWord;

   224   } else if (MacroAssembler::is_load_const_at(addr)) {

   225     // A normal 5 instruction load_const code sequence.

   226     // This is not mt safe, ok in methods like CodeBuffer::copy_code().

   227     MacroAssembler::patch_const(addr, (long)data);

   228     ICache::invalidate_range(addr, load_const_instruction_size);

   229     next_address = addr + 5 * BytesPerInstWord;

   230   } else if (MacroAssembler::is_bl(* (int*) addr)) {

   231     // A single branch-and-link instruction.

   232     ResourceMark rm;

   233     const int code_size = 1 * BytesPerInstWord;

   234     CodeBuffer cb(addr, code_size + 1);

   235     MacroAssembler* a = new MacroAssembler(&cb);

   236     a->bl((address) data);

   237     ICache::invalidate_range(addr, code_size);

   238     next_address = addr + code_size;

   239   } else {

   240     ShouldNotReachHere();

   241   }

   242 

   243   return next_address;

   244 }

   245 

   246 void NativeMovConstReg::set_data(intptr_t data) {

   247   // Store the value into the instruction stream.

   248   CodeBlob *cb = CodeCache::find_blob(instruction_address());

   249   address next_address = set_data_plain(data, cb);

   250 

   251   // Also store the value into an oop_Relocation cell, if any.

   252   if (cb && cb->is_nmethod()) {

   253     RelocIterator iter((nmethod *) cb, instruction_address(), next_address);

   254     oop* oop_addr = NULL;

   255     Metadata** metadata_addr = NULL;

   256     while (iter.next()) {

   257       if (iter.type() == relocInfo::oop_type) {

   258         oop_Relocation *r = iter.oop_reloc();

   259         if (oop_addr == NULL) {

   260           oop_addr = r->oop_addr();

   261           *oop_addr = (oop)data;

   262         } else {

   263           assert(oop_addr == r->oop_addr(), "must be only one set-oop here") ;

   264         }

   265       }

   266       if (iter.type() == relocInfo::metadata_type) {

   267         metadata_Relocation *r = iter.metadata_reloc();

   268         if (metadata_addr == NULL) {

   269           metadata_addr = r->metadata_addr();

   270           *metadata_addr = (Metadata*)data;

   271         } else {

   272           assert(metadata_addr == r->metadata_addr(), "must be only one set-metadata here");

   273         }

   274       }

   275     }

   276   }

   277 }

   278 

   279 void NativeMovConstReg::set_narrow_oop(narrowOop data, CodeBlob *code /* = NULL */) {

   280   address   addr = addr_at(0);

   281   CodeBlob* cb = (code) ? code : CodeCache::find_blob(instruction_address());

   282   const int invalidated_range =

   283     MacroAssembler::patch_set_narrow_oop(addr, cb->content_begin(), (long)data);

   284   const address start = invalidated_range < 0 ? addr + invalidated_range : addr;

   285   // FIXME:

   286   const int range = invalidated_range < 0 ? 4 - invalidated_range : 8;

   287   ICache::invalidate_range(start, range);

   288 }

   289 

   290 // Do not use an assertion here. Let clients decide whether they only

   291 // want this when assertions are enabled.

   292 #ifdef ASSERT

   293 void NativeMovConstReg::verify() {

   294   address   addr = addr_at(0);

   295   CodeBlob* cb = CodeCache::find_blob_unsafe(addr);   // find_nmethod() asserts if nmethod is zombie.

   296   if (! MacroAssembler::is_load_const_at(addr) &&

   297       ! MacroAssembler::is_load_const_from_method_toc_at(addr) &&

   298       ! (cb != NULL && MacroAssembler::is_calculate_address_from_global_toc_at(addr, cb->content_begin())) &&

   299       ! (cb != NULL && MacroAssembler::is_set_narrow_oop(addr, cb->content_begin())) &&

   300       ! MacroAssembler::is_bl(*((int*) addr))) {

   301     tty->print_cr("not a NativeMovConstReg at " PTR_FORMAT, addr);

   302     // TODO: PPC port Disassembler::decode(addr, 20, 20, tty);

   303     fatal(err_msg("not a NativeMovConstReg at " PTR_FORMAT, addr));

   304   }

   305 }

   306 #endif // ASSERT

   307 

   308 void NativeJump::patch_verified_entry(address entry, address verified_entry, address dest) {

   309   ResourceMark rm;

   310   int code_size = 1 * BytesPerInstWord;

   311   CodeBuffer cb(verified_entry, code_size + 1);

   312   MacroAssembler* a = new MacroAssembler(&cb);

   313 #ifdef COMPILER2

   314   assert(dest == SharedRuntime::get_handle_wrong_method_stub(), "expected fixed destination of patch");

   315 #endif

   316   // Patch this nmethod atomically. Always use illtrap/trap in debug build.

   317   if (DEBUG_ONLY(false &&) a->is_within_range_of_b(dest, a->pc())) {

   318     a->b(dest);

   319   } else {

   320     // The signal handler will continue at dest=OptoRuntime::handle_wrong_method_stub().

   321     if (TrapBasedNotEntrantChecks) {

   322       // We use a special trap for marking a method as not_entrant or zombie.

   323       a->trap_zombie_not_entrant();

   324     } else {

   325       // We use an illtrap for marking a method as not_entrant or zombie.

   326       a->illtrap();

   327     }

   328   }

   329   ICache::invalidate_range(verified_entry, code_size);

   330 }

   331 

   332 #ifdef ASSERT

   333 void NativeJump::verify() {

   334   address addr = addr_at(0);

   335 

   336   NativeInstruction::verify();

   337   if (!NativeJump::is_jump_at(addr)) {

   338     tty->print_cr("not a NativeJump at " PTR_FORMAT, addr);

   339     // TODO: PPC port: Disassembler::decode(addr, 20, 20, tty);

   340     fatal(err_msg("not a NativeJump at " PTR_FORMAT, addr));

   341   }

   342 }

   343 #endif // ASSERT

   344 

   345 //-------------------------------------------------------------------

   346 

   347 // Call trampoline stubs.

   348 //

   349 // Layout and instructions of a call trampoline stub:

   350 //    0:  load the TOC (part 1)

   351 //    4:  load the TOC (part 2)

   352 //    8:  load the call target from the constant pool (part 1)

   353 //  [12:  load the call target from the constant pool (part 2, optional)]

   354 //   ..:  branch via CTR

   355 //

   356 

   357 address NativeCallTrampolineStub::encoded_destination_addr() const {

   358   address instruction_addr = addr_at(2 * BytesPerInstWord);

   359   assert(MacroAssembler::is_ld_largeoffset(instruction_addr),

   360          "must be a ld with large offset (from the constant pool)");

   361 

   362   return instruction_addr;

   363 }

   364 

   365 address NativeCallTrampolineStub::destination() const {

   366   CodeBlob* cb = CodeCache::find_blob(addr_at(0));

   367   address ctable = cb->content_begin();

   368 

   369   return *(address*)(ctable + destination_toc_offset());

   370 }

   371 

   372 int NativeCallTrampolineStub::destination_toc_offset() const {

   373   return MacroAssembler::get_ld_largeoffset_offset(encoded_destination_addr());

   374 }

   375 

   376 void NativeCallTrampolineStub::set_destination(address new_destination) {

   377   CodeBlob* cb = CodeCache::find_blob(addr_at(0));

   378   address ctable = cb->content_begin();

   379 

   380   *(address*)(ctable + destination_toc_offset()) = new_destination;

   381 }

   382