Fri, 29 Apr 2011 11:15:30 -0700
Merge
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 |