Mercurial > hg > truffle
diff src/cpu/sparc/vm/args.cc @ 0:a61af66fc99e jdk7-b24
Initial load
author | duke |
---|---|
date | Sat, 01 Dec 2007 00:00:00 +0000 |
parents | |
children | c18cbe5936b8 |
line wrap: on
line diff
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/cpu/sparc/vm/args.cc Sat Dec 01 00:00:00 2007 +0000 @@ -0,0 +1,309 @@ +/* + * Copyright 2002-2006 Sun Microsystems, Inc. All Rights Reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, + * CA 95054 USA or visit www.sun.com if you need additional information or + * have any questions. + * + */ + +#include <stdio.h> +#include <string.h> + +static const int R_O0_num = 1000; +static const int R_I0_num = 2000; +static const int R_F0_num = 3000; +static const int R_F1_num = R_F0_num + 1; +static const int R_F2_num = R_F0_num + 2; +static const int STACK_num= 4000; + +static bool LP64 = false; +static bool LONGS_IN_ONE_ENTRY = false; + +static const int Op_RegI = 'I'; +static const int Op_RegP = 'P'; +static const int Op_RegF = 'F'; +static const int Op_RegD = 'D'; +static const int Op_RegL = 'L'; +static const int SPARC_ARGS_IN_REGS_NUM=6; + +static void print_reg( int reg ) { + if( reg == 0 ) + printf("__"); // halve's + else if( reg >= STACK_num && reg < STACK_num+100 ) + printf("S%d_",reg - STACK_num); + else if( reg >= R_F0_num && reg < R_F0_num+100 ) + printf("F%d_",reg - R_F0_num); + else if( reg >= R_O0_num && reg < R_O0_num+100 ) { + if( LONGS_IN_ONE_ENTRY ) { + reg -= R_O0_num; + printf("O%d",reg>>1); + printf(reg&1 ? "H" : "L"); + } else + printf("O%d_",reg - R_O0_num); + } else + printf("Wretched: %d\n", reg); +} + +static void print_convention( int *sig, const char *s, int length ) { + // Print it out + for( int i = 0; i < length; i++) { + if( sig[i] == 0 ) continue; // do not print 'halves' + print_reg( sig[i] & 0xFFFF ); + int reg = sig[i] >> 16; + if( reg ) { + printf(":"); + print_reg( reg ); + } else { + printf(" "); + } + printf(" "); + } + printf("\n"); +} + +static int INT_SCALE( int x ) { + return LONGS_IN_ONE_ENTRY ? (x<<1) : x; +} + +static void java_convention( int *sig, const char *s, int length ) { + if( LP64 && !LONGS_IN_ONE_ENTRY ) { + printf("LP64 and 2-reg longs not supported\n"); + return; + } + for( int i = 0; i < length; i++ ) + sig[i] = s[i]; // Reset sig array + bool is_outgoing = true; + + int int_base = (is_outgoing ? R_O0_num : R_I0_num); + + // Convention is to pack the first 6 int/oop args into the first 6 + // registers (I0-I5), extras spill to the stack. Then pack the first + // 32 float args into F0-F31, extras spill to the stack. Then pad + // all register sets to align. Then put longs and doubles into the + // same registers as they fit, else spill to the stack. + int int_reg_max = SPARC_ARGS_IN_REGS_NUM; + int flt_reg_max = 32; + + // Count int/oop and float args. See how many stack slots we'll need + // and where the longs & doubles will go. + int int_reg_cnt = 0; + int flt_reg_cnt = 0; + int stk_reg_pairs = 0; + for( int i = 0; i < length; i++) { + switch( sig[i] ) { + case Op_RegL: // Longs-in-1-reg compete with int args + if( LONGS_IN_ONE_ENTRY ) { + if( int_reg_cnt < int_reg_max ) int_reg_cnt++; + } + break; + case Op_RegP: + if( int_reg_cnt < int_reg_max ) int_reg_cnt++; + else if( !LP64 ) stk_reg_pairs++; + break; + case Op_RegI: + if( int_reg_cnt < int_reg_max ) int_reg_cnt++; + else stk_reg_pairs++; + break; + case Op_RegF: + if( flt_reg_cnt < flt_reg_max ) flt_reg_cnt++; + else stk_reg_pairs++; + break; + } + } + + // This is where the longs/doubles start on the stack. + stk_reg_pairs = (stk_reg_pairs+1) & ~1; // Round + + int int_reg_pairs = (int_reg_cnt+1) & ~1; // 32-bit 2-reg longs only + int flt_reg_pairs = (flt_reg_cnt+1) & ~1; + + int stk_reg = 0; + int int_reg = 0; + int flt_reg = 0; + + // Now do the signature layout + for( int i = 0; i < length; i++) { + int tmp = sig[i]; + if( tmp == Op_RegP ) + tmp = LP64 ? Op_RegL : Op_RegI; // Treat ptrs and ints or long accordingly + switch( tmp ) { + case Op_RegI: +// case Op_RegP: + if( int_reg < int_reg_max) tmp = INT_SCALE(int_reg++) + int_base; + else tmp = STACK_num + stk_reg++; + sig[i] = tmp; + break; + + case Op_RegL: + if( sig[i] != Op_RegP && sig[i+1] != 'h' ) { printf("expecting (h)alf, found %c\n", sig[i+1]); return; } +// case Op_RegP: + if( LONGS_IN_ONE_ENTRY ) { + if( int_reg < int_reg_max ) { + tmp = INT_SCALE(int_reg++) + int_base; + } else { + tmp = STACK_num + stk_reg_pairs; + stk_reg_pairs += 2; + } + } else { + if( int_reg_pairs < int_reg_max ) { + tmp = int_reg_pairs + int_base; + int_reg_pairs += 2; + } else { + tmp = STACK_num + stk_reg_pairs; + stk_reg_pairs += 2; + } + } + sig[i] = tmp | (tmp+1)<<16; // Smear to pair + break; + + case Op_RegF: + sig[i] = (flt_reg < flt_reg_max) ? (R_F0_num + flt_reg++) : STACK_num + stk_reg++; + break; + case Op_RegD: + if( sig[i+1] != 'h' ) { printf("expecting (h)alf, found %c\n", sig[i+1]); return; } + if( flt_reg_pairs < flt_reg_max ) { + tmp = R_F0_num + flt_reg_pairs; + flt_reg_pairs += 2; + } else { + tmp = STACK_num + stk_reg_pairs; + stk_reg_pairs += 2; + } + sig[i] = tmp | (tmp+1)<<16; // Smear to pair + break; + case 'h': sig[i] = 0; break; + default: + printf("Bad character: %c\n", sig[i] ); + return; + } + } + + printf("java "); + printf(LP64 ? "LP64 " : "LP32 "); + printf(LONGS_IN_ONE_ENTRY ? "long1: " : "long2: "); + print_convention(sig,s,length); +} + +static int int_stk_helper( int i ) { + if( i < 6 ) return R_O0_num + (LONGS_IN_ONE_ENTRY ? i<<1 : i); + else return STACK_num + (LP64 ? i<<1 : i); +} + +static void native_convention( int *sig, const char *s, int length ) { + if( LP64 && !LONGS_IN_ONE_ENTRY ) { + printf("LP64 and 2-reg longs not supported\n"); + return; + } + for( int i = 0; i < length; i++ ) + sig[i] = s[i]; // Reset sig array + + // The native convention is V8 if !LP64, which means the V8 convention is + // used both with and without LONGS_IN_ONE_ENTRY, an unfortunate split. The + // same actual machine registers are used, but they are named differently in + // the LONGS_IN_ONE_ENTRY mode. The LP64 convention is the V9 convention + // which is slightly more sane. + + if( LP64 ) { + // V9 convention: All things "as-if" on double-wide stack slots. + // Hoist any int/ptr/long's in the first 6 to int regs. + // Hoist any flt/dbl's in the first 16 dbl regs. + int j = 0; // Count of actual args, not HALVES + for( int i=0; i<length; i++, j++ ) { + int tmp; + switch( sig[i] ) { + case Op_RegI: + sig[i] = int_stk_helper( j ); + break; + case Op_RegL: + if( sig[i+1] != 'h' ) { printf("expecting (h)alf, found %c\n", sig[i+1]); return; } + case Op_RegP: + tmp = int_stk_helper( j ); + sig[i] = tmp | ((tmp+1) << 16); // Smear to pair + break; + case Op_RegF: // V9ism: floats go in ODD registers + sig[i] = ((j < 16) ? R_F1_num : (STACK_num + 1)) + (j<<1); + break; + case Op_RegD: // V9ism: doubles go in EVEN/ODD regs + tmp = ((j < 16) ? R_F0_num : STACK_num) + (j<<1); + sig[i] = tmp | ((tmp+1) << 16); // Smear to pair + break; + case 'h': sig[i] = 0; j--; break; // Do not count HALVES + default: + printf("Bad character: %c\n", sig[i] ); + return; + } + } + + } else { + // V8 convention: first 6 things in O-regs, rest on stack. + // Alignment is willy-nilly. + for( int i=0; i<length; i++ ) { + int tmp; + switch( sig[i] ) { + case Op_RegI: + case Op_RegP: + case Op_RegF: + sig[i] = int_stk_helper( i ); + break; + case Op_RegL: + case Op_RegD: + if( sig[i+1] != 'h' ) { printf("expecting (h)alf, found %c\n", sig[i+1]); return; } + tmp = int_stk_helper( i ); + sig[i] = tmp | (int_stk_helper( i+1 ) << 16); + break; + case 'h': sig[i] = 0; break; + default: + printf("Bad character: %c\n", sig[i] ); + return; + } + } + } + + printf("natv "); + printf(LP64 ? "LP64 " : "LP32 "); + printf(LONGS_IN_ONE_ENTRY ? "long1: " : "long2: "); + print_convention(sig,s,length); +} + +int main( int argc, char **argv ) { + + if( argc != 2 ) { + printf("Usage: args IPFLhDh... (Java argument string)\n"); + printf("Returns argument layout\n"); + return -1; + } + + const char *s = argv[1]; + int length = strlen(s); + int sig[1000]; + + LP64 = false; LONGS_IN_ONE_ENTRY = false; + java_convention( sig, s, length ); + LP64 = false; LONGS_IN_ONE_ENTRY = true; + java_convention( sig, s, length ); + LP64 = true ; LONGS_IN_ONE_ENTRY = true; + java_convention( sig, s, length ); + + LP64 = false; LONGS_IN_ONE_ENTRY = false; + native_convention( sig, s, length ); + LP64 = false; LONGS_IN_ONE_ENTRY = true; + native_convention( sig, s, length ); + LP64 = true ; LONGS_IN_ONE_ENTRY = true; + native_convention( sig, s, length ); +} +