graal-compiler: src/cpu/sparc/vm/vtableStubs

annotate src/cpu/sparc/vm/vtableStubs_sparc.cpp @ 6812:988bf00cc564

7200261: G1: Liveness counting inconsistencies during marking verification Summary: The clipping code in the routine that sets the bits for a range of cards, in the liveness accounting verification code was incorrect. It set all the bits in the card bitmap from the given starting index which would lead to spurious marking verification failures. Reviewed-by: brutisso, jwilhelm, jmasa

author	johnc
date	Thu, 27 Sep 2012 15:44:01 -0700
parents	da91efe96a93
children	8e47bac5643a

rev	line source
0 a61af66fc99e Initial load duke parents: diff changeset	1 /*
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2 * Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved.
0 a61af66fc99e Initial load duke parents: diff changeset	3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
a61af66fc99e Initial load duke parents: diff changeset	4 *
a61af66fc99e Initial load duke parents: diff changeset	5 * This code is free software; you can redistribute it and/or modify it
a61af66fc99e Initial load duke parents: diff changeset	6 * under the terms of the GNU General Public License version 2 only, as
a61af66fc99e Initial load duke parents: diff changeset	7 * published by the Free Software Foundation.
a61af66fc99e Initial load duke parents: diff changeset	8 *
a61af66fc99e Initial load duke parents: diff changeset	9 * This code is distributed in the hope that it will be useful, but WITHOUT
a61af66fc99e Initial load duke parents: diff changeset	10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
a61af66fc99e Initial load duke parents: diff changeset	11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
a61af66fc99e Initial load duke parents: diff changeset	12 * version 2 for more details (a copy is included in the LICENSE file that
a61af66fc99e Initial load duke parents: diff changeset	13 * accompanied this code).
a61af66fc99e Initial load duke parents: diff changeset	14 *
a61af66fc99e Initial load duke parents: diff changeset	15 * You should have received a copy of the GNU General Public License version
a61af66fc99e Initial load duke parents: diff changeset	16 * 2 along with this work; if not, write to the Free Software Foundation,
a61af66fc99e Initial load duke parents: diff changeset	17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
a61af66fc99e Initial load duke parents: diff changeset	18 *
1552 c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 727 diff changeset	19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 727 diff changeset	20 * or visit www.oracle.com if you need additional information or have any
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 727 diff changeset	21 * questions.
0 a61af66fc99e Initial load duke parents: diff changeset	22 *
a61af66fc99e Initial load duke parents: diff changeset	23 */
a61af66fc99e Initial load duke parents: diff changeset	24
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	25 #include "precompiled.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	26 #include "asm/assembler.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	27 #include "assembler_sparc.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	28 #include "code/vtableStubs.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	29 #include "interp_masm_sparc.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	30 #include "memory/resourceArea.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	31 #include "oops/instanceKlass.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	32 #include "oops/klassVtable.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	33 #include "runtime/sharedRuntime.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	34 #include "vmreg_sparc.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	35 #ifdef COMPILER2
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	36 #include "opto/runtime.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	37 #endif
0 a61af66fc99e Initial load duke parents: diff changeset	38
a61af66fc99e Initial load duke parents: diff changeset	39 // machine-dependent part of VtableStubs: create vtableStub of correct size and
a61af66fc99e Initial load duke parents: diff changeset	40 // initialize its code
a61af66fc99e Initial load duke parents: diff changeset	41
a61af66fc99e Initial load duke parents: diff changeset	42 #define __ masm->
a61af66fc99e Initial load duke parents: diff changeset	43
a61af66fc99e Initial load duke parents: diff changeset	44
a61af66fc99e Initial load duke parents: diff changeset	45 #ifndef PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	46 extern "C" void bad_compiled_vtable_index(JavaThread* thread, oopDesc* receiver, int index);
a61af66fc99e Initial load duke parents: diff changeset	47 #endif
a61af66fc99e Initial load duke parents: diff changeset	48
a61af66fc99e Initial load duke parents: diff changeset	49
a61af66fc99e Initial load duke parents: diff changeset	50 // Used by compiler only; may use only caller saved, non-argument registers
a61af66fc99e Initial load duke parents: diff changeset	51 // NOTE: %%%% if any change is made to this stub make sure that the function
a61af66fc99e Initial load duke parents: diff changeset	52 // pd_code_size_limit is changed to ensure the correct size for VtableStub
a61af66fc99e Initial load duke parents: diff changeset	53 VtableStub* VtableStubs::create_vtable_stub(int vtable_index) {
a61af66fc99e Initial load duke parents: diff changeset	54 const int sparc_code_length = VtableStub::pd_code_size_limit(true);
a61af66fc99e Initial load duke parents: diff changeset	55 VtableStub* s = new(sparc_code_length) VtableStub(true, vtable_index);
a61af66fc99e Initial load duke parents: diff changeset	56 ResourceMark rm;
a61af66fc99e Initial load duke parents: diff changeset	57 CodeBuffer cb(s->entry_point(), sparc_code_length);
a61af66fc99e Initial load duke parents: diff changeset	58 MacroAssembler* masm = new MacroAssembler(&cb);
a61af66fc99e Initial load duke parents: diff changeset	59
a61af66fc99e Initial load duke parents: diff changeset	60 #ifndef PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	61 if (CountCompiledCalls) {
727 6b2273dd6fa9 6822110: Add AddressLiteral class on SPARC twisti parents: 709 diff changeset	62 __ inc_counter(SharedRuntime::nof_megamorphic_calls_addr(), G5, G3_scratch);
0 a61af66fc99e Initial load duke parents: diff changeset	63 }
a61af66fc99e Initial load duke parents: diff changeset	64 #endif /* PRODUCT */
a61af66fc99e Initial load duke parents: diff changeset	65
a61af66fc99e Initial load duke parents: diff changeset	66 assert(VtableStub::receiver_location() == O0->as_VMReg(), "receiver expected in O0");
a61af66fc99e Initial load duke parents: diff changeset	67
a61af66fc99e Initial load duke parents: diff changeset	68 // get receiver klass
a61af66fc99e Initial load duke parents: diff changeset	69 address npe_addr = __ pc();
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 16 diff changeset	70 __ load_klass(O0, G3_scratch);
0 a61af66fc99e Initial load duke parents: diff changeset	71
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	72 // set Method* (in case of interpreted method), and destination address
0 a61af66fc99e Initial load duke parents: diff changeset	73 #ifndef PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	74 if (DebugVtables) {
a61af66fc99e Initial load duke parents: diff changeset	75 Label L;
a61af66fc99e Initial load duke parents: diff changeset	76 // check offset vs vtable length
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	77 __ ld(G3_scratch, InstanceKlass::vtable_length_offset()*wordSize, G5);
3839 3d42f82cd811 7063628: Use cbcond on T4 kvn parents: 1972 diff changeset	78 __ cmp_and_br_short(G5, vtable_index*vtableEntry::size(), Assembler::greaterUnsigned, Assembler::pt, L);
0 a61af66fc99e Initial load duke parents: diff changeset	79 __ set(vtable_index, O2);
a61af66fc99e Initial load duke parents: diff changeset	80 __ call_VM(noreg, CAST_FROM_FN_PTR(address, bad_compiled_vtable_index), O0, O2);
a61af66fc99e Initial load duke parents: diff changeset	81 __ bind(L);
a61af66fc99e Initial load duke parents: diff changeset	82 }
a61af66fc99e Initial load duke parents: diff changeset	83 #endif
6266 1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 4114 diff changeset	84
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 4114 diff changeset	85 __ lookup_virtual_method(G3_scratch, vtable_index, G5_method);
0 a61af66fc99e Initial load duke parents: diff changeset	86
a61af66fc99e Initial load duke parents: diff changeset	87 #ifndef PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	88 if (DebugVtables) {
a61af66fc99e Initial load duke parents: diff changeset	89 Label L;
3839 3d42f82cd811 7063628: Use cbcond on T4 kvn parents: 1972 diff changeset	90 __ br_notnull_short(G5_method, Assembler::pt, L);
0 a61af66fc99e Initial load duke parents: diff changeset	91 __ stop("Vtable entry is ZERO");
a61af66fc99e Initial load duke parents: diff changeset	92 __ bind(L);
a61af66fc99e Initial load duke parents: diff changeset	93 }
a61af66fc99e Initial load duke parents: diff changeset	94 #endif
a61af66fc99e Initial load duke parents: diff changeset	95
a61af66fc99e Initial load duke parents: diff changeset	96 address ame_addr = __ pc(); // if the vtable entry is null, the method is abstract
a61af66fc99e Initial load duke parents: diff changeset	97 // NOTE: for vtable dispatches, the vtable entry will never be null.
a61af66fc99e Initial load duke parents: diff changeset	98
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	99 __ ld_ptr(G5_method, in_bytes(Method::from_compiled_offset()), G3_scratch);
0 a61af66fc99e Initial load duke parents: diff changeset	100
a61af66fc99e Initial load duke parents: diff changeset	101 // jump to target (either compiled code or c2iadapter)
a61af66fc99e Initial load duke parents: diff changeset	102 __ JMP(G3_scratch, 0);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	103 // load Method* (in case we call c2iadapter)
0 a61af66fc99e Initial load duke parents: diff changeset	104 __ delayed()->nop();
a61af66fc99e Initial load duke parents: diff changeset	105
a61af66fc99e Initial load duke parents: diff changeset	106 masm->flush();
623 9adddb8c0fc8 6812831: factor duplicated assembly code for megamorphic invokeinterface (for 6655638) jrose parents: 196 diff changeset	107
9adddb8c0fc8 6812831: factor duplicated assembly code for megamorphic invokeinterface (for 6655638) jrose parents: 196 diff changeset	108 if (PrintMiscellaneous && (WizardMode \|\| Verbose)) {
9adddb8c0fc8 6812831: factor duplicated assembly code for megamorphic invokeinterface (for 6655638) jrose parents: 196 diff changeset	109 tty->print_cr("vtable #%d at "PTR_FORMAT"[%d] left over: %d",
9adddb8c0fc8 6812831: factor duplicated assembly code for megamorphic invokeinterface (for 6655638) jrose parents: 196 diff changeset	110 vtable_index, s->entry_point(),
9adddb8c0fc8 6812831: factor duplicated assembly code for megamorphic invokeinterface (for 6655638) jrose parents: 196 diff changeset	111 (int)(s->code_end() - s->entry_point()),
9adddb8c0fc8 6812831: factor duplicated assembly code for megamorphic invokeinterface (for 6655638) jrose parents: 196 diff changeset	112 (int)(s->code_end() - __ pc()));
9adddb8c0fc8 6812831: factor duplicated assembly code for megamorphic invokeinterface (for 6655638) jrose parents: 196 diff changeset	113 }
9adddb8c0fc8 6812831: factor duplicated assembly code for megamorphic invokeinterface (for 6655638) jrose parents: 196 diff changeset	114 guarantee(__ pc() <= s->code_end(), "overflowed buffer");
709 1d037ecd7960 6827505: sizing logic for vtable and itable stubs needs self-check jrose parents: 642 diff changeset	115 // shut the door on sizing bugs
1d037ecd7960 6827505: sizing logic for vtable and itable stubs needs self-check jrose parents: 642 diff changeset	116 int slop = 2*BytesPerInstWord; // 32-bit offset is this much larger than a 13-bit one
1d037ecd7960 6827505: sizing logic for vtable and itable stubs needs self-check jrose parents: 642 diff changeset	117 assert(vtable_index > 10 \|\| __ pc() + slop <= s->code_end(), "room for sethi;add");
623 9adddb8c0fc8 6812831: factor duplicated assembly code for megamorphic invokeinterface (for 6655638) jrose parents: 196 diff changeset	118
0 a61af66fc99e Initial load duke parents: diff changeset	119 s->set_exception_points(npe_addr, ame_addr);
a61af66fc99e Initial load duke parents: diff changeset	120 return s;
a61af66fc99e Initial load duke parents: diff changeset	121 }
a61af66fc99e Initial load duke parents: diff changeset	122
a61af66fc99e Initial load duke parents: diff changeset	123
a61af66fc99e Initial load duke parents: diff changeset	124 // NOTE: %%%% if any change is made to this stub make sure that the function
a61af66fc99e Initial load duke parents: diff changeset	125 // pd_code_size_limit is changed to ensure the correct size for VtableStub
623 9adddb8c0fc8 6812831: factor duplicated assembly code for megamorphic invokeinterface (for 6655638) jrose parents: 196 diff changeset	126 VtableStub* VtableStubs::create_itable_stub(int itable_index) {
0 a61af66fc99e Initial load duke parents: diff changeset	127 const int sparc_code_length = VtableStub::pd_code_size_limit(false);
623 9adddb8c0fc8 6812831: factor duplicated assembly code for megamorphic invokeinterface (for 6655638) jrose parents: 196 diff changeset	128 VtableStub* s = new(sparc_code_length) VtableStub(false, itable_index);
0 a61af66fc99e Initial load duke parents: diff changeset	129 ResourceMark rm;
a61af66fc99e Initial load duke parents: diff changeset	130 CodeBuffer cb(s->entry_point(), sparc_code_length);
a61af66fc99e Initial load duke parents: diff changeset	131 MacroAssembler* masm = new MacroAssembler(&cb);
a61af66fc99e Initial load duke parents: diff changeset	132
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	133 Register G3_Klass = G3_scratch;
0 a61af66fc99e Initial load duke parents: diff changeset	134 Register G5_interface = G5; // Passed in as an argument
a61af66fc99e Initial load duke parents: diff changeset	135 Label search;
a61af66fc99e Initial load duke parents: diff changeset	136
a61af66fc99e Initial load duke parents: diff changeset	137 // Entry arguments:
a61af66fc99e Initial load duke parents: diff changeset	138 // G5_interface: Interface
a61af66fc99e Initial load duke parents: diff changeset	139 // O0: Receiver
a61af66fc99e Initial load duke parents: diff changeset	140 assert(VtableStub::receiver_location() == O0->as_VMReg(), "receiver expected in O0");
a61af66fc99e Initial load duke parents: diff changeset	141
a61af66fc99e Initial load duke parents: diff changeset	142 // get receiver klass (also an implicit null-check)
a61af66fc99e Initial load duke parents: diff changeset	143 address npe_addr = __ pc();
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	144 __ load_klass(O0, G3_Klass);
0 a61af66fc99e Initial load duke parents: diff changeset	145
a61af66fc99e Initial load duke parents: diff changeset	146 // Push a new window to get some temp registers. This chops the head of all
a61af66fc99e Initial load duke parents: diff changeset	147 // my 64-bit %o registers in the LION build, but this is OK because no longs
a61af66fc99e Initial load duke parents: diff changeset	148 // are passed in the %o registers. Instead, longs are passed in G1 and G4
a61af66fc99e Initial load duke parents: diff changeset	149 // and so those registers are not available here.
a61af66fc99e Initial load duke parents: diff changeset	150 __ save(SP,-frame::register_save_words*wordSize,SP);
a61af66fc99e Initial load duke parents: diff changeset	151
a61af66fc99e Initial load duke parents: diff changeset	152 #ifndef PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	153 if (CountCompiledCalls) {
727 6b2273dd6fa9 6822110: Add AddressLiteral class on SPARC twisti parents: 709 diff changeset	154 __ inc_counter(SharedRuntime::nof_megamorphic_calls_addr(), L0, L1);
0 a61af66fc99e Initial load duke parents: diff changeset	155 }
a61af66fc99e Initial load duke parents: diff changeset	156 #endif /* PRODUCT */
a61af66fc99e Initial load duke parents: diff changeset	157
623 9adddb8c0fc8 6812831: factor duplicated assembly code for megamorphic invokeinterface (for 6655638) jrose parents: 196 diff changeset	158 Label throw_icce;
0 a61af66fc99e Initial load duke parents: diff changeset	159
623 9adddb8c0fc8 6812831: factor duplicated assembly code for megamorphic invokeinterface (for 6655638) jrose parents: 196 diff changeset	160 Register L5_method = L5;
9adddb8c0fc8 6812831: factor duplicated assembly code for megamorphic invokeinterface (for 6655638) jrose parents: 196 diff changeset	161 __ lookup_interface_method(// inputs: rec. class, interface, itable index
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	162 G3_Klass, G5_interface, itable_index,
623 9adddb8c0fc8 6812831: factor duplicated assembly code for megamorphic invokeinterface (for 6655638) jrose parents: 196 diff changeset	163 // outputs: method, scan temp. reg
9adddb8c0fc8 6812831: factor duplicated assembly code for megamorphic invokeinterface (for 6655638) jrose parents: 196 diff changeset	164 L5_method, L2, L3,
9adddb8c0fc8 6812831: factor duplicated assembly code for megamorphic invokeinterface (for 6655638) jrose parents: 196 diff changeset	165 throw_icce);
0 a61af66fc99e Initial load duke parents: diff changeset	166
a61af66fc99e Initial load duke parents: diff changeset	167 #ifndef PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	168 if (DebugVtables) {
a61af66fc99e Initial load duke parents: diff changeset	169 Label L01;
3839 3d42f82cd811 7063628: Use cbcond on T4 kvn parents: 1972 diff changeset	170 __ br_notnull_short(L5_method, Assembler::pt, L01);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	171 __ stop("Method* is null");
0 a61af66fc99e Initial load duke parents: diff changeset	172 __ bind(L01);
a61af66fc99e Initial load duke parents: diff changeset	173 }
a61af66fc99e Initial load duke parents: diff changeset	174 #endif
a61af66fc99e Initial load duke parents: diff changeset	175
a61af66fc99e Initial load duke parents: diff changeset	176 // If the following load is through a NULL pointer, we'll take an OS
a61af66fc99e Initial load duke parents: diff changeset	177 // exception that should translate into an AbstractMethodError. We need the
a61af66fc99e Initial load duke parents: diff changeset	178 // window count to be correct at that time.
623 9adddb8c0fc8 6812831: factor duplicated assembly code for megamorphic invokeinterface (for 6655638) jrose parents: 196 diff changeset	179 __ restore(L5_method, 0, G5_method);
9adddb8c0fc8 6812831: factor duplicated assembly code for megamorphic invokeinterface (for 6655638) jrose parents: 196 diff changeset	180 // Restore registers before the AME point.
0 a61af66fc99e Initial load duke parents: diff changeset	181
a61af66fc99e Initial load duke parents: diff changeset	182 address ame_addr = __ pc(); // if the vtable entry is null, the method is abstract
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	183 __ ld_ptr(G5_method, in_bytes(Method::from_compiled_offset()), G3_scratch);
0 a61af66fc99e Initial load duke parents: diff changeset	184
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	185 // G5_method: Method*
0 a61af66fc99e Initial load duke parents: diff changeset	186 // O0: Receiver
a61af66fc99e Initial load duke parents: diff changeset	187 // G3_scratch: entry point
a61af66fc99e Initial load duke parents: diff changeset	188 __ JMP(G3_scratch, 0);
a61af66fc99e Initial load duke parents: diff changeset	189 __ delayed()->nop();
a61af66fc99e Initial load duke parents: diff changeset	190
16 f8236e79048a 6664627: Merge changes made only in hotspot 11 forward to jdk 7 dcubed parents: 0 diff changeset	191 __ bind(throw_icce);
727 6b2273dd6fa9 6822110: Add AddressLiteral class on SPARC twisti parents: 709 diff changeset	192 AddressLiteral icce(StubRoutines::throw_IncompatibleClassChangeError_entry());
6b2273dd6fa9 6822110: Add AddressLiteral class on SPARC twisti parents: 709 diff changeset	193 __ jump_to(icce, G3_scratch);
16 f8236e79048a 6664627: Merge changes made only in hotspot 11 forward to jdk 7 dcubed parents: 0 diff changeset	194 __ delayed()->restore();
f8236e79048a 6664627: Merge changes made only in hotspot 11 forward to jdk 7 dcubed parents: 0 diff changeset	195
0 a61af66fc99e Initial load duke parents: diff changeset	196 masm->flush();
16 f8236e79048a 6664627: Merge changes made only in hotspot 11 forward to jdk 7 dcubed parents: 0 diff changeset	197
623 9adddb8c0fc8 6812831: factor duplicated assembly code for megamorphic invokeinterface (for 6655638) jrose parents: 196 diff changeset	198 if (PrintMiscellaneous && (WizardMode \|\| Verbose)) {
9adddb8c0fc8 6812831: factor duplicated assembly code for megamorphic invokeinterface (for 6655638) jrose parents: 196 diff changeset	199 tty->print_cr("itable #%d at "PTR_FORMAT"[%d] left over: %d",
9adddb8c0fc8 6812831: factor duplicated assembly code for megamorphic invokeinterface (for 6655638) jrose parents: 196 diff changeset	200 itable_index, s->entry_point(),
9adddb8c0fc8 6812831: factor duplicated assembly code for megamorphic invokeinterface (for 6655638) jrose parents: 196 diff changeset	201 (int)(s->code_end() - s->entry_point()),
9adddb8c0fc8 6812831: factor duplicated assembly code for megamorphic invokeinterface (for 6655638) jrose parents: 196 diff changeset	202 (int)(s->code_end() - __ pc()));
9adddb8c0fc8 6812831: factor duplicated assembly code for megamorphic invokeinterface (for 6655638) jrose parents: 196 diff changeset	203 }
16 f8236e79048a 6664627: Merge changes made only in hotspot 11 forward to jdk 7 dcubed parents: 0 diff changeset	204 guarantee(__ pc() <= s->code_end(), "overflowed buffer");
709 1d037ecd7960 6827505: sizing logic for vtable and itable stubs needs self-check jrose parents: 642 diff changeset	205 // shut the door on sizing bugs
1d037ecd7960 6827505: sizing logic for vtable and itable stubs needs self-check jrose parents: 642 diff changeset	206 int slop = 2*BytesPerInstWord; // 32-bit offset is this much larger than a 13-bit one
1d037ecd7960 6827505: sizing logic for vtable and itable stubs needs self-check jrose parents: 642 diff changeset	207 assert(itable_index > 10 \|\| __ pc() + slop <= s->code_end(), "room for sethi;add");
16 f8236e79048a 6664627: Merge changes made only in hotspot 11 forward to jdk 7 dcubed parents: 0 diff changeset	208
0 a61af66fc99e Initial load duke parents: diff changeset	209 s->set_exception_points(npe_addr, ame_addr);
a61af66fc99e Initial load duke parents: diff changeset	210 return s;
a61af66fc99e Initial load duke parents: diff changeset	211 }
a61af66fc99e Initial load duke parents: diff changeset	212
a61af66fc99e Initial load duke parents: diff changeset	213
a61af66fc99e Initial load duke parents: diff changeset	214 int VtableStub::pd_code_size_limit(bool is_vtable_stub) {
16 f8236e79048a 6664627: Merge changes made only in hotspot 11 forward to jdk 7 dcubed parents: 0 diff changeset	215 if (TraceJumps \|\| DebugVtables \|\| CountCompiledCalls \|\| VerifyOops) return 1000;
0 a61af66fc99e Initial load duke parents: diff changeset	216 else {
a61af66fc99e Initial load duke parents: diff changeset	217 const int slop = 2*BytesPerInstWord; // sethi;add (needed for long offsets)
a61af66fc99e Initial load duke parents: diff changeset	218 if (is_vtable_stub) {
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 16 diff changeset	219 // ld;ld;ld,jmp,nop
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 16 diff changeset	220 const int basic = 5*BytesPerInstWord +
642 660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 623 diff changeset	221 // shift;add for load_klass (only shift with zero heap based)
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	222 (UseCompressedKlassPointers ?
642 660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 623 diff changeset	223 ((Universe::narrow_oop_base() == NULL) ? BytesPerInstWord : 2*BytesPerInstWord) : 0);
0 a61af66fc99e Initial load duke parents: diff changeset	224 return basic + slop;
a61af66fc99e Initial load duke parents: diff changeset	225 } else {
623 9adddb8c0fc8 6812831: factor duplicated assembly code for megamorphic invokeinterface (for 6655638) jrose parents: 196 diff changeset	226 const int basic = (28 LP64_ONLY(+ 6)) * BytesPerInstWord +
642 660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 623 diff changeset	227 // shift;add for load_klass (only shift with zero heap based)
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	228 (UseCompressedKlassPointers ?
642 660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 623 diff changeset	229 ((Universe::narrow_oop_base() == NULL) ? BytesPerInstWord : 2*BytesPerInstWord) : 0);
0 a61af66fc99e Initial load duke parents: diff changeset	230 return (basic + slop);
a61af66fc99e Initial load duke parents: diff changeset	231 }
a61af66fc99e Initial load duke parents: diff changeset	232 }
709 1d037ecd7960 6827505: sizing logic for vtable and itable stubs needs self-check jrose parents: 642 diff changeset	233
1d037ecd7960 6827505: sizing logic for vtable and itable stubs needs self-check jrose parents: 642 diff changeset	234 // In order to tune these parameters, run the JVM with VM options
1d037ecd7960 6827505: sizing logic for vtable and itable stubs needs self-check jrose parents: 642 diff changeset	235 // +PrintMiscellaneous and +WizardMode to see information about
1d037ecd7960 6827505: sizing logic for vtable and itable stubs needs self-check jrose parents: 642 diff changeset	236 // actual itable stubs. Look for lines like this:
1d037ecd7960 6827505: sizing logic for vtable and itable stubs needs self-check jrose parents: 642 diff changeset	237 // itable #1 at 0x5551212[116] left over: 8
1d037ecd7960 6827505: sizing logic for vtable and itable stubs needs self-check jrose parents: 642 diff changeset	238 // Reduce the constants so that the "left over" number is 8
1d037ecd7960 6827505: sizing logic for vtable and itable stubs needs self-check jrose parents: 642 diff changeset	239 // Do not aim at a left-over number of zero, because a very
1d037ecd7960 6827505: sizing logic for vtable and itable stubs needs self-check jrose parents: 642 diff changeset	240 // large vtable or itable offset (> 4K) will require an extra
1d037ecd7960 6827505: sizing logic for vtable and itable stubs needs self-check jrose parents: 642 diff changeset	241 // sethi/or pair of instructions.
1d037ecd7960 6827505: sizing logic for vtable and itable stubs needs self-check jrose parents: 642 diff changeset	242 //
1d037ecd7960 6827505: sizing logic for vtable and itable stubs needs self-check jrose parents: 642 diff changeset	243 // The JVM98 app. _202_jess has a megamorphic interface call.
1d037ecd7960 6827505: sizing logic for vtable and itable stubs needs self-check jrose parents: 642 diff changeset	244 // The itable code looks like this:
1d037ecd7960 6827505: sizing logic for vtable and itable stubs needs self-check jrose parents: 642 diff changeset	245 // Decoding VtableStub itbl[1]@16
1d037ecd7960 6827505: sizing logic for vtable and itable stubs needs self-check jrose parents: 642 diff changeset	246 // ld [ %o0 + 4 ], %g3
1d037ecd7960 6827505: sizing logic for vtable and itable stubs needs self-check jrose parents: 642 diff changeset	247 // save %sp, -64, %sp
1d037ecd7960 6827505: sizing logic for vtable and itable stubs needs self-check jrose parents: 642 diff changeset	248 // ld [ %g3 + 0xe8 ], %l2
1d037ecd7960 6827505: sizing logic for vtable and itable stubs needs self-check jrose parents: 642 diff changeset	249 // sll %l2, 2, %l2
1d037ecd7960 6827505: sizing logic for vtable and itable stubs needs self-check jrose parents: 642 diff changeset	250 // add %l2, 0x134, %l2
1d037ecd7960 6827505: sizing logic for vtable and itable stubs needs self-check jrose parents: 642 diff changeset	251 // and %l2, -8, %l2 ! NOT_LP64 only
1d037ecd7960 6827505: sizing logic for vtable and itable stubs needs self-check jrose parents: 642 diff changeset	252 // add %g3, %l2, %l2
1d037ecd7960 6827505: sizing logic for vtable and itable stubs needs self-check jrose parents: 642 diff changeset	253 // add %g3, 4, %g3
1d037ecd7960 6827505: sizing logic for vtable and itable stubs needs self-check jrose parents: 642 diff changeset	254 // ld [ %l2 ], %l5
1d037ecd7960 6827505: sizing logic for vtable and itable stubs needs self-check jrose parents: 642 diff changeset	255 // brz,pn %l5, throw_icce
1d037ecd7960 6827505: sizing logic for vtable and itable stubs needs self-check jrose parents: 642 diff changeset	256 // cmp %l5, %g5
1d037ecd7960 6827505: sizing logic for vtable and itable stubs needs self-check jrose parents: 642 diff changeset	257 // be %icc, success
1d037ecd7960 6827505: sizing logic for vtable and itable stubs needs self-check jrose parents: 642 diff changeset	258 // add %l2, 8, %l2
1d037ecd7960 6827505: sizing logic for vtable and itable stubs needs self-check jrose parents: 642 diff changeset	259 // loop:
1d037ecd7960 6827505: sizing logic for vtable and itable stubs needs self-check jrose parents: 642 diff changeset	260 // ld [ %l2 ], %l5
1d037ecd7960 6827505: sizing logic for vtable and itable stubs needs self-check jrose parents: 642 diff changeset	261 // brz,pn %l5, throw_icce
1d037ecd7960 6827505: sizing logic for vtable and itable stubs needs self-check jrose parents: 642 diff changeset	262 // cmp %l5, %g5
1d037ecd7960 6827505: sizing logic for vtable and itable stubs needs self-check jrose parents: 642 diff changeset	263 // bne,pn %icc, loop
1d037ecd7960 6827505: sizing logic for vtable and itable stubs needs self-check jrose parents: 642 diff changeset	264 // add %l2, 8, %l2
1d037ecd7960 6827505: sizing logic for vtable and itable stubs needs self-check jrose parents: 642 diff changeset	265 // success:
1d037ecd7960 6827505: sizing logic for vtable and itable stubs needs self-check jrose parents: 642 diff changeset	266 // ld [ %l2 + -4 ], %l2
1d037ecd7960 6827505: sizing logic for vtable and itable stubs needs self-check jrose parents: 642 diff changeset	267 // ld [ %g3 + %l2 ], %l5
1d037ecd7960 6827505: sizing logic for vtable and itable stubs needs self-check jrose parents: 642 diff changeset	268 // restore %l5, 0, %g5
1d037ecd7960 6827505: sizing logic for vtable and itable stubs needs self-check jrose parents: 642 diff changeset	269 // ld [ %g5 + 0x44 ], %g3
1d037ecd7960 6827505: sizing logic for vtable and itable stubs needs self-check jrose parents: 642 diff changeset	270 // jmp %g3
1d037ecd7960 6827505: sizing logic for vtable and itable stubs needs self-check jrose parents: 642 diff changeset	271 // nop
1d037ecd7960 6827505: sizing logic for vtable and itable stubs needs self-check jrose parents: 642 diff changeset	272 // throw_icce:
1d037ecd7960 6827505: sizing logic for vtable and itable stubs needs self-check jrose parents: 642 diff changeset	273 // sethi %hi(throw_ICCE_entry), %g3
1d037ecd7960 6827505: sizing logic for vtable and itable stubs needs self-check jrose parents: 642 diff changeset	274 // ! 5 more instructions here, LP64_ONLY
1d037ecd7960 6827505: sizing logic for vtable and itable stubs needs self-check jrose parents: 642 diff changeset	275 // jmp %g3 + %lo(throw_ICCE_entry)
1d037ecd7960 6827505: sizing logic for vtable and itable stubs needs self-check jrose parents: 642 diff changeset	276 // restore
0 a61af66fc99e Initial load duke parents: diff changeset	277 }
a61af66fc99e Initial load duke parents: diff changeset	278
a61af66fc99e Initial load duke parents: diff changeset	279
a61af66fc99e Initial load duke parents: diff changeset	280 int VtableStub::pd_code_alignment() {
a61af66fc99e Initial load duke parents: diff changeset	281 // UltraSPARC cache line size is 8 instructions:
a61af66fc99e Initial load duke parents: diff changeset	282 const unsigned int icache_line_size = 32;
a61af66fc99e Initial load duke parents: diff changeset	283 return icache_line_size;
a61af66fc99e Initial load duke parents: diff changeset	284 }

Mercurial > hg > graal-compiler

annotate src/cpu/sparc/vm/vtableStubs_sparc.cpp @ 6812:988bf00cc564