rev 56556 : 8232151: Minimal VM build broken after JDK-8232050
Reviewed-by: dholmes, clanger, redestad

   1 /*
   2  * Copyright (c) 1997, 2018, Oracle and/or its affiliates. All rights reserved.
   3  * Copyright (c) 2012, 2018 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/compiledICHolder.hpp"
  32 #include "oops/instanceKlass.hpp"
  33 #include "oops/klass.inline.hpp"
  34 #include "oops/klassVtable.hpp"
  35 #include "runtime/sharedRuntime.hpp"
  36 #include "vmreg_ppc.inline.hpp"
  37 #ifdef COMPILER2
  38 #include "opto/runtime.hpp"
  39 #endif
  40 
  41 #define __ masm->
  42 
  43 #ifndef PRODUCT
  44 extern "C" void bad_compiled_vtable_index(JavaThread* thread, oopDesc* receiver, int index);
  45 #endif
  46 
  47 // Used by compiler only; may use only caller saved, non-argument registers.
  48 VtableStub* VtableStubs::create_vtable_stub(int vtable_index) {
  49   // Read "A word on VtableStub sizing" in share/code/vtableStubs.hpp for details on stub sizing.
  50   const int stub_code_length = code_size_limit(true);
  51   VtableStub* s = new(stub_code_length) VtableStub(true, vtable_index);
  52   // Can be NULL if there is no free space in the code cache.
  53   if (s == NULL) {
  54     return NULL;
  55   }
  56 
  57   // Count unused bytes in instruction sequences of variable size.
  58   // We add them to the computed buffer size in order to avoid
  59   // overflow in subsequently generated stubs.
  60   address   start_pc;
  61   int       slop_bytes = 8; // just a two-instruction safety net
  62   int       slop_delta = 0;
  63 
  64   ResourceMark    rm;
  65   CodeBuffer      cb(s->entry_point(), stub_code_length);
  66   MacroAssembler* masm = new MacroAssembler(&cb);
  67 
  68 #if (!defined(PRODUCT) && defined(COMPILER2))
  69   if (CountCompiledCalls) {
  70     start_pc = __ pc();
  71     int load_const_maxLen = 5*BytesPerInstWord;  // load_const generates 5 instructions. Assume that as max size for laod_const_optimized
  72     int offs = __ load_const_optimized(R11_scratch1, SharedRuntime::nof_megamorphic_calls_addr(), R12_scratch2, true);
  73     slop_delta  = load_const_maxLen - (__ pc() - start_pc);
  74     slop_bytes += slop_delta;
  75     assert(slop_delta >= 0, "negative slop(%d) encountered, adjust code size estimate!", slop_delta);
  76     __ lwz(R12_scratch2, offs, R11_scratch1);
  77     __ addi(R12_scratch2, R12_scratch2, 1);
  78     __ stw(R12_scratch2, offs, R11_scratch1);
  79   }
  80 #endif
  81 
  82   assert(VtableStub::receiver_location() == R3_ARG1->as_VMReg(), "receiver expected in R3_ARG1");
  83 
  84   const Register rcvr_klass = R11_scratch1;
  85   address npe_addr = __ pc(); // npe = null pointer exception
  86   // check if we must do an explicit check (implicit checks disabled, offset too large).
  87   __ null_check(R3, oopDesc::klass_offset_in_bytes(), /*implicit only*/NULL);
  88   // Get receiver klass.
  89   __ load_klass(rcvr_klass, R3);
  90 
  91 #ifndef PRODUCT
  92   if (DebugVtables) {
  93     Label L;
  94     // Check offset vs vtable length.
  95     const Register vtable_len = R12_scratch2;
  96     __ lwz(vtable_len, in_bytes(Klass::vtable_length_offset()), rcvr_klass);
  97     __ cmpwi(CCR0, vtable_len, vtable_index*vtableEntry::size());
  98     __ bge(CCR0, L);
  99     __ li(R12_scratch2, vtable_index);
 100     __ call_VM(noreg, CAST_FROM_FN_PTR(address, bad_compiled_vtable_index), R3_ARG1, R12_scratch2, false);
 101     __ bind(L);
 102   }
 103 #endif
 104 
 105   int entry_offset = in_bytes(Klass::vtable_start_offset()) +
 106                      vtable_index*vtableEntry::size_in_bytes();
 107   int v_off        = entry_offset + vtableEntry::method_offset_in_bytes();
 108 
 109   __ ld(R19_method, (RegisterOrConstant)v_off, rcvr_klass);
 110 
 111 #ifndef PRODUCT
 112   if (DebugVtables) {
 113     Label L;
 114     __ cmpdi(CCR0, R19_method, 0);
 115     __ bne(CCR0, L);
 116     __ stop("Vtable entry is ZERO", 102);
 117     __ bind(L);
 118   }
 119 #endif
 120 
 121   address ame_addr = __ pc(); // ame = abstract method error
 122                               // if the vtable entry is null, the method is abstract
 123                               // NOTE: for vtable dispatches, the vtable entry will never be null.
 124 
 125   __ null_check(R19_method, in_bytes(Method::from_compiled_offset()), /*implicit only*/NULL);
 126   __ ld(R12_scratch2, in_bytes(Method::from_compiled_offset()), R19_method);
 127   __ mtctr(R12_scratch2);
 128   __ bctr();
 129 
 130   masm->flush();
 131   bookkeeping(masm, tty, s, npe_addr, ame_addr, true, vtable_index, slop_bytes, 0);
 132 
 133   return s;
 134 }
 135 
 136 VtableStub* VtableStubs::create_itable_stub(int itable_index) {
 137   // Read "A word on VtableStub sizing" in share/code/vtableStubs.hpp for details on stub sizing.
 138   const int stub_code_length = code_size_limit(false);
 139   VtableStub* s = new(stub_code_length) VtableStub(false, itable_index);
 140   // Can be NULL if there is no free space in the code cache.
 141   if (s == NULL) {
 142     return NULL;
 143   }
 144   // Count unused bytes in instruction sequences of variable size.
 145   // We add them to the computed buffer size in order to avoid
 146   // overflow in subsequently generated stubs.
 147   address   start_pc;
 148   int       slop_bytes = 8; // just a two-instruction safety net
 149   int       slop_delta = 0;
 150 
 151   ResourceMark    rm;
 152   CodeBuffer      cb(s->entry_point(), stub_code_length);
 153   MacroAssembler* masm = new MacroAssembler(&cb);
 154   int             load_const_maxLen = 5*BytesPerInstWord;  // load_const generates 5 instructions. Assume that as max size for laod_const_optimized
 155 
 156 #if (!defined(PRODUCT) && defined(COMPILER2))
 157   if (CountCompiledCalls) {
 158     start_pc = __ pc();
 159     int offs = __ load_const_optimized(R11_scratch1, SharedRuntime::nof_megamorphic_calls_addr(), R12_scratch2, true);
 160     slop_delta  = load_const_maxLen - (__ pc() - start_pc);
 161     slop_bytes += slop_delta;
 162     assert(slop_delta >= 0, "negative slop(%d) encountered, adjust code size estimate!", slop_delta);
 163     __ lwz(R12_scratch2, offs, R11_scratch1);
 164     __ addi(R12_scratch2, R12_scratch2, 1);
 165     __ stw(R12_scratch2, offs, R11_scratch1);
 166   }
 167 #endif
 168 
 169   assert(VtableStub::receiver_location() == R3_ARG1->as_VMReg(), "receiver expected in R3_ARG1");
 170 
 171   // Entry arguments:
 172   //  R19_method: Interface
 173   //  R3_ARG1:    Receiver
 174 
 175   Label L_no_such_interface;
 176   const Register rcvr_klass = R11_scratch1,
 177                  interface  = R12_scratch2,
 178                  tmp1       = R21_tmp1,
 179                  tmp2       = R22_tmp2;
 180 
 181   address npe_addr = __ pc(); // npe = null pointer exception
 182   __ null_check(R3_ARG1, oopDesc::klass_offset_in_bytes(), /*implicit only*/NULL);
 183   __ load_klass(rcvr_klass, R3_ARG1);
 184 
 185   // Receiver subtype check against REFC.
 186   __ ld(interface, CompiledICHolder::holder_klass_offset(), R19_method);
 187   __ lookup_interface_method(rcvr_klass, interface, noreg,
 188                              R0, tmp1, tmp2,
 189                              L_no_such_interface, /*return_method=*/ false);
 190 
 191   // Get Method* and entrypoint for compiler
 192   __ ld(interface, CompiledICHolder::holder_metadata_offset(), R19_method);
 193   __ lookup_interface_method(rcvr_klass, interface, itable_index,
 194                              R19_method, tmp1, tmp2,
 195                              L_no_such_interface, /*return_method=*/ true);
 196 
 197 #ifndef PRODUCT
 198   if (DebugVtables) {
 199     Label ok;
 200     __ cmpd(CCR0, R19_method, 0);
 201     __ bne(CCR0, ok);
 202     __ stop("method is null", 103);
 203     __ bind(ok);
 204   }
 205 #endif
 206 
 207   // If the vtable entry is null, the method is abstract.
 208   address ame_addr = __ pc(); // ame = abstract method error
 209 
 210   // Must do an explicit check if implicit checks are disabled.
 211   __ null_check(R19_method, in_bytes(Method::from_compiled_offset()), &L_no_such_interface);
 212   __ ld(R12_scratch2, in_bytes(Method::from_compiled_offset()), R19_method);
 213   __ mtctr(R12_scratch2);
 214   __ bctr();
 215 
 216   // Handle IncompatibleClassChangeError in itable stubs.
 217   // More detailed error message.
 218   // We force resolving of the call site by jumping to the "handle
 219   // wrong method" stub, and so let the interpreter runtime do all the
 220   // dirty work.
 221   __ bind(L_no_such_interface);
 222   start_pc = __ pc();
 223   __ load_const_optimized(R11_scratch1, SharedRuntime::get_handle_wrong_method_stub(), R12_scratch2);
 224   slop_delta  = load_const_maxLen - (__ pc() - start_pc);
 225   slop_bytes += slop_delta;
 226   assert(slop_delta >= 0, "negative slop(%d) encountered, adjust code size estimate!", slop_delta);
 227   __ mtctr(R11_scratch1);
 228   __ bctr();
 229 
 230   masm->flush();
 231   bookkeeping(masm, tty, s, npe_addr, ame_addr, false, itable_index, slop_bytes, 0);
 232 
 233   return s;
 234 }
 235 
 236 int VtableStub::pd_code_alignment() {
 237   // Power cache line size is 128 bytes, but we want to limit alignment loss.
 238   const unsigned int icache_line_size = 32;
 239   return icache_line_size;
 240 }
--- EOF ---