215 assert(TaggedStackInterpreter, "should not call this"); |
215 assert(TaggedStackInterpreter, "should not call this"); |
216 return ((frame::interpreter_frame_expression_stack_direction() * n) * |
216 return ((frame::interpreter_frame_expression_stack_direction() * n) * |
217 stackElementSize()) + tag_offset_in_bytes(); |
217 stackElementSize()) + tag_offset_in_bytes(); |
218 } |
218 } |
219 |
219 |
|
220 // access to stacked values according to type: |
|
221 static oop* oop_addr_in_slot(intptr_t* slot_addr) { |
|
222 return (oop*) slot_addr; |
|
223 } |
|
224 static jint* int_addr_in_slot(intptr_t* slot_addr) { |
|
225 if ((int) sizeof(jint) < wordSize && !Bytes::is_Java_byte_ordering_different()) |
|
226 // big-endian LP64 |
|
227 return (jint*)(slot_addr + 1) - 1; |
|
228 else |
|
229 return (jint*) slot_addr; |
|
230 } |
|
231 static jlong long_in_slot(intptr_t* slot_addr) { |
|
232 if (sizeof(intptr_t) >= sizeof(jlong)) { |
|
233 return *(jlong*) slot_addr; |
|
234 } else if (!TaggedStackInterpreter) { |
|
235 return Bytes::get_native_u8((address)slot_addr); |
|
236 } else { |
|
237 assert(sizeof(intptr_t) * 2 == sizeof(jlong), "ILP32"); |
|
238 // assemble the long in memory order (not arithmetic order) |
|
239 union { jlong j; jint i[2]; } u; |
|
240 u.i[0] = (jint) slot_addr[0*stackElementSize()]; |
|
241 u.i[1] = (jint) slot_addr[1*stackElementSize()]; |
|
242 return u.j; |
|
243 } |
|
244 } |
|
245 static void set_long_in_slot(intptr_t* slot_addr, jlong value) { |
|
246 if (sizeof(intptr_t) >= sizeof(jlong)) { |
|
247 *(jlong*) slot_addr = value; |
|
248 } else if (!TaggedStackInterpreter) { |
|
249 Bytes::put_native_u8((address)slot_addr, value); |
|
250 } else { |
|
251 assert(sizeof(intptr_t) * 2 == sizeof(jlong), "ILP32"); |
|
252 // assemble the long in memory order (not arithmetic order) |
|
253 union { jlong j; jint i[2]; } u; |
|
254 u.j = value; |
|
255 slot_addr[0*stackElementSize()] = (intptr_t) u.i[0]; |
|
256 slot_addr[1*stackElementSize()] = (intptr_t) u.i[1]; |
|
257 } |
|
258 } |
|
259 static void get_jvalue_in_slot(intptr_t* slot_addr, BasicType type, jvalue* value) { |
|
260 switch (type) { |
|
261 case T_BOOLEAN: value->z = *int_addr_in_slot(slot_addr); break; |
|
262 case T_CHAR: value->c = *int_addr_in_slot(slot_addr); break; |
|
263 case T_BYTE: value->b = *int_addr_in_slot(slot_addr); break; |
|
264 case T_SHORT: value->s = *int_addr_in_slot(slot_addr); break; |
|
265 case T_INT: value->i = *int_addr_in_slot(slot_addr); break; |
|
266 case T_LONG: value->j = long_in_slot(slot_addr); break; |
|
267 case T_FLOAT: value->f = *(jfloat*)int_addr_in_slot(slot_addr); break; |
|
268 case T_DOUBLE: value->d = jdouble_cast(long_in_slot(slot_addr)); break; |
|
269 case T_OBJECT: value->l = (jobject)*oop_addr_in_slot(slot_addr); break; |
|
270 default: ShouldNotReachHere(); |
|
271 } |
|
272 } |
|
273 static void set_jvalue_in_slot(intptr_t* slot_addr, BasicType type, jvalue* value) { |
|
274 switch (type) { |
|
275 case T_BOOLEAN: *int_addr_in_slot(slot_addr) = (value->z != 0); break; |
|
276 case T_CHAR: *int_addr_in_slot(slot_addr) = value->c; break; |
|
277 case T_BYTE: *int_addr_in_slot(slot_addr) = value->b; break; |
|
278 case T_SHORT: *int_addr_in_slot(slot_addr) = value->s; break; |
|
279 case T_INT: *int_addr_in_slot(slot_addr) = value->i; break; |
|
280 case T_LONG: set_long_in_slot(slot_addr, value->j); break; |
|
281 case T_FLOAT: *(jfloat*)int_addr_in_slot(slot_addr) = value->f; break; |
|
282 case T_DOUBLE: set_long_in_slot(slot_addr, jlong_cast(value->d)); break; |
|
283 case T_OBJECT: *oop_addr_in_slot(slot_addr) = (oop) value->l; break; |
|
284 default: ShouldNotReachHere(); |
|
285 } |
|
286 } |
220 }; |
287 }; |
221 |
288 |
222 //------------------------------------------------------------------------------------------------------------------------ |
289 //------------------------------------------------------------------------------------------------------------------------ |
223 // The interpreter generator. |
290 // The interpreter generator. |
224 |
291 |