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

src/cpu/sparc/vm/args.cc@1d7922586cf6 (annotated)

src/cpu/sparc/vm/args.cc

Tue, 24 Jul 2012 10:51:00 -0700

author

twisti

date

Tue, 24 Jul 2012 10:51:00 -0700

changeset 3969

1d7922586cf6

parent 1907

c18cbe5936b8

child 6876

710a3c8b516e

permissions

-rw-r--r--

7023639: JSR 292 method handle invocation needs a fast path for compiled code
6984705: JSR 292 method handle creation should not go through JNI
Summary: remove assembly code for JDK 7 chained method handles
Reviewed-by: jrose, twisti, kvn, mhaupt
Contributed-by: John Rose <john.r.rose@oracle.com>, Christian Thalinger <christian.thalinger@oracle.com>, Michael Haupt <michael.haupt@oracle.com>

duke@435	1	/*
trims@1907	2	* Copyright (c) 2002, 2006, 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
duke@435	25	#include <stdio.h>
duke@435	26	#include <string.h>
duke@435	27
duke@435	28	static const int R_O0_num = 1000;
duke@435	29	static const int R_I0_num = 2000;
duke@435	30	static const int R_F0_num = 3000;
duke@435	31	static const int R_F1_num = R_F0_num + 1;
duke@435	32	static const int R_F2_num = R_F0_num + 2;
duke@435	33	static const int STACK_num= 4000;
duke@435	34
duke@435	35	static bool LP64 = false;
duke@435	36	static bool LONGS_IN_ONE_ENTRY = false;
duke@435	37
duke@435	38	static const int Op_RegI = 'I';
duke@435	39	static const int Op_RegP = 'P';
duke@435	40	static const int Op_RegF = 'F';
duke@435	41	static const int Op_RegD = 'D';
duke@435	42	static const int Op_RegL = 'L';
duke@435	43	static const int SPARC_ARGS_IN_REGS_NUM=6;
duke@435	44
duke@435	45	static void print_reg( int reg ) {
duke@435	46	if( reg == 0 )
duke@435	47	printf("__"); // halve's
duke@435	48	else if( reg >= STACK_num && reg < STACK_num+100 )
duke@435	49	printf("S%d_",reg - STACK_num);
duke@435	50	else if( reg >= R_F0_num && reg < R_F0_num+100 )
duke@435	51	printf("F%d_",reg - R_F0_num);
duke@435	52	else if( reg >= R_O0_num && reg < R_O0_num+100 ) {
duke@435	53	if( LONGS_IN_ONE_ENTRY ) {
duke@435	54	reg -= R_O0_num;
duke@435	55	printf("O%d",reg>>1);
duke@435	56	printf(reg&1 ? "H" : "L");
duke@435	57	} else
duke@435	58	printf("O%d_",reg - R_O0_num);
duke@435	59	} else
duke@435	60	printf("Wretched: %d\n", reg);
duke@435	61	}
duke@435	62
duke@435	63	static void print_convention( int *sig, const char *s, int length ) {
duke@435	64	// Print it out
duke@435	65	for( int i = 0; i < length; i++) {
duke@435	66	if( sig[i] == 0 ) continue; // do not print 'halves'
duke@435	67	print_reg( sig[i] & 0xFFFF );
duke@435	68	int reg = sig[i] >> 16;
duke@435	69	if( reg ) {
duke@435	70	printf(":");
duke@435	71	print_reg( reg );
duke@435	72	} else {
duke@435	73	printf(" ");
duke@435	74	}
duke@435	75	printf(" ");
duke@435	76	}
duke@435	77	printf("\n");
duke@435	78	}
duke@435	79
duke@435	80	static int INT_SCALE( int x ) {
duke@435	81	return LONGS_IN_ONE_ENTRY ? (x<<1) : x;
duke@435	82	}
duke@435	83
duke@435	84	static void java_convention( int *sig, const char *s, int length ) {
duke@435	85	if( LP64 && !LONGS_IN_ONE_ENTRY ) {
duke@435	86	printf("LP64 and 2-reg longs not supported\n");
duke@435	87	return;
duke@435	88	}
duke@435	89	for( int i = 0; i < length; i++ )
duke@435	90	sig[i] = s[i]; // Reset sig array
duke@435	91	bool is_outgoing = true;
duke@435	92
duke@435	93	int int_base = (is_outgoing ? R_O0_num : R_I0_num);
duke@435	94
duke@435	95	// Convention is to pack the first 6 int/oop args into the first 6
duke@435	96	// registers (I0-I5), extras spill to the stack. Then pack the first
duke@435	97	// 32 float args into F0-F31, extras spill to the stack. Then pad
duke@435	98	// all register sets to align. Then put longs and doubles into the
duke@435	99	// same registers as they fit, else spill to the stack.
duke@435	100	int int_reg_max = SPARC_ARGS_IN_REGS_NUM;
duke@435	101	int flt_reg_max = 32;
duke@435	102
duke@435	103	// Count int/oop and float args. See how many stack slots we'll need
duke@435	104	// and where the longs & doubles will go.
duke@435	105	int int_reg_cnt = 0;
duke@435	106	int flt_reg_cnt = 0;
duke@435	107	int stk_reg_pairs = 0;
duke@435	108	for( int i = 0; i < length; i++) {
duke@435	109	switch( sig[i] ) {
duke@435	110	case Op_RegL: // Longs-in-1-reg compete with int args
duke@435	111	if( LONGS_IN_ONE_ENTRY ) {
duke@435	112	if( int_reg_cnt < int_reg_max ) int_reg_cnt++;
duke@435	113	}
duke@435	114	break;
duke@435	115	case Op_RegP:
duke@435	116	if( int_reg_cnt < int_reg_max ) int_reg_cnt++;
duke@435	117	else if( !LP64 ) stk_reg_pairs++;
duke@435	118	break;
duke@435	119	case Op_RegI:
duke@435	120	if( int_reg_cnt < int_reg_max ) int_reg_cnt++;
duke@435	121	else stk_reg_pairs++;
duke@435	122	break;
duke@435	123	case Op_RegF:
duke@435	124	if( flt_reg_cnt < flt_reg_max ) flt_reg_cnt++;
duke@435	125	else stk_reg_pairs++;
duke@435	126	break;
duke@435	127	}
duke@435	128	}
duke@435	129
duke@435	130	// This is where the longs/doubles start on the stack.
duke@435	131	stk_reg_pairs = (stk_reg_pairs+1) & ~1; // Round
duke@435	132
duke@435	133	int int_reg_pairs = (int_reg_cnt+1) & ~1; // 32-bit 2-reg longs only
duke@435	134	int flt_reg_pairs = (flt_reg_cnt+1) & ~1;
duke@435	135
duke@435	136	int stk_reg = 0;
duke@435	137	int int_reg = 0;
duke@435	138	int flt_reg = 0;
duke@435	139
duke@435	140	// Now do the signature layout
duke@435	141	for( int i = 0; i < length; i++) {
duke@435	142	int tmp = sig[i];
duke@435	143	if( tmp == Op_RegP )
duke@435	144	tmp = LP64 ? Op_RegL : Op_RegI; // Treat ptrs and ints or long accordingly
duke@435	145	switch( tmp ) {
duke@435	146	case Op_RegI:
duke@435	147	// case Op_RegP:
duke@435	148	if( int_reg < int_reg_max) tmp = INT_SCALE(int_reg++) + int_base;
duke@435	149	else tmp = STACK_num + stk_reg++;
duke@435	150	sig[i] = tmp;
duke@435	151	break;
duke@435	152
duke@435	153	case Op_RegL:
duke@435	154	if( sig[i] != Op_RegP && sig[i+1] != 'h' ) { printf("expecting (h)alf, found %c\n", sig[i+1]); return; }
duke@435	155	// case Op_RegP:
duke@435	156	if( LONGS_IN_ONE_ENTRY ) {
duke@435	157	if( int_reg < int_reg_max ) {
duke@435	158	tmp = INT_SCALE(int_reg++) + int_base;
duke@435	159	} else {
duke@435	160	tmp = STACK_num + stk_reg_pairs;
duke@435	161	stk_reg_pairs += 2;
duke@435	162	}
duke@435	163	} else {
duke@435	164	if( int_reg_pairs < int_reg_max ) {
duke@435	165	tmp = int_reg_pairs + int_base;
duke@435	166	int_reg_pairs += 2;
duke@435	167	} else {
duke@435	168	tmp = STACK_num + stk_reg_pairs;
duke@435	169	stk_reg_pairs += 2;
duke@435	170	}
duke@435	171	}
duke@435	172	sig[i] = tmp | (tmp+1)<<16; // Smear to pair
duke@435	173	break;
duke@435	174
duke@435	175	case Op_RegF:
duke@435	176	sig[i] = (flt_reg < flt_reg_max) ? (R_F0_num + flt_reg++) : STACK_num + stk_reg++;
duke@435	177	break;
duke@435	178	case Op_RegD:
duke@435	179	if( sig[i+1] != 'h' ) { printf("expecting (h)alf, found %c\n", sig[i+1]); return; }
duke@435	180	if( flt_reg_pairs < flt_reg_max ) {
duke@435	181	tmp = R_F0_num + flt_reg_pairs;
duke@435	182	flt_reg_pairs += 2;
duke@435	183	} else {
duke@435	184	tmp = STACK_num + stk_reg_pairs;
duke@435	185	stk_reg_pairs += 2;
duke@435	186	}
duke@435	187	sig[i] = tmp | (tmp+1)<<16; // Smear to pair
duke@435	188	break;
duke@435	189	case 'h': sig[i] = 0; break;
duke@435	190	default:
duke@435	191	printf("Bad character: %c\n", sig[i] );
duke@435	192	return;
duke@435	193	}
duke@435	194	}
duke@435	195
duke@435	196	printf("java ");
duke@435	197	printf(LP64 ? "LP64 " : "LP32 ");
duke@435	198	printf(LONGS_IN_ONE_ENTRY ? "long1: " : "long2: ");
duke@435	199	print_convention(sig,s,length);
duke@435	200	}
duke@435	201
duke@435	202	static int int_stk_helper( int i ) {
duke@435	203	if( i < 6 ) return R_O0_num + (LONGS_IN_ONE_ENTRY ? i<<1 : i);
duke@435	204	else return STACK_num + (LP64 ? i<<1 : i);
duke@435	205	}
duke@435	206
duke@435	207	static void native_convention( int *sig, const char *s, int length ) {
duke@435	208	if( LP64 && !LONGS_IN_ONE_ENTRY ) {
duke@435	209	printf("LP64 and 2-reg longs not supported\n");
duke@435	210	return;
duke@435	211	}
duke@435	212	for( int i = 0; i < length; i++ )
duke@435	213	sig[i] = s[i]; // Reset sig array
duke@435	214
duke@435	215	// The native convention is V8 if !LP64, which means the V8 convention is
duke@435	216	// used both with and without LONGS_IN_ONE_ENTRY, an unfortunate split. The
duke@435	217	// same actual machine registers are used, but they are named differently in
duke@435	218	// the LONGS_IN_ONE_ENTRY mode. The LP64 convention is the V9 convention
duke@435	219	// which is slightly more sane.
duke@435	220
duke@435	221	if( LP64 ) {
duke@435	222	// V9 convention: All things "as-if" on double-wide stack slots.
duke@435	223	// Hoist any int/ptr/long's in the first 6 to int regs.
duke@435	224	// Hoist any flt/dbl's in the first 16 dbl regs.
duke@435	225	int j = 0; // Count of actual args, not HALVES
duke@435	226	for( int i=0; i<length; i++, j++ ) {
duke@435	227	int tmp;
duke@435	228	switch( sig[i] ) {
duke@435	229	case Op_RegI:
duke@435	230	sig[i] = int_stk_helper( j );
duke@435	231	break;
duke@435	232	case Op_RegL:
duke@435	233	if( sig[i+1] != 'h' ) { printf("expecting (h)alf, found %c\n", sig[i+1]); return; }
duke@435	234	case Op_RegP:
duke@435	235	tmp = int_stk_helper( j );
duke@435	236	sig[i] = tmp | ((tmp+1) << 16); // Smear to pair
duke@435	237	break;
duke@435	238	case Op_RegF: // V9ism: floats go in ODD registers
duke@435	239	sig[i] = ((j < 16) ? R_F1_num : (STACK_num + 1)) + (j<<1);
duke@435	240	break;
duke@435	241	case Op_RegD: // V9ism: doubles go in EVEN/ODD regs
duke@435	242	tmp = ((j < 16) ? R_F0_num : STACK_num) + (j<<1);
duke@435	243	sig[i] = tmp | ((tmp+1) << 16); // Smear to pair
duke@435	244	break;
duke@435	245	case 'h': sig[i] = 0; j--; break; // Do not count HALVES
duke@435	246	default:
duke@435	247	printf("Bad character: %c\n", sig[i] );
duke@435	248	return;
duke@435	249	}
duke@435	250	}
duke@435	251
duke@435	252	} else {
duke@435	253	// V8 convention: first 6 things in O-regs, rest on stack.
duke@435	254	// Alignment is willy-nilly.
duke@435	255	for( int i=0; i<length; i++ ) {
duke@435	256	int tmp;
duke@435	257	switch( sig[i] ) {
duke@435	258	case Op_RegI:
duke@435	259	case Op_RegP:
duke@435	260	case Op_RegF:
duke@435	261	sig[i] = int_stk_helper( i );
duke@435	262	break;
duke@435	263	case Op_RegL:
duke@435	264	case Op_RegD:
duke@435	265	if( sig[i+1] != 'h' ) { printf("expecting (h)alf, found %c\n", sig[i+1]); return; }
duke@435	266	tmp = int_stk_helper( i );
duke@435	267	sig[i] = tmp | (int_stk_helper( i+1 ) << 16);
duke@435	268	break;
duke@435	269	case 'h': sig[i] = 0; break;
duke@435	270	default:
duke@435	271	printf("Bad character: %c\n", sig[i] );
duke@435	272	return;
duke@435	273	}
duke@435	274	}
duke@435	275	}
duke@435	276
duke@435	277	printf("natv ");
duke@435	278	printf(LP64 ? "LP64 " : "LP32 ");
duke@435	279	printf(LONGS_IN_ONE_ENTRY ? "long1: " : "long2: ");
duke@435	280	print_convention(sig,s,length);
duke@435	281	}
duke@435	282
duke@435	283	int main( int argc, char **argv ) {
duke@435	284
duke@435	285	if( argc != 2 ) {
duke@435	286	printf("Usage: args IPFLhDh... (Java argument string)\n");
duke@435	287	printf("Returns argument layout\n");
duke@435	288	return -1;
duke@435	289	}
duke@435	290
duke@435	291	const char *s = argv[1];
duke@435	292	int length = strlen(s);
duke@435	293	int sig[1000];
duke@435	294
duke@435	295	LP64 = false; LONGS_IN_ONE_ENTRY = false;
duke@435	296	java_convention( sig, s, length );
duke@435	297	LP64 = false; LONGS_IN_ONE_ENTRY = true;
duke@435	298	java_convention( sig, s, length );
duke@435	299	LP64 = true ; LONGS_IN_ONE_ENTRY = true;
duke@435	300	java_convention( sig, s, length );
duke@435	301
duke@435	302	LP64 = false; LONGS_IN_ONE_ENTRY = false;
duke@435	303	native_convention( sig, s, length );
duke@435	304	LP64 = false; LONGS_IN_ONE_ENTRY = true;
duke@435	305	native_convention( sig, s, length );
duke@435	306	LP64 = true ; LONGS_IN_ONE_ENTRY = true;
duke@435	307	native_convention( sig, s, length );
duke@435	308	}
duke@435	309