• file
• revisions
• annotate
• diff
• comparison
• raw

src/cpu/x86/vm/jniFastGetField_x86_32.cpp@bb1da64b0492 (annotated)

src/cpu/x86/vm/jniFastGetField_x86_32.cpp

Fri, 16 Aug 2019 16:50:17 +0200

author

eosterlund

date

Fri, 16 Aug 2019 16:50:17 +0200

changeset 9834

bb1da64b0492

parent 9669

32bc598624bd

child 9703

2fdf635bcf28

permissions

-rw-r--r--

8229345: Memory leak due to vtable stubs not being shared on SPARC
Reviewed-by: mdoerr, dholmes, kvn

duke@435	1	/*
phh@9669	2	* Copyright (c) 2004, 2017, Oracle and/or its affiliates. All rights reserved.
duke@435	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
duke@435	4	*
duke@435	5	* This code is free software; you can redistribute it and/or modify it
duke@435	6	* under the terms of the GNU General Public License version 2 only, as
duke@435	7	* published by the Free Software Foundation.
duke@435	8	*
duke@435	9	* This code is distributed in the hope that it will be useful, but WITHOUT
duke@435	10	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
duke@435	11	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
duke@435	12	* version 2 for more details (a copy is included in the LICENSE file that
duke@435	13	* accompanied this code).
duke@435	14	*
duke@435	15	* You should have received a copy of the GNU General Public License version
duke@435	16	* 2 along with this work; if not, write to the Free Software Foundation,
duke@435	17	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
duke@435	18	*
trims@1907	19	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
trims@1907	20	* or visit www.oracle.com if you need additional information or have any
trims@1907	21	* questions.
duke@435	22	*
duke@435	23	*/
duke@435	24
stefank@2314	25	#include "precompiled.hpp"
twisti@4318	26	#include "asm/macroAssembler.hpp"
stefank@2314	27	#include "memory/resourceArea.hpp"
stefank@2314	28	#include "prims/jniFastGetField.hpp"
stefank@2314	29	#include "prims/jvm_misc.hpp"
stefank@2314	30	#include "runtime/safepoint.hpp"
duke@435	31
duke@435	32	#define __ masm->
duke@435	33
duke@435	34	#define BUFFER_SIZE 30
duke@435	35
duke@435	36	#ifdef _WINDOWS
duke@435	37	GetBooleanField_t JNI_FastGetField::jni_fast_GetBooleanField_fp;
duke@435	38	GetByteField_t JNI_FastGetField::jni_fast_GetByteField_fp;
duke@435	39	GetCharField_t JNI_FastGetField::jni_fast_GetCharField_fp;
duke@435	40	GetShortField_t JNI_FastGetField::jni_fast_GetShortField_fp;
duke@435	41	GetIntField_t JNI_FastGetField::jni_fast_GetIntField_fp;
duke@435	42	GetLongField_t JNI_FastGetField::jni_fast_GetLongField_fp;
duke@435	43	GetFloatField_t JNI_FastGetField::jni_fast_GetFloatField_fp;
duke@435	44	GetDoubleField_t JNI_FastGetField::jni_fast_GetDoubleField_fp;
duke@435	45	#endif
duke@435	46
duke@435	47	// Instead of issuing lfence for LoadLoad barrier, we create data dependency
duke@435	48	// between loads, which is much more efficient than lfence.
duke@435	49
duke@435	50	address JNI_FastGetField::generate_fast_get_int_field0(BasicType type) {
csahu@8316	51	const char *name = NULL;
duke@435	52	switch (type) {
duke@435	53	case T_BOOLEAN: name = "jni_fast_GetBooleanField"; break;
duke@435	54	case T_BYTE: name = "jni_fast_GetByteField"; break;
duke@435	55	case T_CHAR: name = "jni_fast_GetCharField"; break;
duke@435	56	case T_SHORT: name = "jni_fast_GetShortField"; break;
duke@435	57	case T_INT: name = "jni_fast_GetIntField"; break;
duke@435	58	default: ShouldNotReachHere();
duke@435	59	}
duke@435	60	ResourceMark rm;
twisti@2103	61	BufferBlob* blob = BufferBlob::create(name, BUFFER_SIZE*wordSize);
twisti@2103	62	CodeBuffer cbuf(blob);
duke@435	63	MacroAssembler* masm = new MacroAssembler(&cbuf);
twisti@2103	64	address fast_entry = __ pc();
duke@435	65
duke@435	66	Label slow;
duke@435	67
duke@435	68	// stack layout: offset from rsp (in words):
duke@435	69	// return pc 0
duke@435	70	// jni env 1
duke@435	71	// obj 2
duke@435	72	// jfieldID 3
duke@435	73
duke@435	74	ExternalAddress counter(SafepointSynchronize::safepoint_counter_addr());
duke@435	75	__ mov32 (rcx, counter);
duke@435	76	__ testb (rcx, 1);
duke@435	77	__ jcc (Assembler::notZero, slow);
duke@435	78	if (os::is_MP()) {
never@739	79	__ mov(rax, rcx);
never@739	80	__ andptr(rax, 1); // rax, must end up 0
never@739	81	__ movptr(rdx, Address(rsp, rax, Address::times_1, 2*wordSize));
phh@9669	82	// obj, notice rax, is 0.
phh@9669	83	// rdx is data dependent on rcx.
duke@435	84	} else {
phh@9669	85	__ movptr (rdx, Address(rsp, 2*wordSize)); // obj
duke@435	86	}
never@739	87	__ movptr(rax, Address(rsp, 3*wordSize)); // jfieldID
phh@9669	88
phh@9669	89	__ clear_jweak_tag(rdx);
phh@9669	90
never@739	91	__ movptr(rdx, Address(rdx, 0)); // *obj
phh@9669	92	__ shrptr (rax, 2); // offset
duke@435	93
duke@435	94	assert(count < LIST_CAPACITY, "LIST_CAPACITY too small");
duke@435	95	speculative_load_pclist[count] = __ pc();
duke@435	96	switch (type) {
never@739	97	case T_BOOLEAN: __ movzbl (rax, Address(rdx, rax, Address::times_1)); break;
never@739	98	case T_BYTE: __ movsbl (rax, Address(rdx, rax, Address::times_1)); break;
never@739	99	case T_CHAR: __ movzwl (rax, Address(rdx, rax, Address::times_1)); break;
never@739	100	case T_SHORT: __ movswl (rax, Address(rdx, rax, Address::times_1)); break;
duke@435	101	case T_INT: __ movl (rax, Address(rdx, rax, Address::times_1)); break;
duke@435	102	default: ShouldNotReachHere();
duke@435	103	}
duke@435	104
duke@435	105	Address ca1;
duke@435	106	if (os::is_MP()) {
duke@435	107	__ lea(rdx, counter);
never@739	108	__ xorptr(rdx, rax);
never@739	109	__ xorptr(rdx, rax);
duke@435	110	__ cmp32(rcx, Address(rdx, 0));
duke@435	111	// ca1 is the same as ca because
duke@435	112	// rax, ^ counter_addr ^ rax, = address
duke@435	113	// ca1 is data dependent on rax,.
duke@435	114	} else {
duke@435	115	__ cmp32(rcx, counter);
duke@435	116	}
duke@435	117	__ jcc (Assembler::notEqual, slow);
duke@435	118
duke@435	119	#ifndef _WINDOWS
duke@435	120	__ ret (0);
duke@435	121	#else
duke@435	122	// __stdcall calling convention
duke@435	123	__ ret (3*wordSize);
duke@435	124	#endif
duke@435	125
duke@435	126	slowcase_entry_pclist[count++] = __ pc();
duke@435	127	__ bind (slow);
csahu@8316	128	address slow_case_addr = NULL;
duke@435	129	switch (type) {
duke@435	130	case T_BOOLEAN: slow_case_addr = jni_GetBooleanField_addr(); break;
duke@435	131	case T_BYTE: slow_case_addr = jni_GetByteField_addr(); break;
duke@435	132	case T_CHAR: slow_case_addr = jni_GetCharField_addr(); break;
duke@435	133	case T_SHORT: slow_case_addr = jni_GetShortField_addr(); break;
duke@435	134	case T_INT: slow_case_addr = jni_GetIntField_addr();
duke@435	135	}
duke@435	136	// tail call
duke@435	137	__ jump (ExternalAddress(slow_case_addr));
duke@435	138
duke@435	139	__ flush ();
duke@435	140
duke@435	141	#ifndef _WINDOWS
duke@435	142	return fast_entry;
duke@435	143	#else
duke@435	144	switch (type) {
twisti@2103	145	case T_BOOLEAN: jni_fast_GetBooleanField_fp = (GetBooleanField_t) fast_entry; break;
twisti@2103	146	case T_BYTE: jni_fast_GetByteField_fp = (GetByteField_t) fast_entry; break;
twisti@2103	147	case T_CHAR: jni_fast_GetCharField_fp = (GetCharField_t) fast_entry; break;
twisti@2103	148	case T_SHORT: jni_fast_GetShortField_fp = (GetShortField_t) fast_entry; break;
twisti@2103	149	case T_INT: jni_fast_GetIntField_fp = (GetIntField_t) fast_entry; break;
duke@435	150	}
duke@435	151	return os::win32::fast_jni_accessor_wrapper(type);
duke@435	152	#endif
duke@435	153	}
duke@435	154
duke@435	155	address JNI_FastGetField::generate_fast_get_boolean_field() {
duke@435	156	return generate_fast_get_int_field0(T_BOOLEAN);
duke@435	157	}
duke@435	158
duke@435	159	address JNI_FastGetField::generate_fast_get_byte_field() {
duke@435	160	return generate_fast_get_int_field0(T_BYTE);
duke@435	161	}
duke@435	162
duke@435	163	address JNI_FastGetField::generate_fast_get_char_field() {
duke@435	164	return generate_fast_get_int_field0(T_CHAR);
duke@435	165	}
duke@435	166
duke@435	167	address JNI_FastGetField::generate_fast_get_short_field() {
duke@435	168	return generate_fast_get_int_field0(T_SHORT);
duke@435	169	}
duke@435	170
duke@435	171	address JNI_FastGetField::generate_fast_get_int_field() {
duke@435	172	return generate_fast_get_int_field0(T_INT);
duke@435	173	}
duke@435	174
duke@435	175	address JNI_FastGetField::generate_fast_get_long_field() {
duke@435	176	const char *name = "jni_fast_GetLongField";
duke@435	177	ResourceMark rm;
twisti@2103	178	BufferBlob* blob = BufferBlob::create(name, BUFFER_SIZE*wordSize);
twisti@2103	179	CodeBuffer cbuf(blob);
duke@435	180	MacroAssembler* masm = new MacroAssembler(&cbuf);
twisti@2103	181	address fast_entry = __ pc();
duke@435	182
duke@435	183	Label slow;
duke@435	184
duke@435	185	// stack layout: offset from rsp (in words):
duke@435	186	// old rsi 0
duke@435	187	// return pc 1
duke@435	188	// jni env 2
duke@435	189	// obj 3
duke@435	190	// jfieldID 4
duke@435	191
duke@435	192	ExternalAddress counter(SafepointSynchronize::safepoint_counter_addr());
duke@435	193
never@739	194	__ push (rsi);
duke@435	195	__ mov32 (rcx, counter);
duke@435	196	__ testb (rcx, 1);
duke@435	197	__ jcc (Assembler::notZero, slow);
duke@435	198	if (os::is_MP()) {
never@739	199	__ mov(rax, rcx);
phh@9669	200	__ andptr(rax, 1); // rax, must end up 0
never@739	201	__ movptr(rdx, Address(rsp, rax, Address::times_1, 3*wordSize));
duke@435	202	// obj, notice rax, is 0.
duke@435	203	// rdx is data dependent on rcx.
duke@435	204	} else {
phh@9669	205	__ movptr(rdx, Address(rsp, 3*wordSize)); // obj
duke@435	206	}
never@739	207	__ movptr(rsi, Address(rsp, 4*wordSize)); // jfieldID
phh@9669	208
phh@9669	209	__ clear_jweak_tag(rdx);
phh@9669	210
never@739	211	__ movptr(rdx, Address(rdx, 0)); // *obj
never@739	212	__ shrptr(rsi, 2); // offset
duke@435	213
duke@435	214	assert(count < LIST_CAPACITY-1, "LIST_CAPACITY too small");
duke@435	215	speculative_load_pclist[count++] = __ pc();
never@739	216	__ movptr(rax, Address(rdx, rsi, Address::times_1));
never@739	217	#ifndef _LP64
duke@435	218	speculative_load_pclist[count] = __ pc();
never@739	219	__ movl(rdx, Address(rdx, rsi, Address::times_1, 4));
never@739	220	#endif // _LP64
duke@435	221
duke@435	222	if (os::is_MP()) {
never@739	223	__ lea(rsi, counter);
never@739	224	__ xorptr(rsi, rdx);
never@739	225	__ xorptr(rsi, rax);
never@739	226	__ xorptr(rsi, rdx);
never@739	227	__ xorptr(rsi, rax);
duke@435	228	__ cmp32(rcx, Address(rsi, 0));
duke@435	229	// ca1 is the same as ca because
duke@435	230	// rax, ^ rdx ^ counter_addr ^ rax, ^ rdx = address
duke@435	231	// ca1 is data dependent on both rax, and rdx.
duke@435	232	} else {
duke@435	233	__ cmp32(rcx, counter);
duke@435	234	}
duke@435	235	__ jcc (Assembler::notEqual, slow);
duke@435	236
never@739	237	__ pop (rsi);
duke@435	238
duke@435	239	#ifndef _WINDOWS
duke@435	240	__ ret (0);
duke@435	241	#else
duke@435	242	// __stdcall calling convention
duke@435	243	__ ret (3*wordSize);
duke@435	244	#endif
duke@435	245
duke@435	246	slowcase_entry_pclist[count-1] = __ pc();
duke@435	247	slowcase_entry_pclist[count++] = __ pc();
duke@435	248	__ bind (slow);
never@739	249	__ pop (rsi);
duke@435	250	address slow_case_addr = jni_GetLongField_addr();;
duke@435	251	// tail call
duke@435	252	__ jump (ExternalAddress(slow_case_addr));
duke@435	253
duke@435	254	__ flush ();
duke@435	255
duke@435	256	#ifndef _WINDOWS
duke@435	257	return fast_entry;
duke@435	258	#else
twisti@2103	259	jni_fast_GetLongField_fp = (GetLongField_t) fast_entry;
duke@435	260	return os::win32::fast_jni_accessor_wrapper(T_LONG);
duke@435	261	#endif
duke@435	262	}
duke@435	263
duke@435	264	address JNI_FastGetField::generate_fast_get_float_field0(BasicType type) {
csahu@8316	265	const char *name = NULL;
duke@435	266	switch (type) {
duke@435	267	case T_FLOAT: name = "jni_fast_GetFloatField"; break;
duke@435	268	case T_DOUBLE: name = "jni_fast_GetDoubleField"; break;
duke@435	269	default: ShouldNotReachHere();
duke@435	270	}
duke@435	271	ResourceMark rm;
twisti@2103	272	BufferBlob* blob = BufferBlob::create(name, BUFFER_SIZE*wordSize);
twisti@2103	273	CodeBuffer cbuf(blob);
duke@435	274	MacroAssembler* masm = new MacroAssembler(&cbuf);
twisti@2103	275	address fast_entry = __ pc();
duke@435	276
duke@435	277	Label slow_with_pop, slow;
duke@435	278
duke@435	279	// stack layout: offset from rsp (in words):
duke@435	280	// return pc 0
duke@435	281	// jni env 1
duke@435	282	// obj 2
duke@435	283	// jfieldID 3
duke@435	284
duke@435	285	ExternalAddress counter(SafepointSynchronize::safepoint_counter_addr());
duke@435	286
duke@435	287	__ mov32 (rcx, counter);
duke@435	288	__ testb (rcx, 1);
duke@435	289	__ jcc (Assembler::notZero, slow);
duke@435	290	if (os::is_MP()) {
never@739	291	__ mov(rax, rcx);
phh@9669	292	__ andptr(rax, 1); // rax, must end up 0
never@739	293	__ movptr(rdx, Address(rsp, rax, Address::times_1, 2*wordSize));
duke@435	294	// obj, notice rax, is 0.
duke@435	295	// rdx is data dependent on rcx.
duke@435	296	} else {
never@739	297	__ movptr(rdx, Address(rsp, 2*wordSize)); // obj
duke@435	298	}
never@739	299	__ movptr(rax, Address(rsp, 3*wordSize)); // jfieldID
phh@9669	300
phh@9669	301	__ clear_jweak_tag(rdx);
phh@9669	302
never@739	303	__ movptr(rdx, Address(rdx, 0)); // *obj
never@739	304	__ shrptr(rax, 2); // offset
duke@435	305
duke@435	306	assert(count < LIST_CAPACITY, "LIST_CAPACITY too small");
duke@435	307	speculative_load_pclist[count] = __ pc();
duke@435	308	switch (type) {
never@739	309	#ifndef _LP64
duke@435	310	case T_FLOAT: __ fld_s (Address(rdx, rax, Address::times_1)); break;
duke@435	311	case T_DOUBLE: __ fld_d (Address(rdx, rax, Address::times_1)); break;
never@739	312	#else
never@739	313	case T_FLOAT: __ movflt (xmm0, Address(robj, roffset, Address::times_1)); break;
never@739	314	case T_DOUBLE: __ movdbl (xmm0, Address(robj, roffset, Address::times_1)); break;
never@739	315	#endif // _LP64
duke@435	316	default: ShouldNotReachHere();
duke@435	317	}
duke@435	318
duke@435	319	Address ca1;
duke@435	320	if (os::is_MP()) {
duke@435	321	__ fst_s (Address(rsp, -4));
duke@435	322	__ lea(rdx, counter);
duke@435	323	__ movl (rax, Address(rsp, -4));
never@739	324	// garbage hi-order bits on 64bit are harmless.
never@739	325	__ xorptr(rdx, rax);
never@739	326	__ xorptr(rdx, rax);
duke@435	327	__ cmp32(rcx, Address(rdx, 0));
duke@435	328	// rax, ^ counter_addr ^ rax, = address
duke@435	329	// ca1 is data dependent on the field
duke@435	330	// access.
duke@435	331	} else {
duke@435	332	__ cmp32(rcx, counter);
duke@435	333	}
duke@435	334	__ jcc (Assembler::notEqual, slow_with_pop);
duke@435	335
duke@435	336	#ifndef _WINDOWS
duke@435	337	__ ret (0);
duke@435	338	#else
duke@435	339	// __stdcall calling convention
duke@435	340	__ ret (3*wordSize);
duke@435	341	#endif
duke@435	342
duke@435	343	__ bind (slow_with_pop);
duke@435	344	// invalid load. pop FPU stack.
duke@435	345	__ fstp_d (0);
duke@435	346
duke@435	347	slowcase_entry_pclist[count++] = __ pc();
duke@435	348	__ bind (slow);
csahu@8316	349	address slow_case_addr = NULL;
duke@435	350	switch (type) {
duke@435	351	case T_FLOAT: slow_case_addr = jni_GetFloatField_addr(); break;
duke@435	352	case T_DOUBLE: slow_case_addr = jni_GetDoubleField_addr(); break;
duke@435	353	default: ShouldNotReachHere();
duke@435	354	}
duke@435	355	// tail call
duke@435	356	__ jump (ExternalAddress(slow_case_addr));
duke@435	357
duke@435	358	__ flush ();
duke@435	359
duke@435	360	#ifndef _WINDOWS
duke@435	361	return fast_entry;
duke@435	362	#else
duke@435	363	switch (type) {
twisti@2103	364	case T_FLOAT: jni_fast_GetFloatField_fp = (GetFloatField_t) fast_entry; break;
twisti@2103	365	case T_DOUBLE: jni_fast_GetDoubleField_fp = (GetDoubleField_t) fast_entry; break;
duke@435	366	}
duke@435	367	return os::win32::fast_jni_accessor_wrapper(type);
duke@435	368	#endif
duke@435	369	}
duke@435	370
duke@435	371	address JNI_FastGetField::generate_fast_get_float_field() {
duke@435	372	return generate_fast_get_float_field0(T_FLOAT);
duke@435	373	}
duke@435	374
duke@435	375	address JNI_FastGetField::generate_fast_get_double_field() {
duke@435	376	return generate_fast_get_float_field0(T_DOUBLE);
duke@435	377	}