1 /* 2 * Copyright (c) 1997, 2017, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. 8 * 9 * This code is distributed in the hope that it will be useful, but WITHOUT 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 12 * version 2 for more details (a copy is included in the LICENSE file that 13 * accompanied this code). 14 * 15 * You should have received a copy of the GNU General Public License version 16 * 2 along with this work; if not, write to the Free Software Foundation, 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 18 * 19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 20 * or visit www.oracle.com if you need additional information or have any 21 * questions. 22 * 23 */ 24 25 #include "precompiled.hpp" 26 #include "code/debugInfo.hpp" 27 #include "oops/compressedOops.inline.hpp" 28 #include "oops/oop.hpp" 29 #include "runtime/frame.inline.hpp" 30 #include "runtime/handles.inline.hpp" 31 #include "oops/typeArrayOop.inline.hpp" 32 #include "runtime/interfaceSupport.inline.hpp" 33 #include "runtime/stackValue.hpp" 34 #if INCLUDE_ZGC 35 #include "gc/z/zBarrier.inline.hpp" 36 #endif 37 38 static BasicType klass2bt(InstanceKlass* ik, bool& is_mask) { 39 switch(vmSymbols::find_sid(ik->name())) { 40 // Vectors 41 case vmSymbols::VM_SYMBOL_ENUM_NAME(jdk_incubator_vector_Byte64Vector): 42 case vmSymbols::VM_SYMBOL_ENUM_NAME(jdk_incubator_vector_Byte128Vector): 43 case vmSymbols::VM_SYMBOL_ENUM_NAME(jdk_incubator_vector_Byte256Vector): 44 case vmSymbols::VM_SYMBOL_ENUM_NAME(jdk_incubator_vector_Byte512Vector): 45 is_mask = false; 46 return T_BYTE; 47 48 case vmSymbols::VM_SYMBOL_ENUM_NAME(jdk_incubator_vector_Short64Vector): 49 case vmSymbols::VM_SYMBOL_ENUM_NAME(jdk_incubator_vector_Short128Vector): 50 case vmSymbols::VM_SYMBOL_ENUM_NAME(jdk_incubator_vector_Short256Vector): 51 case vmSymbols::VM_SYMBOL_ENUM_NAME(jdk_incubator_vector_Short512Vector): 52 is_mask = false; 53 return T_SHORT; 54 55 case vmSymbols::VM_SYMBOL_ENUM_NAME(jdk_incubator_vector_Int64Vector): 56 case vmSymbols::VM_SYMBOL_ENUM_NAME(jdk_incubator_vector_Int128Vector): 57 case vmSymbols::VM_SYMBOL_ENUM_NAME(jdk_incubator_vector_Int256Vector): 58 case vmSymbols::VM_SYMBOL_ENUM_NAME(jdk_incubator_vector_Int512Vector): 59 is_mask = false; 60 return T_INT; 61 62 case vmSymbols::VM_SYMBOL_ENUM_NAME(jdk_incubator_vector_Long64Vector): 63 case vmSymbols::VM_SYMBOL_ENUM_NAME(jdk_incubator_vector_Long128Vector): 64 case vmSymbols::VM_SYMBOL_ENUM_NAME(jdk_incubator_vector_Long256Vector): 65 case vmSymbols::VM_SYMBOL_ENUM_NAME(jdk_incubator_vector_Long512Vector): 66 is_mask = false; 67 return T_LONG; 68 69 case vmSymbols::VM_SYMBOL_ENUM_NAME(jdk_incubator_vector_Float64Vector): 70 case vmSymbols::VM_SYMBOL_ENUM_NAME(jdk_incubator_vector_Float128Vector): 71 case vmSymbols::VM_SYMBOL_ENUM_NAME(jdk_incubator_vector_Float256Vector): 72 case vmSymbols::VM_SYMBOL_ENUM_NAME(jdk_incubator_vector_Float512Vector): 73 is_mask = false; 74 return T_FLOAT; 75 76 case vmSymbols::VM_SYMBOL_ENUM_NAME(jdk_incubator_vector_Double64Vector): 77 case vmSymbols::VM_SYMBOL_ENUM_NAME(jdk_incubator_vector_Double128Vector): 78 case vmSymbols::VM_SYMBOL_ENUM_NAME(jdk_incubator_vector_Double256Vector): 79 case vmSymbols::VM_SYMBOL_ENUM_NAME(jdk_incubator_vector_Double512Vector): 80 is_mask = false; 81 return T_DOUBLE; 82 83 // Masks 84 case vmSymbols::VM_SYMBOL_ENUM_NAME(jdk_incubator_vector_Byte64Vector_Byte64Mask): 85 case vmSymbols::VM_SYMBOL_ENUM_NAME(jdk_incubator_vector_Byte128Vector_Byte128Mask): 86 case vmSymbols::VM_SYMBOL_ENUM_NAME(jdk_incubator_vector_Byte256Vector_Byte256Mask): 87 case vmSymbols::VM_SYMBOL_ENUM_NAME(jdk_incubator_vector_Byte512Vector_Byte512Mask): 88 is_mask = true; 89 return T_BYTE; 90 91 case vmSymbols::VM_SYMBOL_ENUM_NAME(jdk_incubator_vector_Short64Vector_Short64Mask): 92 case vmSymbols::VM_SYMBOL_ENUM_NAME(jdk_incubator_vector_Short128Vector_Short128Mask): 93 case vmSymbols::VM_SYMBOL_ENUM_NAME(jdk_incubator_vector_Short256Vector_Short256Mask): 94 case vmSymbols::VM_SYMBOL_ENUM_NAME(jdk_incubator_vector_Short512Vector_Short512Mask): 95 is_mask = true; 96 return T_SHORT; 97 98 case vmSymbols::VM_SYMBOL_ENUM_NAME(jdk_incubator_vector_Int64Vector_Int64Mask): 99 case vmSymbols::VM_SYMBOL_ENUM_NAME(jdk_incubator_vector_Int128Vector_Int128Mask): 100 case vmSymbols::VM_SYMBOL_ENUM_NAME(jdk_incubator_vector_Int256Vector_Int256Mask): 101 case vmSymbols::VM_SYMBOL_ENUM_NAME(jdk_incubator_vector_Int512Vector_Int512Mask): 102 is_mask = true; 103 return T_INT; 104 105 // LongMask 106 case vmSymbols::VM_SYMBOL_ENUM_NAME(jdk_incubator_vector_Long64Vector_Long64Mask): 107 case vmSymbols::VM_SYMBOL_ENUM_NAME(jdk_incubator_vector_Long128Vector_Long128Mask): 108 case vmSymbols::VM_SYMBOL_ENUM_NAME(jdk_incubator_vector_Long256Vector_Long256Mask): 109 case vmSymbols::VM_SYMBOL_ENUM_NAME(jdk_incubator_vector_Long512Vector_Long512Mask): 110 is_mask = true; 111 return T_LONG; 112 113 // FloatMask 114 case vmSymbols::VM_SYMBOL_ENUM_NAME(jdk_incubator_vector_Float64Vector_Float64Mask): 115 case vmSymbols::VM_SYMBOL_ENUM_NAME(jdk_incubator_vector_Float128Vector_Float128Mask): 116 case vmSymbols::VM_SYMBOL_ENUM_NAME(jdk_incubator_vector_Float256Vector_Float256Mask): 117 case vmSymbols::VM_SYMBOL_ENUM_NAME(jdk_incubator_vector_Float512Vector_Float512Mask): 118 is_mask = true; 119 return T_INT; 120 121 // DoubleMask 122 case vmSymbols::VM_SYMBOL_ENUM_NAME(jdk_incubator_vector_Double64Vector_Double64Mask): 123 case vmSymbols::VM_SYMBOL_ENUM_NAME(jdk_incubator_vector_Double128Vector_Double128Mask): 124 case vmSymbols::VM_SYMBOL_ENUM_NAME(jdk_incubator_vector_Double256Vector_Double256Mask): 125 case vmSymbols::VM_SYMBOL_ENUM_NAME(jdk_incubator_vector_Double512Vector_Double512Mask): 126 is_mask = true; 127 return T_LONG; 128 129 default: 130 fatal("unknown klass: %s", ik->name()->as_utf8()); 131 return T_ILLEGAL; 132 } 133 } 134 135 static int klass2bytes(InstanceKlass* ik) { 136 switch(vmSymbols::find_sid(ik->name())) { 137 case vmSymbols::VM_SYMBOL_ENUM_NAME(jdk_incubator_vector_Byte64Vector): 138 case vmSymbols::VM_SYMBOL_ENUM_NAME(jdk_incubator_vector_Byte64Vector_Byte64Mask): 139 case vmSymbols::VM_SYMBOL_ENUM_NAME(jdk_incubator_vector_Short64Vector): 140 case vmSymbols::VM_SYMBOL_ENUM_NAME(jdk_incubator_vector_Short64Vector_Short64Mask): 141 case vmSymbols::VM_SYMBOL_ENUM_NAME(jdk_incubator_vector_Int64Vector): 142 case vmSymbols::VM_SYMBOL_ENUM_NAME(jdk_incubator_vector_Int64Vector_Int64Mask): 143 case vmSymbols::VM_SYMBOL_ENUM_NAME(jdk_incubator_vector_Long64Vector): 144 case vmSymbols::VM_SYMBOL_ENUM_NAME(jdk_incubator_vector_Long64Vector_Long64Mask): 145 case vmSymbols::VM_SYMBOL_ENUM_NAME(jdk_incubator_vector_Float64Vector): 146 case vmSymbols::VM_SYMBOL_ENUM_NAME(jdk_incubator_vector_Float64Vector_Float64Mask): 147 case vmSymbols::VM_SYMBOL_ENUM_NAME(jdk_incubator_vector_Double64Vector): 148 case vmSymbols::VM_SYMBOL_ENUM_NAME(jdk_incubator_vector_Double64Vector_Double64Mask): 149 return (64 / 8); 150 151 case vmSymbols::VM_SYMBOL_ENUM_NAME(jdk_incubator_vector_Byte128Vector): 152 case vmSymbols::VM_SYMBOL_ENUM_NAME(jdk_incubator_vector_Byte128Vector_Byte128Mask): 153 case vmSymbols::VM_SYMBOL_ENUM_NAME(jdk_incubator_vector_Short128Vector): 154 case vmSymbols::VM_SYMBOL_ENUM_NAME(jdk_incubator_vector_Short128Vector_Short128Mask): 155 case vmSymbols::VM_SYMBOL_ENUM_NAME(jdk_incubator_vector_Int128Vector): 156 case vmSymbols::VM_SYMBOL_ENUM_NAME(jdk_incubator_vector_Int128Vector_Int128Mask): 157 case vmSymbols::VM_SYMBOL_ENUM_NAME(jdk_incubator_vector_Long128Vector): 158 case vmSymbols::VM_SYMBOL_ENUM_NAME(jdk_incubator_vector_Long128Vector_Long128Mask): 159 case vmSymbols::VM_SYMBOL_ENUM_NAME(jdk_incubator_vector_Float128Vector): 160 case vmSymbols::VM_SYMBOL_ENUM_NAME(jdk_incubator_vector_Float128Vector_Float128Mask): 161 case vmSymbols::VM_SYMBOL_ENUM_NAME(jdk_incubator_vector_Double128Vector): 162 case vmSymbols::VM_SYMBOL_ENUM_NAME(jdk_incubator_vector_Double128Vector_Double128Mask): 163 return (128 / 8); 164 165 case vmSymbols::VM_SYMBOL_ENUM_NAME(jdk_incubator_vector_Byte256Vector): 166 case vmSymbols::VM_SYMBOL_ENUM_NAME(jdk_incubator_vector_Byte256Vector_Byte256Mask): 167 case vmSymbols::VM_SYMBOL_ENUM_NAME(jdk_incubator_vector_Short256Vector): 168 case vmSymbols::VM_SYMBOL_ENUM_NAME(jdk_incubator_vector_Short256Vector_Short256Mask): 169 case vmSymbols::VM_SYMBOL_ENUM_NAME(jdk_incubator_vector_Int256Vector): 170 case vmSymbols::VM_SYMBOL_ENUM_NAME(jdk_incubator_vector_Int256Vector_Int256Mask): 171 case vmSymbols::VM_SYMBOL_ENUM_NAME(jdk_incubator_vector_Long256Vector): 172 case vmSymbols::VM_SYMBOL_ENUM_NAME(jdk_incubator_vector_Long256Vector_Long256Mask): 173 case vmSymbols::VM_SYMBOL_ENUM_NAME(jdk_incubator_vector_Float256Vector): 174 case vmSymbols::VM_SYMBOL_ENUM_NAME(jdk_incubator_vector_Float256Vector_Float256Mask): 175 case vmSymbols::VM_SYMBOL_ENUM_NAME(jdk_incubator_vector_Double256Vector): 176 case vmSymbols::VM_SYMBOL_ENUM_NAME(jdk_incubator_vector_Double256Vector_Double256Mask): 177 return (256 / 8); 178 179 case vmSymbols::VM_SYMBOL_ENUM_NAME(jdk_incubator_vector_Byte512Vector): 180 case vmSymbols::VM_SYMBOL_ENUM_NAME(jdk_incubator_vector_Byte512Vector_Byte512Mask): 181 case vmSymbols::VM_SYMBOL_ENUM_NAME(jdk_incubator_vector_Short512Vector): 182 case vmSymbols::VM_SYMBOL_ENUM_NAME(jdk_incubator_vector_Short512Vector_Short512Mask): 183 case vmSymbols::VM_SYMBOL_ENUM_NAME(jdk_incubator_vector_Int512Vector): 184 case vmSymbols::VM_SYMBOL_ENUM_NAME(jdk_incubator_vector_Int512Vector_Int512Mask): 185 case vmSymbols::VM_SYMBOL_ENUM_NAME(jdk_incubator_vector_Long512Vector): 186 case vmSymbols::VM_SYMBOL_ENUM_NAME(jdk_incubator_vector_Long512Vector_Long512Mask): 187 case vmSymbols::VM_SYMBOL_ENUM_NAME(jdk_incubator_vector_Float512Vector): 188 case vmSymbols::VM_SYMBOL_ENUM_NAME(jdk_incubator_vector_Float512Vector_Float512Mask): 189 case vmSymbols::VM_SYMBOL_ENUM_NAME(jdk_incubator_vector_Double512Vector): 190 case vmSymbols::VM_SYMBOL_ENUM_NAME(jdk_incubator_vector_Double512Vector_Double512Mask): 191 return (512 / 8); 192 193 default: 194 fatal("unknown klass: %s", ik->name()->as_utf8()); 195 return -1; 196 } 197 } 198 199 static void init_vector_array(typeArrayOop arr, BasicType elem_bt, int num_elem, address value_addr) { 200 int elem_size = type2aelembytes(elem_bt); 201 202 for (int i = 0; i < num_elem; i++) { 203 switch (elem_bt) { 204 case T_BYTE: { 205 jbyte elem_value = *(jbyte*) (value_addr + i * elem_size); 206 arr->byte_at_put(i, elem_value); 207 break; 208 } 209 case T_SHORT: { 210 jshort elem_value = *(jshort*) (value_addr + i * elem_size); 211 arr->short_at_put(i, elem_value); 212 break; 213 } 214 case T_INT: { 215 jint elem_value = *(jint*) (value_addr + i * elem_size); 216 arr->int_at_put(i, elem_value); 217 break; 218 } 219 case T_LONG: { 220 jlong elem_value = *(jlong*) (value_addr + i * elem_size); 221 arr->long_at_put(i, elem_value); 222 break; 223 } 224 case T_FLOAT: { 225 jfloat elem_value = *(jfloat*) (value_addr + i * elem_size); 226 arr->float_at_put(i, elem_value); 227 break; 228 } 229 case T_DOUBLE: { 230 jdouble elem_value = *(jdouble*) (value_addr + i * elem_size); 231 arr->double_at_put(i, elem_value); 232 break; 233 } 234 default: 235 fatal("unsupported: %s", type2name(elem_bt)); 236 } 237 } 238 } 239 240 static void init_mask_array(typeArrayOop arr, BasicType elem_bt, int num_elem, address value_addr) { 241 int elem_size = type2aelembytes(elem_bt); 242 243 for (int i = 0; i < num_elem; i++) { 244 switch (elem_bt) { 245 case T_BYTE: { 246 jbyte elem_value = *(jbyte*) (value_addr + i * elem_size); 247 arr->bool_at_put(i, elem_value != 0); 248 break; 249 } 250 case T_SHORT: { 251 jshort elem_value = *(jshort*) (value_addr + i * elem_size); 252 arr->bool_at_put(i, elem_value != 0); 253 break; 254 } 255 case T_INT: { 256 jint elem_value = *(jint*) (value_addr + i * elem_size); 257 arr->bool_at_put(i, elem_value != 0); 258 break; 259 } 260 case T_LONG: { 261 jlong elem_value = *(jlong*) (value_addr + i * elem_size); 262 arr->bool_at_put(i, elem_value != 0); 263 break; 264 } 265 default: 266 fatal("unsupported: %s", type2name(elem_bt)); 267 } 268 } 269 } 270 271 static oop allocate_vector(InstanceKlass* ik, address value_addr) { 272 bool is_mask = false; // overwritten by klass2bt 273 BasicType elem_bt = klass2bt(ik, is_mask); 274 int num_elem = klass2bytes(ik) / type2aelembytes(elem_bt); 275 assert(!is_mask || (elem_bt != T_FLOAT && elem_bt != T_DOUBLE), "%s", type2name(elem_bt)); 276 TypeArrayKlass* ak = TypeArrayKlass::cast(Universe::typeArrayKlassObj(is_mask ? T_BOOLEAN : elem_bt)); 277 JavaThread* thread = JavaThread::current(); 278 JRT_BLOCK 279 typeArrayOop arr = ak->allocate(num_elem, THREAD); 280 if (is_mask) { 281 init_mask_array(arr, elem_bt, num_elem, value_addr); 282 } else { 283 init_vector_array(arr, elem_bt, num_elem, value_addr); 284 } 285 return arr; 286 JRT_END 287 } 288 289 StackValue* StackValue::create_stack_value(const frame* fr, const RegisterMap* reg_map, ScopeValue* sv, InstanceKlass* ik) { 290 if (sv->is_location()) { 291 // Stack or register value 292 Location loc = ((LocationValue *)sv)->location(); 293 294 #ifdef SPARC 295 // %%%%% Callee-save floats will NOT be working on a Sparc until we 296 // handle the case of a 2 floats in a single double register. 297 assert( !(loc.is_register() && loc.type() == Location::float_in_dbl), "Sparc does not handle callee-save floats yet" ); 298 #endif // SPARC 299 300 // First find address of value 301 302 address value_addr = loc.is_register() 303 // Value was in a callee-save register 304 ? reg_map->location(VMRegImpl::as_VMReg(loc.register_number())) 305 // Else value was directly saved on the stack. The frame's original stack pointer, 306 // before any extension by its callee (due to Compiler1 linkage on SPARC), must be used. 307 : ((address)fr->unextended_sp()) + loc.stack_offset(); 308 309 // Then package it right depending on type 310 // Note: the transfer of the data is thru a union that contains 311 // an intptr_t. This is because an interpreter stack slot is 312 // really an intptr_t. The use of a union containing an intptr_t 313 // ensures that on a 64 bit platform we have proper alignment 314 // and that we store the value where the interpreter will expect 315 // to find it (i.e. proper endian). Similarly on a 32bit platform 316 // using the intptr_t ensures that when a value is larger than 317 // a stack slot (jlong/jdouble) that we capture the proper part 318 // of the value for the stack slot in question. 319 // 320 switch( loc.type() ) { 321 case Location::float_in_dbl: { // Holds a float in a double register? 322 // The callee has no clue whether the register holds a float, 323 // double or is unused. He always saves a double. Here we know 324 // a double was saved, but we only want a float back. Narrow the 325 // saved double to the float that the JVM wants. 326 assert( loc.is_register(), "floats always saved to stack in 1 word" ); 327 union { intptr_t p; jfloat jf; } value; 328 value.p = (intptr_t) CONST64(0xDEADDEAFDEADDEAF); 329 value.jf = (jfloat) *(jdouble*) value_addr; 330 return new StackValue(value.p); // 64-bit high half is stack junk 331 } 332 case Location::int_in_long: { // Holds an int in a long register? 333 // The callee has no clue whether the register holds an int, 334 // long or is unused. He always saves a long. Here we know 335 // a long was saved, but we only want an int back. Narrow the 336 // saved long to the int that the JVM wants. 337 assert( loc.is_register(), "ints always saved to stack in 1 word" ); 338 union { intptr_t p; jint ji;} value; 339 value.p = (intptr_t) CONST64(0xDEADDEAFDEADDEAF); 340 value.ji = (jint) *(jlong*) value_addr; 341 return new StackValue(value.p); // 64-bit high half is stack junk 342 } 343 #ifdef _LP64 344 case Location::dbl: 345 // Double value in an aligned adjacent pair 346 return new StackValue(*(intptr_t*)value_addr); 347 case Location::lng: 348 // Long value in an aligned adjacent pair 349 return new StackValue(*(intptr_t*)value_addr); 350 case Location::vector: { 351 assert(ik != NULL /*&& ik->is_vector_box()*/, ""); 352 // Vector value in an aligned adjacent tuple (4, 8, or 16 slots). 353 Handle h(Thread::current(), allocate_vector(ik, value_addr)); // Wrap a handle around the oop 354 return new StackValue(h); 355 } 356 case Location::narrowoop: { 357 union { intptr_t p; narrowOop noop;} value; 358 value.p = (intptr_t) CONST64(0xDEADDEAFDEADDEAF); 359 if (loc.is_register()) { 360 // The callee has no clue whether the register holds an int, 361 // long or is unused. He always saves a long. Here we know 362 // a long was saved, but we only want an int back. Narrow the 363 // saved long to the int that the JVM wants. 364 value.noop = (narrowOop) *(julong*) value_addr; 365 } else { 366 value.noop = *(narrowOop*) value_addr; 367 } 368 // Decode narrowoop and wrap a handle around the oop 369 Handle h(Thread::current(), CompressedOops::decode(value.noop)); 370 return new StackValue(h); 371 } 372 #endif 373 case Location::oop: { 374 oop val = *(oop *)value_addr; 375 #ifdef _LP64 376 if (Universe::is_narrow_oop_base(val)) { 377 // Compiled code may produce decoded oop = narrow_oop_base 378 // when a narrow oop implicit null check is used. 379 // The narrow_oop_base could be NULL or be the address 380 // of the page below heap. Use NULL value for both cases. 381 val = (oop)NULL; 382 } 383 #endif 384 #if INCLUDE_ZGC 385 // Deoptimization must make sure all oop have passed load barrier 386 if (UseZGC) { 387 val = ZBarrier::load_barrier_on_oop_field_preloaded((oop*)value_addr, val); 388 } 389 #endif 390 391 Handle h(Thread::current(), val); // Wrap a handle around the oop 392 return new StackValue(h); 393 } 394 case Location::addr: { 395 ShouldNotReachHere(); // both C1 and C2 now inline jsrs 396 } 397 case Location::normal: { 398 // Just copy all other bits straight through 399 union { intptr_t p; jint ji;} value; 400 value.p = (intptr_t) CONST64(0xDEADDEAFDEADDEAF); 401 value.ji = *(jint*)value_addr; 402 return new StackValue(value.p); 403 } 404 case Location::invalid: 405 return new StackValue(); 406 default: 407 ShouldNotReachHere(); 408 } 409 410 } else if (sv->is_constant_int()) { 411 // Constant int: treat same as register int. 412 union { intptr_t p; jint ji;} value; 413 value.p = (intptr_t) CONST64(0xDEADDEAFDEADDEAF); 414 value.ji = (jint)((ConstantIntValue*)sv)->value(); 415 return new StackValue(value.p); 416 } else if (sv->is_constant_oop()) { 417 // constant oop 418 return new StackValue(sv->as_ConstantOopReadValue()->value()); 419 #ifdef _LP64 420 } else if (sv->is_constant_double()) { 421 // Constant double in a single stack slot 422 union { intptr_t p; double d; } value; 423 value.p = (intptr_t) CONST64(0xDEADDEAFDEADDEAF); 424 value.d = ((ConstantDoubleValue *)sv)->value(); 425 return new StackValue(value.p); 426 } else if (sv->is_constant_long()) { 427 // Constant long in a single stack slot 428 union { intptr_t p; jlong jl; } value; 429 value.p = (intptr_t) CONST64(0xDEADDEAFDEADDEAF); 430 value.jl = ((ConstantLongValue *)sv)->value(); 431 return new StackValue(value.p); 432 #endif 433 } else if (sv->is_object()) { // Scalar replaced object in compiled frame 434 Handle ov = ((ObjectValue *)sv)->value(); 435 return new StackValue(ov, (ov.is_null()) ? 1 : 0); 436 } 437 438 // Unknown ScopeValue type 439 ShouldNotReachHere(); 440 return new StackValue((intptr_t) 0); // dummy 441 } 442 443 444 BasicLock* StackValue::resolve_monitor_lock(const frame* fr, Location location) { 445 assert(location.is_stack(), "for now we only look at the stack"); 446 int word_offset = location.stack_offset() / wordSize; 447 // (stack picture) 448 // high: [ ] word_offset + 1 449 // low [ ] word_offset 450 // 451 // sp-> [ ] 0 452 // the word_offset is the distance from the stack pointer to the lowest address 453 // The frame's original stack pointer, before any extension by its callee 454 // (due to Compiler1 linkage on SPARC), must be used. 455 return (BasicLock*) (fr->unextended_sp() + word_offset); 456 } 457 458 459 #ifndef PRODUCT 460 461 void StackValue::print_on(outputStream* st) const { 462 switch(_type) { 463 case T_INT: 464 st->print("%d (int) %f (float) %x (hex)", *(int *)&_integer_value, *(float *)&_integer_value, *(int *)&_integer_value); 465 break; 466 467 case T_OBJECT: 468 _handle_value()->print_value_on(st); 469 st->print(" <" INTPTR_FORMAT ">", p2i((address)_handle_value())); 470 break; 471 472 case T_ILLEGAL: // FIXME 473 st->print(" V@<" INTPTR_FORMAT ">", _integer_value); 474 break; 475 476 case T_CONFLICT: 477 st->print("conflict"); 478 break; 479 480 default: 481 ShouldNotReachHere(); 482 } 483 } 484 485 #endif