1 /*
   2  * Copyright (c) 1997, 2016, Oracle and/or its affiliates. All rights reserved.
   3  * Copyright (c) 2012, 2016 SAP SE. 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 "code/vtableStubs.hpp"
  29 #include "interp_masm_ppc.hpp"
  30 #include "memory/resourceArea.hpp"
  31 #include "oops/instanceKlass.hpp"
  32 #include "oops/klassVtable.hpp"
  33 #include "runtime/sharedRuntime.hpp"
  34 #include "vmreg_ppc.inline.hpp"
  35 #ifdef COMPILER2
  36 #include "opto/runtime.hpp"
  37 #endif
  38 
  39 #define __ masm->
  40 
  41 #ifdef PRODUCT
  42 #define BLOCK_COMMENT(str) // nothing
  43 #else
  44 #define BLOCK_COMMENT(str) __ block_comment(str)
  45 #endif
  46 #define BIND(label) bind(label); BLOCK_COMMENT(#label ":")
  47 
  48 #ifndef PRODUCT
  49 extern "C" void bad_compiled_vtable_index(JavaThread* thread, oopDesc* receiver, int index);
  50 #endif
  51 
  52 // Used by compiler only; may use only caller saved, non-argument
  53 // registers.
  54 VtableStub* VtableStubs::create_vtable_stub(int vtable_index) {
  55   // PPC port: use fixed size.
  56   const int code_length = VtableStub::pd_code_size_limit(true);
  57   VtableStub* s = new (code_length) VtableStub(true, vtable_index);
  58   ResourceMark rm;
  59   CodeBuffer cb(s->entry_point(), code_length);
  60   MacroAssembler* masm = new MacroAssembler(&cb);
  61   address start_pc;
  62 
  63 #ifndef PRODUCT
  64   if (CountCompiledCalls) {
  65     __ load_const(R11_scratch1, SharedRuntime::nof_megamorphic_calls_addr());
  66     __ lwz(R12_scratch2, 0, R11_scratch1);
  67     __ addi(R12_scratch2, R12_scratch2, 1);
  68     __ stw(R12_scratch2, 0, R11_scratch1);
  69   }
  70 #endif
  71 
  72   assert(VtableStub::receiver_location() == R3_ARG1->as_VMReg(), "receiver expected in R3_ARG1");
  73 
  74   // Get receiver klass.
  75   const Register rcvr_klass = R11_scratch1;
  76 
  77   // We might implicit NULL fault here.
  78   address npe_addr = __ pc(); // npe = null pointer exception
  79   __ null_check(R3, oopDesc::klass_offset_in_bytes(), /*implicit only*/NULL);
  80   __ load_klass(rcvr_klass, R3);
  81 
  82  // Set method (in case of interpreted method), and destination address.
  83   int entry_offset = in_bytes(Klass::vtable_start_offset()) + vtable_index*vtableEntry::size_in_bytes();
  84 
  85 #ifndef PRODUCT
  86   if (DebugVtables) {
  87     Label L;
  88     // Check offset vs vtable length.
  89     const Register vtable_len = R12_scratch2;
  90     __ lwz(vtable_len, in_bytes(Klass::vtable_length_offset()), rcvr_klass);
  91     __ cmpwi(CCR0, vtable_len, vtable_index*vtableEntry::size());
  92     __ bge(CCR0, L);
  93     __ li(R12_scratch2, vtable_index);
  94     __ call_VM(noreg, CAST_FROM_FN_PTR(address, bad_compiled_vtable_index), R3_ARG1, R12_scratch2, false);
  95     __ bind(L);
  96   }
  97 #endif
  98 
  99   int v_off = entry_offset + vtableEntry::method_offset_in_bytes();
 100 
 101   __ ld(R19_method, v_off, rcvr_klass);
 102 
 103 #ifndef PRODUCT
 104   if (DebugVtables) {
 105     Label L;
 106     __ cmpdi(CCR0, R19_method, 0);
 107     __ bne(CCR0, L);
 108     __ stop("Vtable entry is ZERO", 102);
 109     __ bind(L);
 110   }
 111 #endif
 112 
 113   // If the vtable entry is null, the method is abstract.
 114   address ame_addr = __ pc(); // ame = abstract method error
 115   __ null_check(R19_method, in_bytes(Method::from_compiled_offset()), /*implicit only*/NULL);
 116   __ ld(R12_scratch2, in_bytes(Method::from_compiled_offset()), R19_method);
 117   __ mtctr(R12_scratch2);
 118   __ bctr();
 119   masm->flush();
 120 
 121   guarantee(__ pc() <= s->code_end(), "overflowed buffer");
 122 
 123   s->set_exception_points(npe_addr, ame_addr);
 124 
 125   return s;
 126 }
 127 
 128 VtableStub* VtableStubs::create_itable_stub(int vtable_index) {
 129   // PPC port: use fixed size.
 130   const int code_length = VtableStub::pd_code_size_limit(false);
 131   VtableStub* s = new (code_length) VtableStub(false, vtable_index);
 132   ResourceMark rm;
 133   CodeBuffer cb(s->entry_point(), code_length);
 134   MacroAssembler* masm = new MacroAssembler(&cb);
 135   address start_pc;
 136 
 137 #ifndef PRODUCT
 138   if (CountCompiledCalls) {
 139     __ load_const(R11_scratch1, SharedRuntime::nof_megamorphic_calls_addr());
 140     __ lwz(R12_scratch2, 0, R11_scratch1);
 141     __ addi(R12_scratch2, R12_scratch2, 1);
 142     __ stw(R12_scratch2, 0, R11_scratch1);
 143   }
 144 #endif
 145 
 146   assert(VtableStub::receiver_location() == R3_ARG1->as_VMReg(), "receiver expected in R3_ARG1");
 147 
 148   // Entry arguments:
 149   //  R19_method: Interface
 150   //  R3_ARG1:    Receiver
 151   //
 152 
 153   const Register rcvr_klass = R11_scratch1;
 154   const Register vtable_len = R12_scratch2;
 155   const Register itable_entry_addr = R21_tmp1;
 156   const Register itable_interface = R22_tmp2;
 157 
 158   // Get receiver klass.
 159 
 160   // We might implicit NULL fault here.
 161   address npe_addr = __ pc(); // npe = null pointer exception
 162   __ null_check(R3_ARG1, oopDesc::klass_offset_in_bytes(), /*implicit only*/NULL);
 163   __ load_klass(rcvr_klass, R3_ARG1);
 164 
 165   BLOCK_COMMENT("Load start of itable entries into itable_entry.");
 166   __ lwz(vtable_len, in_bytes(Klass::vtable_length_offset()), rcvr_klass);
 167   __ slwi(vtable_len, vtable_len, exact_log2(vtableEntry::size_in_bytes()));
 168   __ add(itable_entry_addr, vtable_len, rcvr_klass);
 169 
 170   // Loop over all itable entries until desired interfaceOop(Rinterface) found.
 171   BLOCK_COMMENT("Increment itable_entry_addr in loop.");
 172   const int vtable_base_offset = in_bytes(Klass::vtable_start_offset());
 173   __ addi(itable_entry_addr, itable_entry_addr, vtable_base_offset + itableOffsetEntry::interface_offset_in_bytes());
 174 
 175   const int itable_offset_search_inc = itableOffsetEntry::size() * wordSize;
 176   Label search;
 177   __ bind(search);
 178   __ ld(itable_interface, 0, itable_entry_addr);
 179 
 180   // Handle IncompatibleClassChangeError in itable stubs.
 181   // If the entry is NULL then we've reached the end of the table
 182   // without finding the expected interface, so throw an exception.
 183   BLOCK_COMMENT("Handle IncompatibleClassChangeError in itable stubs.");
 184   Label throw_icce;
 185   __ cmpdi(CCR1, itable_interface, 0);
 186   __ cmpd(CCR0, itable_interface, R19_method);
 187   __ addi(itable_entry_addr, itable_entry_addr, itable_offset_search_inc);
 188   __ beq(CCR1, throw_icce);
 189   __ bne(CCR0, search);
 190 
 191   // Entry found and itable_entry_addr points to it, get offset of vtable for interface.
 192 
 193   const Register vtable_offset = R12_scratch2;
 194   const Register itable_method = R11_scratch1;
 195 
 196   const int vtable_offset_offset = (itableOffsetEntry::offset_offset_in_bytes() -
 197                                     itableOffsetEntry::interface_offset_in_bytes()) -
 198                                    itable_offset_search_inc;
 199   __ lwz(vtable_offset, vtable_offset_offset, itable_entry_addr);
 200 
 201   // Compute itableMethodEntry and get method and entry point for compiler.
 202   const int method_offset = (itableMethodEntry::size() * wordSize * vtable_index) +
 203     itableMethodEntry::method_offset_in_bytes();
 204 
 205   __ add(itable_method, rcvr_klass, vtable_offset);
 206   __ ld(R19_method, method_offset, itable_method);
 207 
 208 #ifndef PRODUCT
 209   if (DebugVtables) {
 210     Label ok;
 211     __ cmpd(CCR0, R19_method, 0);
 212     __ bne(CCR0, ok);
 213     __ stop("method is null", 103);
 214     __ bind(ok);
 215   }
 216 #endif
 217 
 218   // If the vtable entry is null, the method is abstract.
 219   address ame_addr = __ pc(); // ame = abstract method error
 220 
 221   // Must do an explicit check if implicit checks are disabled.
 222   __ null_check(R19_method, in_bytes(Method::from_compiled_offset()), &throw_icce);
 223   __ ld(R12_scratch2, in_bytes(Method::from_compiled_offset()), R19_method);
 224   __ mtctr(R12_scratch2);
 225   __ bctr();
 226 
 227   // Handle IncompatibleClassChangeError in itable stubs.
 228   // More detailed error message.
 229   // We force resolving of the call site by jumping to the "handle
 230   // wrong method" stub, and so let the interpreter runtime do all the
 231   // dirty work.
 232   __ bind(throw_icce);
 233   __ load_const(R11_scratch1, SharedRuntime::get_handle_wrong_method_stub());
 234   __ mtctr(R11_scratch1);
 235   __ bctr();
 236 
 237   masm->flush();
 238 
 239   guarantee(__ pc() <= s->code_end(), "overflowed buffer");
 240 
 241   s->set_exception_points(npe_addr, ame_addr);
 242   return s;
 243 }
 244 
 245 int VtableStub::pd_code_size_limit(bool is_vtable_stub) {
 246   if (TraceJumps || DebugVtables || CountCompiledCalls || VerifyOops) {
 247     return 1000;
 248   } else {
 249     int decode_klass_size = MacroAssembler::instr_size_for_decode_klass_not_null();
 250     if (is_vtable_stub) {
 251       return 20 + decode_klass_size +  8 + 8;   // Plain + cOops + Traps + safety
 252     } else {
 253       return 96 + decode_klass_size + 12 + 8;   // Plain + cOops + Traps + safety
 254     }
 255   }
 256 }
 257 
 258 int VtableStub::pd_code_alignment() {
 259   const unsigned int icache_line_size = 32;
 260   return icache_line_size;
 261 }