1 /*
2 * Copyright (c) 2000, 2014, 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 *
1087 // try/finally clause:
1088 if (temp_alloc != NULL) {
1089 FREE_C_HEAP_ARRAY(HeapWord, temp_alloc);
1090 }
1091
1092 // The anonymous class loader data has been artificially been kept alive to
1093 // this point. The mirror and any instances of this class have to keep
1094 // it alive afterwards.
1095 if (anon_klass() != NULL) {
1096 anon_klass->class_loader_data()->set_keep_alive(false);
1097 }
1098
1099 // let caller initialize it as needed...
1100
1101 return (jclass) res_jh;
1102 }
1103 UNSAFE_END
1104
1105
1106
1107 UNSAFE_ENTRY(void, Unsafe_MonitorEnter(JNIEnv *env, jobject unsafe, jobject jobj))
1108 UnsafeWrapper("Unsafe_MonitorEnter");
1109 {
1110 if (jobj == NULL) {
1111 THROW(vmSymbols::java_lang_NullPointerException());
1112 }
1113 Handle obj(thread, JNIHandles::resolve_non_null(jobj));
1114 ObjectSynchronizer::jni_enter(obj, CHECK);
1115 }
1116 UNSAFE_END
1117
1118
1119 UNSAFE_ENTRY(jboolean, Unsafe_TryMonitorEnter(JNIEnv *env, jobject unsafe, jobject jobj))
1120 UnsafeWrapper("Unsafe_TryMonitorEnter");
1121 {
1122 if (jobj == NULL) {
1123 THROW_(vmSymbols::java_lang_NullPointerException(), JNI_FALSE);
1124 }
1125 Handle obj(thread, JNIHandles::resolve_non_null(jobj));
1126 bool res = ObjectSynchronizer::jni_try_enter(obj, CHECK_0);
1127 return (res ? JNI_TRUE : JNI_FALSE);
1128 }
1129 UNSAFE_END
1130
1131
1132 UNSAFE_ENTRY(void, Unsafe_MonitorExit(JNIEnv *env, jobject unsafe, jobject jobj))
1133 UnsafeWrapper("Unsafe_MonitorExit");
1134 {
1135 if (jobj == NULL) {
1136 THROW(vmSymbols::java_lang_NullPointerException());
1137 }
1138 Handle obj(THREAD, JNIHandles::resolve_non_null(jobj));
1139 ObjectSynchronizer::jni_exit(obj(), CHECK);
1140 }
1141 UNSAFE_END
1142
1143
1144 UNSAFE_ENTRY(void, Unsafe_ThrowException(JNIEnv *env, jobject unsafe, jthrowable thr))
1145 UnsafeWrapper("Unsafe_ThrowException");
1146 {
1147 ThreadToNativeFromVM ttnfv(thread);
1148 env->Throw(thr);
1149 }
1150 UNSAFE_END
1151
1152 // JSR166 ------------------------------------------------------------------
1153
1154 UNSAFE_ENTRY(jboolean, Unsafe_CompareAndSwapObject(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jobject e_h, jobject x_h))
1155 UnsafeWrapper("Unsafe_CompareAndSwapObject");
1156 oop x = JNIHandles::resolve(x_h);
1157 oop e = JNIHandles::resolve(e_h);
1158 oop p = JNIHandles::resolve(obj);
1159 HeapWord* addr = (HeapWord *)index_oop_from_field_offset_long(p, offset);
1160 oop res = oopDesc::atomic_compare_exchange_oop(x, addr, e, true);
1161 jboolean success = (res == e);
1162 if (success)
1163 update_barrier_set((void*)addr, x);
1348 DECLARE_GETSETNATIVE(Double, D),
1349
1350 {CC"getAddress", CC"("ADR")"ADR, FN_PTR(Unsafe_GetNativeAddress)},
1351 {CC"putAddress", CC"("ADR""ADR")V", FN_PTR(Unsafe_SetNativeAddress)},
1352
1353 {CC"allocateMemory", CC"(J)"ADR, FN_PTR(Unsafe_AllocateMemory)},
1354 {CC"reallocateMemory", CC"("ADR"J)"ADR, FN_PTR(Unsafe_ReallocateMemory)},
1355 {CC"freeMemory", CC"("ADR")V", FN_PTR(Unsafe_FreeMemory)},
1356
1357 {CC"fieldOffset", CC"("FLD")I", FN_PTR(Unsafe_FieldOffset)},
1358 {CC"staticFieldBase", CC"("CLS")"OBJ, FN_PTR(Unsafe_StaticFieldBaseFromClass)},
1359 {CC"ensureClassInitialized",CC"("CLS")V", FN_PTR(Unsafe_EnsureClassInitialized)},
1360 {CC"arrayBaseOffset", CC"("CLS")I", FN_PTR(Unsafe_ArrayBaseOffset)},
1361 {CC"arrayIndexScale", CC"("CLS")I", FN_PTR(Unsafe_ArrayIndexScale)},
1362 {CC"addressSize", CC"()I", FN_PTR(Unsafe_AddressSize)},
1363 {CC"pageSize", CC"()I", FN_PTR(Unsafe_PageSize)},
1364
1365 {CC"defineClass", CC"("DC0_Args")"CLS, FN_PTR(Unsafe_DefineClass0)},
1366 {CC"defineClass", CC"("DC_Args")"CLS, FN_PTR(Unsafe_DefineClass)},
1367 {CC"allocateInstance", CC"("CLS")"OBJ, FN_PTR(Unsafe_AllocateInstance)},
1368 {CC"monitorEnter", CC"("OBJ")V", FN_PTR(Unsafe_MonitorEnter)},
1369 {CC"monitorExit", CC"("OBJ")V", FN_PTR(Unsafe_MonitorExit)},
1370 {CC"throwException", CC"("THR")V", FN_PTR(Unsafe_ThrowException)}
1371 };
1372
1373 // These are the methods prior to the JSR 166 changes in 1.5.0
1374 static JNINativeMethod methods_141[] = {
1375 {CC"getObject", CC"("OBJ"J)"OBJ"", FN_PTR(Unsafe_GetObject)},
1376 {CC"putObject", CC"("OBJ"J"OBJ")V", FN_PTR(Unsafe_SetObject)},
1377
1378 DECLARE_GETSETOOP_141(Boolean, Z),
1379 DECLARE_GETSETOOP_141(Byte, B),
1380 DECLARE_GETSETOOP_141(Short, S),
1381 DECLARE_GETSETOOP_141(Char, C),
1382 DECLARE_GETSETOOP_141(Int, I),
1383 DECLARE_GETSETOOP_141(Long, J),
1384 DECLARE_GETSETOOP_141(Float, F),
1385 DECLARE_GETSETOOP_141(Double, D),
1386
1387 DECLARE_GETSETNATIVE(Byte, B),
1388 DECLARE_GETSETNATIVE(Short, S),
1389 DECLARE_GETSETNATIVE(Char, C),
1394
1395 {CC"getAddress", CC"("ADR")"ADR, FN_PTR(Unsafe_GetNativeAddress)},
1396 {CC"putAddress", CC"("ADR""ADR")V", FN_PTR(Unsafe_SetNativeAddress)},
1397
1398 {CC"allocateMemory", CC"(J)"ADR, FN_PTR(Unsafe_AllocateMemory)},
1399 {CC"reallocateMemory", CC"("ADR"J)"ADR, FN_PTR(Unsafe_ReallocateMemory)},
1400 {CC"freeMemory", CC"("ADR")V", FN_PTR(Unsafe_FreeMemory)},
1401
1402 {CC"objectFieldOffset", CC"("FLD")J", FN_PTR(Unsafe_ObjectFieldOffset)},
1403 {CC"staticFieldOffset", CC"("FLD")J", FN_PTR(Unsafe_StaticFieldOffset)},
1404 {CC"staticFieldBase", CC"("FLD")"OBJ, FN_PTR(Unsafe_StaticFieldBaseFromField)},
1405 {CC"ensureClassInitialized",CC"("CLS")V", FN_PTR(Unsafe_EnsureClassInitialized)},
1406 {CC"arrayBaseOffset", CC"("CLS")I", FN_PTR(Unsafe_ArrayBaseOffset)},
1407 {CC"arrayIndexScale", CC"("CLS")I", FN_PTR(Unsafe_ArrayIndexScale)},
1408 {CC"addressSize", CC"()I", FN_PTR(Unsafe_AddressSize)},
1409 {CC"pageSize", CC"()I", FN_PTR(Unsafe_PageSize)},
1410
1411 {CC"defineClass", CC"("DC0_Args")"CLS, FN_PTR(Unsafe_DefineClass0)},
1412 {CC"defineClass", CC"("DC_Args")"CLS, FN_PTR(Unsafe_DefineClass)},
1413 {CC"allocateInstance", CC"("CLS")"OBJ, FN_PTR(Unsafe_AllocateInstance)},
1414 {CC"monitorEnter", CC"("OBJ")V", FN_PTR(Unsafe_MonitorEnter)},
1415 {CC"monitorExit", CC"("OBJ")V", FN_PTR(Unsafe_MonitorExit)},
1416 {CC"throwException", CC"("THR")V", FN_PTR(Unsafe_ThrowException)}
1417
1418 };
1419
1420 // These are the methods prior to the JSR 166 changes in 1.6.0
1421 static JNINativeMethod methods_15[] = {
1422 {CC"getObject", CC"("OBJ"J)"OBJ"", FN_PTR(Unsafe_GetObject)},
1423 {CC"putObject", CC"("OBJ"J"OBJ")V", FN_PTR(Unsafe_SetObject)},
1424 {CC"getObjectVolatile",CC"("OBJ"J)"OBJ"", FN_PTR(Unsafe_GetObjectVolatile)},
1425 {CC"putObjectVolatile",CC"("OBJ"J"OBJ")V", FN_PTR(Unsafe_SetObjectVolatile)},
1426
1427
1428 DECLARE_GETSETOOP(Boolean, Z),
1429 DECLARE_GETSETOOP(Byte, B),
1430 DECLARE_GETSETOOP(Short, S),
1431 DECLARE_GETSETOOP(Char, C),
1432 DECLARE_GETSETOOP(Int, I),
1433 DECLARE_GETSETOOP(Long, J),
1434 DECLARE_GETSETOOP(Float, F),
1435 DECLARE_GETSETOOP(Double, D),
1444
1445 {CC"getAddress", CC"("ADR")"ADR, FN_PTR(Unsafe_GetNativeAddress)},
1446 {CC"putAddress", CC"("ADR""ADR")V", FN_PTR(Unsafe_SetNativeAddress)},
1447
1448 {CC"allocateMemory", CC"(J)"ADR, FN_PTR(Unsafe_AllocateMemory)},
1449 {CC"reallocateMemory", CC"("ADR"J)"ADR, FN_PTR(Unsafe_ReallocateMemory)},
1450 {CC"freeMemory", CC"("ADR")V", FN_PTR(Unsafe_FreeMemory)},
1451
1452 {CC"objectFieldOffset", CC"("FLD")J", FN_PTR(Unsafe_ObjectFieldOffset)},
1453 {CC"staticFieldOffset", CC"("FLD")J", FN_PTR(Unsafe_StaticFieldOffset)},
1454 {CC"staticFieldBase", CC"("FLD")"OBJ, FN_PTR(Unsafe_StaticFieldBaseFromField)},
1455 {CC"ensureClassInitialized",CC"("CLS")V", FN_PTR(Unsafe_EnsureClassInitialized)},
1456 {CC"arrayBaseOffset", CC"("CLS")I", FN_PTR(Unsafe_ArrayBaseOffset)},
1457 {CC"arrayIndexScale", CC"("CLS")I", FN_PTR(Unsafe_ArrayIndexScale)},
1458 {CC"addressSize", CC"()I", FN_PTR(Unsafe_AddressSize)},
1459 {CC"pageSize", CC"()I", FN_PTR(Unsafe_PageSize)},
1460
1461 {CC"defineClass", CC"("DC0_Args")"CLS, FN_PTR(Unsafe_DefineClass0)},
1462 {CC"defineClass", CC"("DC_Args")"CLS, FN_PTR(Unsafe_DefineClass)},
1463 {CC"allocateInstance", CC"("CLS")"OBJ, FN_PTR(Unsafe_AllocateInstance)},
1464 {CC"monitorEnter", CC"("OBJ")V", FN_PTR(Unsafe_MonitorEnter)},
1465 {CC"monitorExit", CC"("OBJ")V", FN_PTR(Unsafe_MonitorExit)},
1466 {CC"throwException", CC"("THR")V", FN_PTR(Unsafe_ThrowException)},
1467 {CC"compareAndSwapObject", CC"("OBJ"J"OBJ""OBJ")Z", FN_PTR(Unsafe_CompareAndSwapObject)},
1468 {CC"compareAndSwapInt", CC"("OBJ"J""I""I"")Z", FN_PTR(Unsafe_CompareAndSwapInt)},
1469 {CC"compareAndSwapLong", CC"("OBJ"J""J""J"")Z", FN_PTR(Unsafe_CompareAndSwapLong)},
1470 {CC"park", CC"(ZJ)V", FN_PTR(Unsafe_Park)},
1471 {CC"unpark", CC"("OBJ")V", FN_PTR(Unsafe_Unpark)}
1472
1473 };
1474
1475 // These are the methods for 1.6.0 and 1.7.0
1476 static JNINativeMethod methods_16[] = {
1477 {CC"getObject", CC"("OBJ"J)"OBJ"", FN_PTR(Unsafe_GetObject)},
1478 {CC"putObject", CC"("OBJ"J"OBJ")V", FN_PTR(Unsafe_SetObject)},
1479 {CC"getObjectVolatile",CC"("OBJ"J)"OBJ"", FN_PTR(Unsafe_GetObjectVolatile)},
1480 {CC"putObjectVolatile",CC"("OBJ"J"OBJ")V", FN_PTR(Unsafe_SetObjectVolatile)},
1481
1482 DECLARE_GETSETOOP(Boolean, Z),
1483 DECLARE_GETSETOOP(Byte, B),
1484 DECLARE_GETSETOOP(Short, S),
1485 DECLARE_GETSETOOP(Char, C),
1498
1499 {CC"getAddress", CC"("ADR")"ADR, FN_PTR(Unsafe_GetNativeAddress)},
1500 {CC"putAddress", CC"("ADR""ADR")V", FN_PTR(Unsafe_SetNativeAddress)},
1501
1502 {CC"allocateMemory", CC"(J)"ADR, FN_PTR(Unsafe_AllocateMemory)},
1503 {CC"reallocateMemory", CC"("ADR"J)"ADR, FN_PTR(Unsafe_ReallocateMemory)},
1504 {CC"freeMemory", CC"("ADR")V", FN_PTR(Unsafe_FreeMemory)},
1505
1506 {CC"objectFieldOffset", CC"("FLD")J", FN_PTR(Unsafe_ObjectFieldOffset)},
1507 {CC"staticFieldOffset", CC"("FLD")J", FN_PTR(Unsafe_StaticFieldOffset)},
1508 {CC"staticFieldBase", CC"("FLD")"OBJ, FN_PTR(Unsafe_StaticFieldBaseFromField)},
1509 {CC"ensureClassInitialized",CC"("CLS")V", FN_PTR(Unsafe_EnsureClassInitialized)},
1510 {CC"arrayBaseOffset", CC"("CLS")I", FN_PTR(Unsafe_ArrayBaseOffset)},
1511 {CC"arrayIndexScale", CC"("CLS")I", FN_PTR(Unsafe_ArrayIndexScale)},
1512 {CC"addressSize", CC"()I", FN_PTR(Unsafe_AddressSize)},
1513 {CC"pageSize", CC"()I", FN_PTR(Unsafe_PageSize)},
1514
1515 {CC"defineClass", CC"("DC0_Args")"CLS, FN_PTR(Unsafe_DefineClass0)},
1516 {CC"defineClass", CC"("DC_Args")"CLS, FN_PTR(Unsafe_DefineClass)},
1517 {CC"allocateInstance", CC"("CLS")"OBJ, FN_PTR(Unsafe_AllocateInstance)},
1518 {CC"monitorEnter", CC"("OBJ")V", FN_PTR(Unsafe_MonitorEnter)},
1519 {CC"monitorExit", CC"("OBJ")V", FN_PTR(Unsafe_MonitorExit)},
1520 {CC"tryMonitorEnter", CC"("OBJ")Z", FN_PTR(Unsafe_TryMonitorEnter)},
1521 {CC"throwException", CC"("THR")V", FN_PTR(Unsafe_ThrowException)},
1522 {CC"compareAndSwapObject", CC"("OBJ"J"OBJ""OBJ")Z", FN_PTR(Unsafe_CompareAndSwapObject)},
1523 {CC"compareAndSwapInt", CC"("OBJ"J""I""I"")Z", FN_PTR(Unsafe_CompareAndSwapInt)},
1524 {CC"compareAndSwapLong", CC"("OBJ"J""J""J"")Z", FN_PTR(Unsafe_CompareAndSwapLong)},
1525 {CC"putOrderedObject", CC"("OBJ"J"OBJ")V", FN_PTR(Unsafe_SetOrderedObject)},
1526 {CC"putOrderedInt", CC"("OBJ"JI)V", FN_PTR(Unsafe_SetOrderedInt)},
1527 {CC"putOrderedLong", CC"("OBJ"JJ)V", FN_PTR(Unsafe_SetOrderedLong)},
1528 {CC"park", CC"(ZJ)V", FN_PTR(Unsafe_Park)},
1529 {CC"unpark", CC"("OBJ")V", FN_PTR(Unsafe_Unpark)}
1530 };
1531
1532 // These are the methods for 1.8.0
1533 static JNINativeMethod methods_18[] = {
1534 {CC"getObject", CC"("OBJ"J)"OBJ"", FN_PTR(Unsafe_GetObject)},
1535 {CC"putObject", CC"("OBJ"J"OBJ")V", FN_PTR(Unsafe_SetObject)},
1536 {CC"getObjectVolatile",CC"("OBJ"J)"OBJ"", FN_PTR(Unsafe_GetObjectVolatile)},
1537 {CC"putObjectVolatile",CC"("OBJ"J"OBJ")V", FN_PTR(Unsafe_SetObjectVolatile)},
1538
1539 DECLARE_GETSETOOP(Boolean, Z),
1540 DECLARE_GETSETOOP(Byte, B),
1554 DECLARE_GETSETNATIVE(Double, D),
1555
1556 {CC"getAddress", CC"("ADR")"ADR, FN_PTR(Unsafe_GetNativeAddress)},
1557 {CC"putAddress", CC"("ADR""ADR")V", FN_PTR(Unsafe_SetNativeAddress)},
1558
1559 {CC"allocateMemory", CC"(J)"ADR, FN_PTR(Unsafe_AllocateMemory)},
1560 {CC"reallocateMemory", CC"("ADR"J)"ADR, FN_PTR(Unsafe_ReallocateMemory)},
1561 {CC"freeMemory", CC"("ADR")V", FN_PTR(Unsafe_FreeMemory)},
1562
1563 {CC"objectFieldOffset", CC"("FLD")J", FN_PTR(Unsafe_ObjectFieldOffset)},
1564 {CC"staticFieldOffset", CC"("FLD")J", FN_PTR(Unsafe_StaticFieldOffset)},
1565 {CC"staticFieldBase", CC"("FLD")"OBJ, FN_PTR(Unsafe_StaticFieldBaseFromField)},
1566 {CC"ensureClassInitialized",CC"("CLS")V", FN_PTR(Unsafe_EnsureClassInitialized)},
1567 {CC"arrayBaseOffset", CC"("CLS")I", FN_PTR(Unsafe_ArrayBaseOffset)},
1568 {CC"arrayIndexScale", CC"("CLS")I", FN_PTR(Unsafe_ArrayIndexScale)},
1569 {CC"addressSize", CC"()I", FN_PTR(Unsafe_AddressSize)},
1570 {CC"pageSize", CC"()I", FN_PTR(Unsafe_PageSize)},
1571
1572 {CC"defineClass", CC"("DC_Args")"CLS, FN_PTR(Unsafe_DefineClass)},
1573 {CC"allocateInstance", CC"("CLS")"OBJ, FN_PTR(Unsafe_AllocateInstance)},
1574 {CC"monitorEnter", CC"("OBJ")V", FN_PTR(Unsafe_MonitorEnter)},
1575 {CC"monitorExit", CC"("OBJ")V", FN_PTR(Unsafe_MonitorExit)},
1576 {CC"tryMonitorEnter", CC"("OBJ")Z", FN_PTR(Unsafe_TryMonitorEnter)},
1577 {CC"throwException", CC"("THR")V", FN_PTR(Unsafe_ThrowException)},
1578 {CC"compareAndSwapObject", CC"("OBJ"J"OBJ""OBJ")Z", FN_PTR(Unsafe_CompareAndSwapObject)},
1579 {CC"compareAndSwapInt", CC"("OBJ"J""I""I"")Z", FN_PTR(Unsafe_CompareAndSwapInt)},
1580 {CC"compareAndSwapLong", CC"("OBJ"J""J""J"")Z", FN_PTR(Unsafe_CompareAndSwapLong)},
1581 {CC"putOrderedObject", CC"("OBJ"J"OBJ")V", FN_PTR(Unsafe_SetOrderedObject)},
1582 {CC"putOrderedInt", CC"("OBJ"JI)V", FN_PTR(Unsafe_SetOrderedInt)},
1583 {CC"putOrderedLong", CC"("OBJ"JJ)V", FN_PTR(Unsafe_SetOrderedLong)},
1584 {CC"park", CC"(ZJ)V", FN_PTR(Unsafe_Park)},
1585 {CC"unpark", CC"("OBJ")V", FN_PTR(Unsafe_Unpark)}
1586 };
1587
1588 JNINativeMethod loadavg_method[] = {
1589 {CC"getLoadAverage", CC"([DI)I", FN_PTR(Unsafe_Loadavg)}
1590 };
1591
1592 JNINativeMethod prefetch_methods[] = {
1593 {CC"prefetchRead", CC"("OBJ"J)V", FN_PTR(Unsafe_PrefetchRead)},
1594 {CC"prefetchWrite", CC"("OBJ"J)V", FN_PTR(Unsafe_PrefetchWrite)},
1595 {CC"prefetchReadStatic", CC"("OBJ"J)V", FN_PTR(Unsafe_PrefetchRead)},
1596 {CC"prefetchWriteStatic",CC"("OBJ"J)V", FN_PTR(Unsafe_PrefetchWrite)}
|
1 /*
2 * Copyright (c) 2000, 2015, 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 *
1087 // try/finally clause:
1088 if (temp_alloc != NULL) {
1089 FREE_C_HEAP_ARRAY(HeapWord, temp_alloc);
1090 }
1091
1092 // The anonymous class loader data has been artificially been kept alive to
1093 // this point. The mirror and any instances of this class have to keep
1094 // it alive afterwards.
1095 if (anon_klass() != NULL) {
1096 anon_klass->class_loader_data()->set_keep_alive(false);
1097 }
1098
1099 // let caller initialize it as needed...
1100
1101 return (jclass) res_jh;
1102 }
1103 UNSAFE_END
1104
1105
1106
1107 UNSAFE_ENTRY(void, Unsafe_ThrowException(JNIEnv *env, jobject unsafe, jthrowable thr))
1108 UnsafeWrapper("Unsafe_ThrowException");
1109 {
1110 ThreadToNativeFromVM ttnfv(thread);
1111 env->Throw(thr);
1112 }
1113 UNSAFE_END
1114
1115 // JSR166 ------------------------------------------------------------------
1116
1117 UNSAFE_ENTRY(jboolean, Unsafe_CompareAndSwapObject(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jobject e_h, jobject x_h))
1118 UnsafeWrapper("Unsafe_CompareAndSwapObject");
1119 oop x = JNIHandles::resolve(x_h);
1120 oop e = JNIHandles::resolve(e_h);
1121 oop p = JNIHandles::resolve(obj);
1122 HeapWord* addr = (HeapWord *)index_oop_from_field_offset_long(p, offset);
1123 oop res = oopDesc::atomic_compare_exchange_oop(x, addr, e, true);
1124 jboolean success = (res == e);
1125 if (success)
1126 update_barrier_set((void*)addr, x);
1311 DECLARE_GETSETNATIVE(Double, D),
1312
1313 {CC"getAddress", CC"("ADR")"ADR, FN_PTR(Unsafe_GetNativeAddress)},
1314 {CC"putAddress", CC"("ADR""ADR")V", FN_PTR(Unsafe_SetNativeAddress)},
1315
1316 {CC"allocateMemory", CC"(J)"ADR, FN_PTR(Unsafe_AllocateMemory)},
1317 {CC"reallocateMemory", CC"("ADR"J)"ADR, FN_PTR(Unsafe_ReallocateMemory)},
1318 {CC"freeMemory", CC"("ADR")V", FN_PTR(Unsafe_FreeMemory)},
1319
1320 {CC"fieldOffset", CC"("FLD")I", FN_PTR(Unsafe_FieldOffset)},
1321 {CC"staticFieldBase", CC"("CLS")"OBJ, FN_PTR(Unsafe_StaticFieldBaseFromClass)},
1322 {CC"ensureClassInitialized",CC"("CLS")V", FN_PTR(Unsafe_EnsureClassInitialized)},
1323 {CC"arrayBaseOffset", CC"("CLS")I", FN_PTR(Unsafe_ArrayBaseOffset)},
1324 {CC"arrayIndexScale", CC"("CLS")I", FN_PTR(Unsafe_ArrayIndexScale)},
1325 {CC"addressSize", CC"()I", FN_PTR(Unsafe_AddressSize)},
1326 {CC"pageSize", CC"()I", FN_PTR(Unsafe_PageSize)},
1327
1328 {CC"defineClass", CC"("DC0_Args")"CLS, FN_PTR(Unsafe_DefineClass0)},
1329 {CC"defineClass", CC"("DC_Args")"CLS, FN_PTR(Unsafe_DefineClass)},
1330 {CC"allocateInstance", CC"("CLS")"OBJ, FN_PTR(Unsafe_AllocateInstance)},
1331 {CC"throwException", CC"("THR")V", FN_PTR(Unsafe_ThrowException)}
1332 };
1333
1334 // These are the methods prior to the JSR 166 changes in 1.5.0
1335 static JNINativeMethod methods_141[] = {
1336 {CC"getObject", CC"("OBJ"J)"OBJ"", FN_PTR(Unsafe_GetObject)},
1337 {CC"putObject", CC"("OBJ"J"OBJ")V", FN_PTR(Unsafe_SetObject)},
1338
1339 DECLARE_GETSETOOP_141(Boolean, Z),
1340 DECLARE_GETSETOOP_141(Byte, B),
1341 DECLARE_GETSETOOP_141(Short, S),
1342 DECLARE_GETSETOOP_141(Char, C),
1343 DECLARE_GETSETOOP_141(Int, I),
1344 DECLARE_GETSETOOP_141(Long, J),
1345 DECLARE_GETSETOOP_141(Float, F),
1346 DECLARE_GETSETOOP_141(Double, D),
1347
1348 DECLARE_GETSETNATIVE(Byte, B),
1349 DECLARE_GETSETNATIVE(Short, S),
1350 DECLARE_GETSETNATIVE(Char, C),
1355
1356 {CC"getAddress", CC"("ADR")"ADR, FN_PTR(Unsafe_GetNativeAddress)},
1357 {CC"putAddress", CC"("ADR""ADR")V", FN_PTR(Unsafe_SetNativeAddress)},
1358
1359 {CC"allocateMemory", CC"(J)"ADR, FN_PTR(Unsafe_AllocateMemory)},
1360 {CC"reallocateMemory", CC"("ADR"J)"ADR, FN_PTR(Unsafe_ReallocateMemory)},
1361 {CC"freeMemory", CC"("ADR")V", FN_PTR(Unsafe_FreeMemory)},
1362
1363 {CC"objectFieldOffset", CC"("FLD")J", FN_PTR(Unsafe_ObjectFieldOffset)},
1364 {CC"staticFieldOffset", CC"("FLD")J", FN_PTR(Unsafe_StaticFieldOffset)},
1365 {CC"staticFieldBase", CC"("FLD")"OBJ, FN_PTR(Unsafe_StaticFieldBaseFromField)},
1366 {CC"ensureClassInitialized",CC"("CLS")V", FN_PTR(Unsafe_EnsureClassInitialized)},
1367 {CC"arrayBaseOffset", CC"("CLS")I", FN_PTR(Unsafe_ArrayBaseOffset)},
1368 {CC"arrayIndexScale", CC"("CLS")I", FN_PTR(Unsafe_ArrayIndexScale)},
1369 {CC"addressSize", CC"()I", FN_PTR(Unsafe_AddressSize)},
1370 {CC"pageSize", CC"()I", FN_PTR(Unsafe_PageSize)},
1371
1372 {CC"defineClass", CC"("DC0_Args")"CLS, FN_PTR(Unsafe_DefineClass0)},
1373 {CC"defineClass", CC"("DC_Args")"CLS, FN_PTR(Unsafe_DefineClass)},
1374 {CC"allocateInstance", CC"("CLS")"OBJ, FN_PTR(Unsafe_AllocateInstance)},
1375 {CC"throwException", CC"("THR")V", FN_PTR(Unsafe_ThrowException)}
1376
1377 };
1378
1379 // These are the methods prior to the JSR 166 changes in 1.6.0
1380 static JNINativeMethod methods_15[] = {
1381 {CC"getObject", CC"("OBJ"J)"OBJ"", FN_PTR(Unsafe_GetObject)},
1382 {CC"putObject", CC"("OBJ"J"OBJ")V", FN_PTR(Unsafe_SetObject)},
1383 {CC"getObjectVolatile",CC"("OBJ"J)"OBJ"", FN_PTR(Unsafe_GetObjectVolatile)},
1384 {CC"putObjectVolatile",CC"("OBJ"J"OBJ")V", FN_PTR(Unsafe_SetObjectVolatile)},
1385
1386
1387 DECLARE_GETSETOOP(Boolean, Z),
1388 DECLARE_GETSETOOP(Byte, B),
1389 DECLARE_GETSETOOP(Short, S),
1390 DECLARE_GETSETOOP(Char, C),
1391 DECLARE_GETSETOOP(Int, I),
1392 DECLARE_GETSETOOP(Long, J),
1393 DECLARE_GETSETOOP(Float, F),
1394 DECLARE_GETSETOOP(Double, D),
1403
1404 {CC"getAddress", CC"("ADR")"ADR, FN_PTR(Unsafe_GetNativeAddress)},
1405 {CC"putAddress", CC"("ADR""ADR")V", FN_PTR(Unsafe_SetNativeAddress)},
1406
1407 {CC"allocateMemory", CC"(J)"ADR, FN_PTR(Unsafe_AllocateMemory)},
1408 {CC"reallocateMemory", CC"("ADR"J)"ADR, FN_PTR(Unsafe_ReallocateMemory)},
1409 {CC"freeMemory", CC"("ADR")V", FN_PTR(Unsafe_FreeMemory)},
1410
1411 {CC"objectFieldOffset", CC"("FLD")J", FN_PTR(Unsafe_ObjectFieldOffset)},
1412 {CC"staticFieldOffset", CC"("FLD")J", FN_PTR(Unsafe_StaticFieldOffset)},
1413 {CC"staticFieldBase", CC"("FLD")"OBJ, FN_PTR(Unsafe_StaticFieldBaseFromField)},
1414 {CC"ensureClassInitialized",CC"("CLS")V", FN_PTR(Unsafe_EnsureClassInitialized)},
1415 {CC"arrayBaseOffset", CC"("CLS")I", FN_PTR(Unsafe_ArrayBaseOffset)},
1416 {CC"arrayIndexScale", CC"("CLS")I", FN_PTR(Unsafe_ArrayIndexScale)},
1417 {CC"addressSize", CC"()I", FN_PTR(Unsafe_AddressSize)},
1418 {CC"pageSize", CC"()I", FN_PTR(Unsafe_PageSize)},
1419
1420 {CC"defineClass", CC"("DC0_Args")"CLS, FN_PTR(Unsafe_DefineClass0)},
1421 {CC"defineClass", CC"("DC_Args")"CLS, FN_PTR(Unsafe_DefineClass)},
1422 {CC"allocateInstance", CC"("CLS")"OBJ, FN_PTR(Unsafe_AllocateInstance)},
1423 {CC"throwException", CC"("THR")V", FN_PTR(Unsafe_ThrowException)},
1424 {CC"compareAndSwapObject", CC"("OBJ"J"OBJ""OBJ")Z", FN_PTR(Unsafe_CompareAndSwapObject)},
1425 {CC"compareAndSwapInt", CC"("OBJ"J""I""I"")Z", FN_PTR(Unsafe_CompareAndSwapInt)},
1426 {CC"compareAndSwapLong", CC"("OBJ"J""J""J"")Z", FN_PTR(Unsafe_CompareAndSwapLong)},
1427 {CC"park", CC"(ZJ)V", FN_PTR(Unsafe_Park)},
1428 {CC"unpark", CC"("OBJ")V", FN_PTR(Unsafe_Unpark)}
1429
1430 };
1431
1432 // These are the methods for 1.6.0 and 1.7.0
1433 static JNINativeMethod methods_16[] = {
1434 {CC"getObject", CC"("OBJ"J)"OBJ"", FN_PTR(Unsafe_GetObject)},
1435 {CC"putObject", CC"("OBJ"J"OBJ")V", FN_PTR(Unsafe_SetObject)},
1436 {CC"getObjectVolatile",CC"("OBJ"J)"OBJ"", FN_PTR(Unsafe_GetObjectVolatile)},
1437 {CC"putObjectVolatile",CC"("OBJ"J"OBJ")V", FN_PTR(Unsafe_SetObjectVolatile)},
1438
1439 DECLARE_GETSETOOP(Boolean, Z),
1440 DECLARE_GETSETOOP(Byte, B),
1441 DECLARE_GETSETOOP(Short, S),
1442 DECLARE_GETSETOOP(Char, C),
1455
1456 {CC"getAddress", CC"("ADR")"ADR, FN_PTR(Unsafe_GetNativeAddress)},
1457 {CC"putAddress", CC"("ADR""ADR")V", FN_PTR(Unsafe_SetNativeAddress)},
1458
1459 {CC"allocateMemory", CC"(J)"ADR, FN_PTR(Unsafe_AllocateMemory)},
1460 {CC"reallocateMemory", CC"("ADR"J)"ADR, FN_PTR(Unsafe_ReallocateMemory)},
1461 {CC"freeMemory", CC"("ADR")V", FN_PTR(Unsafe_FreeMemory)},
1462
1463 {CC"objectFieldOffset", CC"("FLD")J", FN_PTR(Unsafe_ObjectFieldOffset)},
1464 {CC"staticFieldOffset", CC"("FLD")J", FN_PTR(Unsafe_StaticFieldOffset)},
1465 {CC"staticFieldBase", CC"("FLD")"OBJ, FN_PTR(Unsafe_StaticFieldBaseFromField)},
1466 {CC"ensureClassInitialized",CC"("CLS")V", FN_PTR(Unsafe_EnsureClassInitialized)},
1467 {CC"arrayBaseOffset", CC"("CLS")I", FN_PTR(Unsafe_ArrayBaseOffset)},
1468 {CC"arrayIndexScale", CC"("CLS")I", FN_PTR(Unsafe_ArrayIndexScale)},
1469 {CC"addressSize", CC"()I", FN_PTR(Unsafe_AddressSize)},
1470 {CC"pageSize", CC"()I", FN_PTR(Unsafe_PageSize)},
1471
1472 {CC"defineClass", CC"("DC0_Args")"CLS, FN_PTR(Unsafe_DefineClass0)},
1473 {CC"defineClass", CC"("DC_Args")"CLS, FN_PTR(Unsafe_DefineClass)},
1474 {CC"allocateInstance", CC"("CLS")"OBJ, FN_PTR(Unsafe_AllocateInstance)},
1475 {CC"throwException", CC"("THR")V", FN_PTR(Unsafe_ThrowException)},
1476 {CC"compareAndSwapObject", CC"("OBJ"J"OBJ""OBJ")Z", FN_PTR(Unsafe_CompareAndSwapObject)},
1477 {CC"compareAndSwapInt", CC"("OBJ"J""I""I"")Z", FN_PTR(Unsafe_CompareAndSwapInt)},
1478 {CC"compareAndSwapLong", CC"("OBJ"J""J""J"")Z", FN_PTR(Unsafe_CompareAndSwapLong)},
1479 {CC"putOrderedObject", CC"("OBJ"J"OBJ")V", FN_PTR(Unsafe_SetOrderedObject)},
1480 {CC"putOrderedInt", CC"("OBJ"JI)V", FN_PTR(Unsafe_SetOrderedInt)},
1481 {CC"putOrderedLong", CC"("OBJ"JJ)V", FN_PTR(Unsafe_SetOrderedLong)},
1482 {CC"park", CC"(ZJ)V", FN_PTR(Unsafe_Park)},
1483 {CC"unpark", CC"("OBJ")V", FN_PTR(Unsafe_Unpark)}
1484 };
1485
1486 // These are the methods for 1.8.0
1487 static JNINativeMethod methods_18[] = {
1488 {CC"getObject", CC"("OBJ"J)"OBJ"", FN_PTR(Unsafe_GetObject)},
1489 {CC"putObject", CC"("OBJ"J"OBJ")V", FN_PTR(Unsafe_SetObject)},
1490 {CC"getObjectVolatile",CC"("OBJ"J)"OBJ"", FN_PTR(Unsafe_GetObjectVolatile)},
1491 {CC"putObjectVolatile",CC"("OBJ"J"OBJ")V", FN_PTR(Unsafe_SetObjectVolatile)},
1492
1493 DECLARE_GETSETOOP(Boolean, Z),
1494 DECLARE_GETSETOOP(Byte, B),
1508 DECLARE_GETSETNATIVE(Double, D),
1509
1510 {CC"getAddress", CC"("ADR")"ADR, FN_PTR(Unsafe_GetNativeAddress)},
1511 {CC"putAddress", CC"("ADR""ADR")V", FN_PTR(Unsafe_SetNativeAddress)},
1512
1513 {CC"allocateMemory", CC"(J)"ADR, FN_PTR(Unsafe_AllocateMemory)},
1514 {CC"reallocateMemory", CC"("ADR"J)"ADR, FN_PTR(Unsafe_ReallocateMemory)},
1515 {CC"freeMemory", CC"("ADR")V", FN_PTR(Unsafe_FreeMemory)},
1516
1517 {CC"objectFieldOffset", CC"("FLD")J", FN_PTR(Unsafe_ObjectFieldOffset)},
1518 {CC"staticFieldOffset", CC"("FLD")J", FN_PTR(Unsafe_StaticFieldOffset)},
1519 {CC"staticFieldBase", CC"("FLD")"OBJ, FN_PTR(Unsafe_StaticFieldBaseFromField)},
1520 {CC"ensureClassInitialized",CC"("CLS")V", FN_PTR(Unsafe_EnsureClassInitialized)},
1521 {CC"arrayBaseOffset", CC"("CLS")I", FN_PTR(Unsafe_ArrayBaseOffset)},
1522 {CC"arrayIndexScale", CC"("CLS")I", FN_PTR(Unsafe_ArrayIndexScale)},
1523 {CC"addressSize", CC"()I", FN_PTR(Unsafe_AddressSize)},
1524 {CC"pageSize", CC"()I", FN_PTR(Unsafe_PageSize)},
1525
1526 {CC"defineClass", CC"("DC_Args")"CLS, FN_PTR(Unsafe_DefineClass)},
1527 {CC"allocateInstance", CC"("CLS")"OBJ, FN_PTR(Unsafe_AllocateInstance)},
1528 {CC"throwException", CC"("THR")V", FN_PTR(Unsafe_ThrowException)},
1529 {CC"compareAndSwapObject", CC"("OBJ"J"OBJ""OBJ")Z", FN_PTR(Unsafe_CompareAndSwapObject)},
1530 {CC"compareAndSwapInt", CC"("OBJ"J""I""I"")Z", FN_PTR(Unsafe_CompareAndSwapInt)},
1531 {CC"compareAndSwapLong", CC"("OBJ"J""J""J"")Z", FN_PTR(Unsafe_CompareAndSwapLong)},
1532 {CC"putOrderedObject", CC"("OBJ"J"OBJ")V", FN_PTR(Unsafe_SetOrderedObject)},
1533 {CC"putOrderedInt", CC"("OBJ"JI)V", FN_PTR(Unsafe_SetOrderedInt)},
1534 {CC"putOrderedLong", CC"("OBJ"JJ)V", FN_PTR(Unsafe_SetOrderedLong)},
1535 {CC"park", CC"(ZJ)V", FN_PTR(Unsafe_Park)},
1536 {CC"unpark", CC"("OBJ")V", FN_PTR(Unsafe_Unpark)}
1537 };
1538
1539 JNINativeMethod loadavg_method[] = {
1540 {CC"getLoadAverage", CC"([DI)I", FN_PTR(Unsafe_Loadavg)}
1541 };
1542
1543 JNINativeMethod prefetch_methods[] = {
1544 {CC"prefetchRead", CC"("OBJ"J)V", FN_PTR(Unsafe_PrefetchRead)},
1545 {CC"prefetchWrite", CC"("OBJ"J)V", FN_PTR(Unsafe_PrefetchWrite)},
1546 {CC"prefetchReadStatic", CC"("OBJ"J)V", FN_PTR(Unsafe_PrefetchRead)},
1547 {CC"prefetchWriteStatic",CC"("OBJ"J)V", FN_PTR(Unsafe_PrefetchWrite)}
|