Mercurial > hg > graal-compiler
comparison src/share/vm/prims/unsafe.cpp @ 8866:16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
Reviewed-by: kvn, jrose
author | twisti |
---|---|
date | Mon, 25 Mar 2013 17:13:26 -0700 |
parents | db9981fd3124 |
children | b9a918201d47 6b388e7d4905 |
comparison
equal
deleted
inserted
replaced
8865:818a1ac7da7a | 8866:16885e702c88 |
---|---|
866 jclass cls = env->FindClass(buf); | 866 jclass cls = env->FindClass(buf); |
867 char* msg = NULL; | 867 char* msg = NULL; |
868 env->ThrowNew(cls, msg); | 868 env->ThrowNew(cls, msg); |
869 } | 869 } |
870 | 870 |
871 static jclass Unsafe_DefineClass(JNIEnv *env, jstring name, jbyteArray data, int offset, int length, jobject loader, jobject pd) { | 871 static jclass Unsafe_DefineClass_impl(JNIEnv *env, jstring name, jbyteArray data, int offset, int length, jobject loader, jobject pd) { |
872 { | 872 { |
873 // Code lifted from JDK 1.3 ClassLoader.c | 873 // Code lifted from JDK 1.3 ClassLoader.c |
874 | 874 |
875 jbyte *body; | 875 jbyte *body; |
876 char *utfName; | 876 char *utfName; |
937 return result; | 937 return result; |
938 } | 938 } |
939 } | 939 } |
940 | 940 |
941 | 941 |
942 UNSAFE_ENTRY(jclass, Unsafe_DefineClass(JNIEnv *env, jobject unsafe, jstring name, jbyteArray data, int offset, int length, jobject loader, jobject pd)) | |
943 UnsafeWrapper("Unsafe_DefineClass"); | |
944 { | |
945 ThreadToNativeFromVM ttnfv(thread); | |
946 return Unsafe_DefineClass_impl(env, name, data, offset, length, loader, pd); | |
947 } | |
948 UNSAFE_END | |
949 | |
950 | |
942 UNSAFE_ENTRY(jclass, Unsafe_DefineClass0(JNIEnv *env, jobject unsafe, jstring name, jbyteArray data, int offset, int length)) | 951 UNSAFE_ENTRY(jclass, Unsafe_DefineClass0(JNIEnv *env, jobject unsafe, jstring name, jbyteArray data, int offset, int length)) |
943 UnsafeWrapper("Unsafe_DefineClass"); | 952 UnsafeWrapper("Unsafe_DefineClass"); |
944 { | 953 { |
945 ThreadToNativeFromVM ttnfv(thread); | 954 ThreadToNativeFromVM ttnfv(thread); |
946 | 955 |
947 int depthFromDefineClass0 = 1; | 956 int depthFromDefineClass0 = 1; |
948 jclass caller = JVM_GetCallerClass(env, depthFromDefineClass0); | 957 jclass caller = JVM_GetCallerClass(env, depthFromDefineClass0); |
949 jobject loader = (caller == NULL) ? NULL : JVM_GetClassLoader(env, caller); | 958 jobject loader = (caller == NULL) ? NULL : JVM_GetClassLoader(env, caller); |
950 jobject pd = (caller == NULL) ? NULL : JVM_GetProtectionDomain(env, caller); | 959 jobject pd = (caller == NULL) ? NULL : JVM_GetProtectionDomain(env, caller); |
951 | 960 |
952 return Unsafe_DefineClass(env, name, data, offset, length, loader, pd); | 961 return Unsafe_DefineClass_impl(env, name, data, offset, length, loader, pd); |
953 } | 962 } |
954 UNSAFE_END | 963 UNSAFE_END |
955 | 964 |
956 | |
957 UNSAFE_ENTRY(jclass, Unsafe_DefineClass1(JNIEnv *env, jobject unsafe, jstring name, jbyteArray data, int offset, int length, jobject loader, jobject pd)) | |
958 UnsafeWrapper("Unsafe_DefineClass"); | |
959 { | |
960 ThreadToNativeFromVM ttnfv(thread); | |
961 | |
962 return Unsafe_DefineClass(env, name, data, offset, length, loader, pd); | |
963 } | |
964 UNSAFE_END | |
965 | 965 |
966 #define DAC_Args CLS"[B["OBJ | 966 #define DAC_Args CLS"[B["OBJ |
967 // define a class but do not make it known to the class loader or system dictionary | 967 // define a class but do not make it known to the class loader or system dictionary |
968 // - host_class: supplies context for linkage, access control, protection domain, and class loader | 968 // - host_class: supplies context for linkage, access control, protection domain, and class loader |
969 // - data: bytes of a class file, a raw memory address (length gives the number of bytes) | 969 // - data: bytes of a class file, a raw memory address (length gives the number of bytes) |
1321 #define FLD LANG"reflect/Field;" | 1321 #define FLD LANG"reflect/Field;" |
1322 #define MTH LANG"reflect/Method;" | 1322 #define MTH LANG"reflect/Method;" |
1323 #define THR LANG"Throwable;" | 1323 #define THR LANG"Throwable;" |
1324 | 1324 |
1325 #define DC0_Args LANG"String;[BII" | 1325 #define DC0_Args LANG"String;[BII" |
1326 #define DC1_Args DC0_Args LANG"ClassLoader;" "Ljava/security/ProtectionDomain;" | 1326 #define DC_Args DC0_Args LANG"ClassLoader;" "Ljava/security/ProtectionDomain;" |
1327 | 1327 |
1328 #define CC (char*) /*cast a literal from (const char*)*/ | 1328 #define CC (char*) /*cast a literal from (const char*)*/ |
1329 #define FN_PTR(f) CAST_FROM_FN_PTR(void*, &f) | 1329 #define FN_PTR(f) CAST_FROM_FN_PTR(void*, &f) |
1330 | 1330 |
1331 // define deprecated accessors for compabitility with 1.4.0 | 1331 // define deprecated accessors for compabitility with 1.4.0 |
1350 {CC"get"#Byte, CC"("ADR")"#B, FN_PTR(Unsafe_GetNative##Byte)}, \ | 1350 {CC"get"#Byte, CC"("ADR")"#B, FN_PTR(Unsafe_GetNative##Byte)}, \ |
1351 {CC"put"#Byte, CC"("ADR#B")V", FN_PTR(Unsafe_SetNative##Byte)} | 1351 {CC"put"#Byte, CC"("ADR#B")V", FN_PTR(Unsafe_SetNative##Byte)} |
1352 | 1352 |
1353 | 1353 |
1354 | 1354 |
1355 // %%% These are temporarily supported until the SDK sources | 1355 // These are the methods for 1.4.0 |
1356 // contain the necessarily updated Unsafe.java. | |
1357 static JNINativeMethod methods_140[] = { | 1356 static JNINativeMethod methods_140[] = { |
1358 | |
1359 {CC"getObject", CC"("OBJ"I)"OBJ"", FN_PTR(Unsafe_GetObject140)}, | 1357 {CC"getObject", CC"("OBJ"I)"OBJ"", FN_PTR(Unsafe_GetObject140)}, |
1360 {CC"putObject", CC"("OBJ"I"OBJ")V", FN_PTR(Unsafe_SetObject140)}, | 1358 {CC"putObject", CC"("OBJ"I"OBJ")V", FN_PTR(Unsafe_SetObject140)}, |
1361 | 1359 |
1362 DECLARE_GETSETOOP_140(Boolean, Z), | 1360 DECLARE_GETSETOOP_140(Boolean, Z), |
1363 DECLARE_GETSETOOP_140(Byte, B), | 1361 DECLARE_GETSETOOP_140(Byte, B), |
1379 {CC"getAddress", CC"("ADR")"ADR, FN_PTR(Unsafe_GetNativeAddress)}, | 1377 {CC"getAddress", CC"("ADR")"ADR, FN_PTR(Unsafe_GetNativeAddress)}, |
1380 {CC"putAddress", CC"("ADR""ADR")V", FN_PTR(Unsafe_SetNativeAddress)}, | 1378 {CC"putAddress", CC"("ADR""ADR")V", FN_PTR(Unsafe_SetNativeAddress)}, |
1381 | 1379 |
1382 {CC"allocateMemory", CC"(J)"ADR, FN_PTR(Unsafe_AllocateMemory)}, | 1380 {CC"allocateMemory", CC"(J)"ADR, FN_PTR(Unsafe_AllocateMemory)}, |
1383 {CC"reallocateMemory", CC"("ADR"J)"ADR, FN_PTR(Unsafe_ReallocateMemory)}, | 1381 {CC"reallocateMemory", CC"("ADR"J)"ADR, FN_PTR(Unsafe_ReallocateMemory)}, |
1384 // {CC"setMemory", CC"("ADR"JB)V", FN_PTR(Unsafe_SetMemory)}, | |
1385 // {CC"copyMemory", CC"("ADR ADR"J)V", FN_PTR(Unsafe_CopyMemory)}, | |
1386 {CC"freeMemory", CC"("ADR")V", FN_PTR(Unsafe_FreeMemory)}, | 1382 {CC"freeMemory", CC"("ADR")V", FN_PTR(Unsafe_FreeMemory)}, |
1387 | 1383 |
1388 {CC"fieldOffset", CC"("FLD")I", FN_PTR(Unsafe_FieldOffset)}, //deprecated | 1384 {CC"fieldOffset", CC"("FLD")I", FN_PTR(Unsafe_FieldOffset)}, |
1389 {CC"staticFieldBase", CC"("CLS")"OBJ, FN_PTR(Unsafe_StaticFieldBaseFromClass)}, //deprecated | 1385 {CC"staticFieldBase", CC"("CLS")"OBJ, FN_PTR(Unsafe_StaticFieldBaseFromClass)}, |
1390 {CC"ensureClassInitialized",CC"("CLS")V", FN_PTR(Unsafe_EnsureClassInitialized)}, | 1386 {CC"ensureClassInitialized",CC"("CLS")V", FN_PTR(Unsafe_EnsureClassInitialized)}, |
1391 {CC"arrayBaseOffset", CC"("CLS")I", FN_PTR(Unsafe_ArrayBaseOffset)}, | 1387 {CC"arrayBaseOffset", CC"("CLS")I", FN_PTR(Unsafe_ArrayBaseOffset)}, |
1392 {CC"arrayIndexScale", CC"("CLS")I", FN_PTR(Unsafe_ArrayIndexScale)}, | 1388 {CC"arrayIndexScale", CC"("CLS")I", FN_PTR(Unsafe_ArrayIndexScale)}, |
1393 {CC"addressSize", CC"()I", FN_PTR(Unsafe_AddressSize)}, | 1389 {CC"addressSize", CC"()I", FN_PTR(Unsafe_AddressSize)}, |
1394 {CC"pageSize", CC"()I", FN_PTR(Unsafe_PageSize)}, | 1390 {CC"pageSize", CC"()I", FN_PTR(Unsafe_PageSize)}, |
1395 | 1391 |
1396 {CC"defineClass", CC"("DC0_Args")"CLS, FN_PTR(Unsafe_DefineClass0)}, | 1392 {CC"defineClass", CC"("DC0_Args")"CLS, FN_PTR(Unsafe_DefineClass0)}, |
1397 {CC"defineClass", CC"("DC1_Args")"CLS, FN_PTR(Unsafe_DefineClass1)}, | 1393 {CC"defineClass", CC"("DC_Args")"CLS, FN_PTR(Unsafe_DefineClass)}, |
1398 {CC"allocateInstance", CC"("CLS")"OBJ, FN_PTR(Unsafe_AllocateInstance)}, | 1394 {CC"allocateInstance", CC"("CLS")"OBJ, FN_PTR(Unsafe_AllocateInstance)}, |
1399 {CC"monitorEnter", CC"("OBJ")V", FN_PTR(Unsafe_MonitorEnter)}, | 1395 {CC"monitorEnter", CC"("OBJ")V", FN_PTR(Unsafe_MonitorEnter)}, |
1400 {CC"monitorExit", CC"("OBJ")V", FN_PTR(Unsafe_MonitorExit)}, | 1396 {CC"monitorExit", CC"("OBJ")V", FN_PTR(Unsafe_MonitorExit)}, |
1401 {CC"throwException", CC"("THR")V", FN_PTR(Unsafe_ThrowException)} | 1397 {CC"throwException", CC"("THR")V", FN_PTR(Unsafe_ThrowException)} |
1402 }; | 1398 }; |
1403 | 1399 |
1404 // These are the old methods prior to the JSR 166 changes in 1.5.0 | 1400 // These are the methods prior to the JSR 166 changes in 1.5.0 |
1405 static JNINativeMethod methods_141[] = { | 1401 static JNINativeMethod methods_141[] = { |
1406 | |
1407 {CC"getObject", CC"("OBJ"J)"OBJ"", FN_PTR(Unsafe_GetObject)}, | 1402 {CC"getObject", CC"("OBJ"J)"OBJ"", FN_PTR(Unsafe_GetObject)}, |
1408 {CC"putObject", CC"("OBJ"J"OBJ")V", FN_PTR(Unsafe_SetObject)}, | 1403 {CC"putObject", CC"("OBJ"J"OBJ")V", FN_PTR(Unsafe_SetObject)}, |
1409 | 1404 |
1410 DECLARE_GETSETOOP_141(Boolean, Z), | 1405 DECLARE_GETSETOOP_141(Boolean, Z), |
1411 DECLARE_GETSETOOP_141(Byte, B), | 1406 DECLARE_GETSETOOP_141(Byte, B), |
1427 {CC"getAddress", CC"("ADR")"ADR, FN_PTR(Unsafe_GetNativeAddress)}, | 1422 {CC"getAddress", CC"("ADR")"ADR, FN_PTR(Unsafe_GetNativeAddress)}, |
1428 {CC"putAddress", CC"("ADR""ADR")V", FN_PTR(Unsafe_SetNativeAddress)}, | 1423 {CC"putAddress", CC"("ADR""ADR")V", FN_PTR(Unsafe_SetNativeAddress)}, |
1429 | 1424 |
1430 {CC"allocateMemory", CC"(J)"ADR, FN_PTR(Unsafe_AllocateMemory)}, | 1425 {CC"allocateMemory", CC"(J)"ADR, FN_PTR(Unsafe_AllocateMemory)}, |
1431 {CC"reallocateMemory", CC"("ADR"J)"ADR, FN_PTR(Unsafe_ReallocateMemory)}, | 1426 {CC"reallocateMemory", CC"("ADR"J)"ADR, FN_PTR(Unsafe_ReallocateMemory)}, |
1432 // {CC"setMemory", CC"("ADR"JB)V", FN_PTR(Unsafe_SetMemory)}, | |
1433 // {CC"copyMemory", CC"("ADR ADR"J)V", FN_PTR(Unsafe_CopyMemory)}, | |
1434 {CC"freeMemory", CC"("ADR")V", FN_PTR(Unsafe_FreeMemory)}, | 1427 {CC"freeMemory", CC"("ADR")V", FN_PTR(Unsafe_FreeMemory)}, |
1435 | 1428 |
1436 {CC"objectFieldOffset", CC"("FLD")J", FN_PTR(Unsafe_ObjectFieldOffset)}, | 1429 {CC"objectFieldOffset", CC"("FLD")J", FN_PTR(Unsafe_ObjectFieldOffset)}, |
1437 {CC"staticFieldOffset", CC"("FLD")J", FN_PTR(Unsafe_StaticFieldOffset)}, | 1430 {CC"staticFieldOffset", CC"("FLD")J", FN_PTR(Unsafe_StaticFieldOffset)}, |
1438 {CC"staticFieldBase", CC"("FLD")"OBJ, FN_PTR(Unsafe_StaticFieldBaseFromField)}, | 1431 {CC"staticFieldBase", CC"("FLD")"OBJ, FN_PTR(Unsafe_StaticFieldBaseFromField)}, |
1441 {CC"arrayIndexScale", CC"("CLS")I", FN_PTR(Unsafe_ArrayIndexScale)}, | 1434 {CC"arrayIndexScale", CC"("CLS")I", FN_PTR(Unsafe_ArrayIndexScale)}, |
1442 {CC"addressSize", CC"()I", FN_PTR(Unsafe_AddressSize)}, | 1435 {CC"addressSize", CC"()I", FN_PTR(Unsafe_AddressSize)}, |
1443 {CC"pageSize", CC"()I", FN_PTR(Unsafe_PageSize)}, | 1436 {CC"pageSize", CC"()I", FN_PTR(Unsafe_PageSize)}, |
1444 | 1437 |
1445 {CC"defineClass", CC"("DC0_Args")"CLS, FN_PTR(Unsafe_DefineClass0)}, | 1438 {CC"defineClass", CC"("DC0_Args")"CLS, FN_PTR(Unsafe_DefineClass0)}, |
1446 {CC"defineClass", CC"("DC1_Args")"CLS, FN_PTR(Unsafe_DefineClass1)}, | 1439 {CC"defineClass", CC"("DC_Args")"CLS, FN_PTR(Unsafe_DefineClass)}, |
1447 {CC"allocateInstance", CC"("CLS")"OBJ, FN_PTR(Unsafe_AllocateInstance)}, | 1440 {CC"allocateInstance", CC"("CLS")"OBJ, FN_PTR(Unsafe_AllocateInstance)}, |
1448 {CC"monitorEnter", CC"("OBJ")V", FN_PTR(Unsafe_MonitorEnter)}, | 1441 {CC"monitorEnter", CC"("OBJ")V", FN_PTR(Unsafe_MonitorEnter)}, |
1449 {CC"monitorExit", CC"("OBJ")V", FN_PTR(Unsafe_MonitorExit)}, | 1442 {CC"monitorExit", CC"("OBJ")V", FN_PTR(Unsafe_MonitorExit)}, |
1450 {CC"throwException", CC"("THR")V", FN_PTR(Unsafe_ThrowException)} | 1443 {CC"throwException", CC"("THR")V", FN_PTR(Unsafe_ThrowException)} |
1451 | 1444 |
1452 }; | 1445 }; |
1453 | 1446 |
1454 // These are the old methods prior to the JSR 166 changes in 1.6.0 | 1447 // These are the methods prior to the JSR 166 changes in 1.6.0 |
1455 static JNINativeMethod methods_15[] = { | 1448 static JNINativeMethod methods_15[] = { |
1456 | |
1457 {CC"getObject", CC"("OBJ"J)"OBJ"", FN_PTR(Unsafe_GetObject)}, | 1449 {CC"getObject", CC"("OBJ"J)"OBJ"", FN_PTR(Unsafe_GetObject)}, |
1458 {CC"putObject", CC"("OBJ"J"OBJ")V", FN_PTR(Unsafe_SetObject)}, | 1450 {CC"putObject", CC"("OBJ"J"OBJ")V", FN_PTR(Unsafe_SetObject)}, |
1459 {CC"getObjectVolatile",CC"("OBJ"J)"OBJ"", FN_PTR(Unsafe_GetObjectVolatile)}, | 1451 {CC"getObjectVolatile",CC"("OBJ"J)"OBJ"", FN_PTR(Unsafe_GetObjectVolatile)}, |
1460 {CC"putObjectVolatile",CC"("OBJ"J"OBJ")V", FN_PTR(Unsafe_SetObjectVolatile)}, | 1452 {CC"putObjectVolatile",CC"("OBJ"J"OBJ")V", FN_PTR(Unsafe_SetObjectVolatile)}, |
1461 | 1453 |
1480 {CC"getAddress", CC"("ADR")"ADR, FN_PTR(Unsafe_GetNativeAddress)}, | 1472 {CC"getAddress", CC"("ADR")"ADR, FN_PTR(Unsafe_GetNativeAddress)}, |
1481 {CC"putAddress", CC"("ADR""ADR")V", FN_PTR(Unsafe_SetNativeAddress)}, | 1473 {CC"putAddress", CC"("ADR""ADR")V", FN_PTR(Unsafe_SetNativeAddress)}, |
1482 | 1474 |
1483 {CC"allocateMemory", CC"(J)"ADR, FN_PTR(Unsafe_AllocateMemory)}, | 1475 {CC"allocateMemory", CC"(J)"ADR, FN_PTR(Unsafe_AllocateMemory)}, |
1484 {CC"reallocateMemory", CC"("ADR"J)"ADR, FN_PTR(Unsafe_ReallocateMemory)}, | 1476 {CC"reallocateMemory", CC"("ADR"J)"ADR, FN_PTR(Unsafe_ReallocateMemory)}, |
1485 // {CC"setMemory", CC"("ADR"JB)V", FN_PTR(Unsafe_SetMemory)}, | |
1486 // {CC"copyMemory", CC"("ADR ADR"J)V", FN_PTR(Unsafe_CopyMemory)}, | |
1487 {CC"freeMemory", CC"("ADR")V", FN_PTR(Unsafe_FreeMemory)}, | 1477 {CC"freeMemory", CC"("ADR")V", FN_PTR(Unsafe_FreeMemory)}, |
1488 | 1478 |
1489 {CC"objectFieldOffset", CC"("FLD")J", FN_PTR(Unsafe_ObjectFieldOffset)}, | 1479 {CC"objectFieldOffset", CC"("FLD")J", FN_PTR(Unsafe_ObjectFieldOffset)}, |
1490 {CC"staticFieldOffset", CC"("FLD")J", FN_PTR(Unsafe_StaticFieldOffset)}, | 1480 {CC"staticFieldOffset", CC"("FLD")J", FN_PTR(Unsafe_StaticFieldOffset)}, |
1491 {CC"staticFieldBase", CC"("FLD")"OBJ, FN_PTR(Unsafe_StaticFieldBaseFromField)}, | 1481 {CC"staticFieldBase", CC"("FLD")"OBJ, FN_PTR(Unsafe_StaticFieldBaseFromField)}, |
1494 {CC"arrayIndexScale", CC"("CLS")I", FN_PTR(Unsafe_ArrayIndexScale)}, | 1484 {CC"arrayIndexScale", CC"("CLS")I", FN_PTR(Unsafe_ArrayIndexScale)}, |
1495 {CC"addressSize", CC"()I", FN_PTR(Unsafe_AddressSize)}, | 1485 {CC"addressSize", CC"()I", FN_PTR(Unsafe_AddressSize)}, |
1496 {CC"pageSize", CC"()I", FN_PTR(Unsafe_PageSize)}, | 1486 {CC"pageSize", CC"()I", FN_PTR(Unsafe_PageSize)}, |
1497 | 1487 |
1498 {CC"defineClass", CC"("DC0_Args")"CLS, FN_PTR(Unsafe_DefineClass0)}, | 1488 {CC"defineClass", CC"("DC0_Args")"CLS, FN_PTR(Unsafe_DefineClass0)}, |
1499 {CC"defineClass", CC"("DC1_Args")"CLS, FN_PTR(Unsafe_DefineClass1)}, | 1489 {CC"defineClass", CC"("DC_Args")"CLS, FN_PTR(Unsafe_DefineClass)}, |
1500 {CC"allocateInstance", CC"("CLS")"OBJ, FN_PTR(Unsafe_AllocateInstance)}, | 1490 {CC"allocateInstance", CC"("CLS")"OBJ, FN_PTR(Unsafe_AllocateInstance)}, |
1501 {CC"monitorEnter", CC"("OBJ")V", FN_PTR(Unsafe_MonitorEnter)}, | 1491 {CC"monitorEnter", CC"("OBJ")V", FN_PTR(Unsafe_MonitorEnter)}, |
1502 {CC"monitorExit", CC"("OBJ")V", FN_PTR(Unsafe_MonitorExit)}, | 1492 {CC"monitorExit", CC"("OBJ")V", FN_PTR(Unsafe_MonitorExit)}, |
1503 {CC"throwException", CC"("THR")V", FN_PTR(Unsafe_ThrowException)}, | 1493 {CC"throwException", CC"("THR")V", FN_PTR(Unsafe_ThrowException)}, |
1504 {CC"compareAndSwapObject", CC"("OBJ"J"OBJ""OBJ")Z", FN_PTR(Unsafe_CompareAndSwapObject)}, | 1494 {CC"compareAndSwapObject", CC"("OBJ"J"OBJ""OBJ")Z", FN_PTR(Unsafe_CompareAndSwapObject)}, |
1507 {CC"park", CC"(ZJ)V", FN_PTR(Unsafe_Park)}, | 1497 {CC"park", CC"(ZJ)V", FN_PTR(Unsafe_Park)}, |
1508 {CC"unpark", CC"("OBJ")V", FN_PTR(Unsafe_Unpark)} | 1498 {CC"unpark", CC"("OBJ")V", FN_PTR(Unsafe_Unpark)} |
1509 | 1499 |
1510 }; | 1500 }; |
1511 | 1501 |
1512 // These are the correct methods, moving forward: | 1502 // These are the methods for 1.6.0 and 1.7.0 |
1513 static JNINativeMethod methods[] = { | 1503 static JNINativeMethod methods_16[] = { |
1514 | |
1515 {CC"getObject", CC"("OBJ"J)"OBJ"", FN_PTR(Unsafe_GetObject)}, | 1504 {CC"getObject", CC"("OBJ"J)"OBJ"", FN_PTR(Unsafe_GetObject)}, |
1516 {CC"putObject", CC"("OBJ"J"OBJ")V", FN_PTR(Unsafe_SetObject)}, | 1505 {CC"putObject", CC"("OBJ"J"OBJ")V", FN_PTR(Unsafe_SetObject)}, |
1517 {CC"getObjectVolatile",CC"("OBJ"J)"OBJ"", FN_PTR(Unsafe_GetObjectVolatile)}, | 1506 {CC"getObjectVolatile",CC"("OBJ"J)"OBJ"", FN_PTR(Unsafe_GetObjectVolatile)}, |
1518 {CC"putObjectVolatile",CC"("OBJ"J"OBJ")V", FN_PTR(Unsafe_SetObjectVolatile)}, | 1507 {CC"putObjectVolatile",CC"("OBJ"J"OBJ")V", FN_PTR(Unsafe_SetObjectVolatile)}, |
1519 | |
1520 | 1508 |
1521 DECLARE_GETSETOOP(Boolean, Z), | 1509 DECLARE_GETSETOOP(Boolean, Z), |
1522 DECLARE_GETSETOOP(Byte, B), | 1510 DECLARE_GETSETOOP(Byte, B), |
1523 DECLARE_GETSETOOP(Short, S), | 1511 DECLARE_GETSETOOP(Short, S), |
1524 DECLARE_GETSETOOP(Char, C), | 1512 DECLARE_GETSETOOP(Char, C), |
1538 {CC"getAddress", CC"("ADR")"ADR, FN_PTR(Unsafe_GetNativeAddress)}, | 1526 {CC"getAddress", CC"("ADR")"ADR, FN_PTR(Unsafe_GetNativeAddress)}, |
1539 {CC"putAddress", CC"("ADR""ADR")V", FN_PTR(Unsafe_SetNativeAddress)}, | 1527 {CC"putAddress", CC"("ADR""ADR")V", FN_PTR(Unsafe_SetNativeAddress)}, |
1540 | 1528 |
1541 {CC"allocateMemory", CC"(J)"ADR, FN_PTR(Unsafe_AllocateMemory)}, | 1529 {CC"allocateMemory", CC"(J)"ADR, FN_PTR(Unsafe_AllocateMemory)}, |
1542 {CC"reallocateMemory", CC"("ADR"J)"ADR, FN_PTR(Unsafe_ReallocateMemory)}, | 1530 {CC"reallocateMemory", CC"("ADR"J)"ADR, FN_PTR(Unsafe_ReallocateMemory)}, |
1543 // {CC"setMemory", CC"("ADR"JB)V", FN_PTR(Unsafe_SetMemory)}, | |
1544 // {CC"copyMemory", CC"("ADR ADR"J)V", FN_PTR(Unsafe_CopyMemory)}, | |
1545 {CC"freeMemory", CC"("ADR")V", FN_PTR(Unsafe_FreeMemory)}, | 1531 {CC"freeMemory", CC"("ADR")V", FN_PTR(Unsafe_FreeMemory)}, |
1546 | 1532 |
1547 {CC"objectFieldOffset", CC"("FLD")J", FN_PTR(Unsafe_ObjectFieldOffset)}, | 1533 {CC"objectFieldOffset", CC"("FLD")J", FN_PTR(Unsafe_ObjectFieldOffset)}, |
1548 {CC"staticFieldOffset", CC"("FLD")J", FN_PTR(Unsafe_StaticFieldOffset)}, | 1534 {CC"staticFieldOffset", CC"("FLD")J", FN_PTR(Unsafe_StaticFieldOffset)}, |
1549 {CC"staticFieldBase", CC"("FLD")"OBJ, FN_PTR(Unsafe_StaticFieldBaseFromField)}, | 1535 {CC"staticFieldBase", CC"("FLD")"OBJ, FN_PTR(Unsafe_StaticFieldBaseFromField)}, |
1552 {CC"arrayIndexScale", CC"("CLS")I", FN_PTR(Unsafe_ArrayIndexScale)}, | 1538 {CC"arrayIndexScale", CC"("CLS")I", FN_PTR(Unsafe_ArrayIndexScale)}, |
1553 {CC"addressSize", CC"()I", FN_PTR(Unsafe_AddressSize)}, | 1539 {CC"addressSize", CC"()I", FN_PTR(Unsafe_AddressSize)}, |
1554 {CC"pageSize", CC"()I", FN_PTR(Unsafe_PageSize)}, | 1540 {CC"pageSize", CC"()I", FN_PTR(Unsafe_PageSize)}, |
1555 | 1541 |
1556 {CC"defineClass", CC"("DC0_Args")"CLS, FN_PTR(Unsafe_DefineClass0)}, | 1542 {CC"defineClass", CC"("DC0_Args")"CLS, FN_PTR(Unsafe_DefineClass0)}, |
1557 {CC"defineClass", CC"("DC1_Args")"CLS, FN_PTR(Unsafe_DefineClass1)}, | 1543 {CC"defineClass", CC"("DC_Args")"CLS, FN_PTR(Unsafe_DefineClass)}, |
1558 {CC"allocateInstance", CC"("CLS")"OBJ, FN_PTR(Unsafe_AllocateInstance)}, | 1544 {CC"allocateInstance", CC"("CLS")"OBJ, FN_PTR(Unsafe_AllocateInstance)}, |
1559 {CC"monitorEnter", CC"("OBJ")V", FN_PTR(Unsafe_MonitorEnter)}, | 1545 {CC"monitorEnter", CC"("OBJ")V", FN_PTR(Unsafe_MonitorEnter)}, |
1560 {CC"monitorExit", CC"("OBJ")V", FN_PTR(Unsafe_MonitorExit)}, | 1546 {CC"monitorExit", CC"("OBJ")V", FN_PTR(Unsafe_MonitorExit)}, |
1561 {CC"tryMonitorEnter", CC"("OBJ")Z", FN_PTR(Unsafe_TryMonitorEnter)}, | 1547 {CC"tryMonitorEnter", CC"("OBJ")Z", FN_PTR(Unsafe_TryMonitorEnter)}, |
1562 {CC"throwException", CC"("THR")V", FN_PTR(Unsafe_ThrowException)}, | 1548 {CC"throwException", CC"("THR")V", FN_PTR(Unsafe_ThrowException)}, |
1564 {CC"compareAndSwapInt", CC"("OBJ"J""I""I"")Z", FN_PTR(Unsafe_CompareAndSwapInt)}, | 1550 {CC"compareAndSwapInt", CC"("OBJ"J""I""I"")Z", FN_PTR(Unsafe_CompareAndSwapInt)}, |
1565 {CC"compareAndSwapLong", CC"("OBJ"J""J""J"")Z", FN_PTR(Unsafe_CompareAndSwapLong)}, | 1551 {CC"compareAndSwapLong", CC"("OBJ"J""J""J"")Z", FN_PTR(Unsafe_CompareAndSwapLong)}, |
1566 {CC"putOrderedObject", CC"("OBJ"J"OBJ")V", FN_PTR(Unsafe_SetOrderedObject)}, | 1552 {CC"putOrderedObject", CC"("OBJ"J"OBJ")V", FN_PTR(Unsafe_SetOrderedObject)}, |
1567 {CC"putOrderedInt", CC"("OBJ"JI)V", FN_PTR(Unsafe_SetOrderedInt)}, | 1553 {CC"putOrderedInt", CC"("OBJ"JI)V", FN_PTR(Unsafe_SetOrderedInt)}, |
1568 {CC"putOrderedLong", CC"("OBJ"JJ)V", FN_PTR(Unsafe_SetOrderedLong)}, | 1554 {CC"putOrderedLong", CC"("OBJ"JJ)V", FN_PTR(Unsafe_SetOrderedLong)}, |
1569 {CC"loadFence", CC"()V", FN_PTR(Unsafe_LoadFence)}, | |
1570 {CC"storeFence", CC"()V", FN_PTR(Unsafe_StoreFence)}, | |
1571 {CC"fullFence", CC"()V", FN_PTR(Unsafe_FullFence)}, | |
1572 {CC"park", CC"(ZJ)V", FN_PTR(Unsafe_Park)}, | 1555 {CC"park", CC"(ZJ)V", FN_PTR(Unsafe_Park)}, |
1573 {CC"unpark", CC"("OBJ")V", FN_PTR(Unsafe_Unpark)} | 1556 {CC"unpark", CC"("OBJ")V", FN_PTR(Unsafe_Unpark)} |
1574 | |
1575 // {CC"getLoadAverage", CC"([DI)I", FN_PTR(Unsafe_Loadavg)}, | |
1576 | |
1577 // {CC"prefetchRead", CC"("OBJ"J)V", FN_PTR(Unsafe_PrefetchRead)}, | |
1578 // {CC"prefetchWrite", CC"("OBJ"J)V", FN_PTR(Unsafe_PrefetchWrite)} | |
1579 // {CC"prefetchReadStatic", CC"("OBJ"J)V", FN_PTR(Unsafe_PrefetchRead)}, | |
1580 // {CC"prefetchWriteStatic",CC"("OBJ"J)V", FN_PTR(Unsafe_PrefetchWrite)} | |
1581 | |
1582 }; | 1557 }; |
1583 | 1558 |
1559 // These are the methods for 1.8.0 | |
1560 static JNINativeMethod methods_18[] = { | |
1561 {CC"getObject", CC"("OBJ"J)"OBJ"", FN_PTR(Unsafe_GetObject)}, | |
1562 {CC"putObject", CC"("OBJ"J"OBJ")V", FN_PTR(Unsafe_SetObject)}, | |
1563 {CC"getObjectVolatile",CC"("OBJ"J)"OBJ"", FN_PTR(Unsafe_GetObjectVolatile)}, | |
1564 {CC"putObjectVolatile",CC"("OBJ"J"OBJ")V", FN_PTR(Unsafe_SetObjectVolatile)}, | |
1565 | |
1566 DECLARE_GETSETOOP(Boolean, Z), | |
1567 DECLARE_GETSETOOP(Byte, B), | |
1568 DECLARE_GETSETOOP(Short, S), | |
1569 DECLARE_GETSETOOP(Char, C), | |
1570 DECLARE_GETSETOOP(Int, I), | |
1571 DECLARE_GETSETOOP(Long, J), | |
1572 DECLARE_GETSETOOP(Float, F), | |
1573 DECLARE_GETSETOOP(Double, D), | |
1574 | |
1575 DECLARE_GETSETNATIVE(Byte, B), | |
1576 DECLARE_GETSETNATIVE(Short, S), | |
1577 DECLARE_GETSETNATIVE(Char, C), | |
1578 DECLARE_GETSETNATIVE(Int, I), | |
1579 DECLARE_GETSETNATIVE(Long, J), | |
1580 DECLARE_GETSETNATIVE(Float, F), | |
1581 DECLARE_GETSETNATIVE(Double, D), | |
1582 | |
1583 {CC"getAddress", CC"("ADR")"ADR, FN_PTR(Unsafe_GetNativeAddress)}, | |
1584 {CC"putAddress", CC"("ADR""ADR")V", FN_PTR(Unsafe_SetNativeAddress)}, | |
1585 | |
1586 {CC"allocateMemory", CC"(J)"ADR, FN_PTR(Unsafe_AllocateMemory)}, | |
1587 {CC"reallocateMemory", CC"("ADR"J)"ADR, FN_PTR(Unsafe_ReallocateMemory)}, | |
1588 {CC"freeMemory", CC"("ADR")V", FN_PTR(Unsafe_FreeMemory)}, | |
1589 | |
1590 {CC"objectFieldOffset", CC"("FLD")J", FN_PTR(Unsafe_ObjectFieldOffset)}, | |
1591 {CC"staticFieldOffset", CC"("FLD")J", FN_PTR(Unsafe_StaticFieldOffset)}, | |
1592 {CC"staticFieldBase", CC"("FLD")"OBJ, FN_PTR(Unsafe_StaticFieldBaseFromField)}, | |
1593 {CC"ensureClassInitialized",CC"("CLS")V", FN_PTR(Unsafe_EnsureClassInitialized)}, | |
1594 {CC"arrayBaseOffset", CC"("CLS")I", FN_PTR(Unsafe_ArrayBaseOffset)}, | |
1595 {CC"arrayIndexScale", CC"("CLS")I", FN_PTR(Unsafe_ArrayIndexScale)}, | |
1596 {CC"addressSize", CC"()I", FN_PTR(Unsafe_AddressSize)}, | |
1597 {CC"pageSize", CC"()I", FN_PTR(Unsafe_PageSize)}, | |
1598 | |
1599 {CC"defineClass", CC"("DC_Args")"CLS, FN_PTR(Unsafe_DefineClass)}, | |
1600 {CC"allocateInstance", CC"("CLS")"OBJ, FN_PTR(Unsafe_AllocateInstance)}, | |
1601 {CC"monitorEnter", CC"("OBJ")V", FN_PTR(Unsafe_MonitorEnter)}, | |
1602 {CC"monitorExit", CC"("OBJ")V", FN_PTR(Unsafe_MonitorExit)}, | |
1603 {CC"tryMonitorEnter", CC"("OBJ")Z", FN_PTR(Unsafe_TryMonitorEnter)}, | |
1604 {CC"throwException", CC"("THR")V", FN_PTR(Unsafe_ThrowException)}, | |
1605 {CC"compareAndSwapObject", CC"("OBJ"J"OBJ""OBJ")Z", FN_PTR(Unsafe_CompareAndSwapObject)}, | |
1606 {CC"compareAndSwapInt", CC"("OBJ"J""I""I"")Z", FN_PTR(Unsafe_CompareAndSwapInt)}, | |
1607 {CC"compareAndSwapLong", CC"("OBJ"J""J""J"")Z", FN_PTR(Unsafe_CompareAndSwapLong)}, | |
1608 {CC"putOrderedObject", CC"("OBJ"J"OBJ")V", FN_PTR(Unsafe_SetOrderedObject)}, | |
1609 {CC"putOrderedInt", CC"("OBJ"JI)V", FN_PTR(Unsafe_SetOrderedInt)}, | |
1610 {CC"putOrderedLong", CC"("OBJ"JJ)V", FN_PTR(Unsafe_SetOrderedLong)}, | |
1611 {CC"park", CC"(ZJ)V", FN_PTR(Unsafe_Park)}, | |
1612 {CC"unpark", CC"("OBJ")V", FN_PTR(Unsafe_Unpark)} | |
1613 }; | |
1614 | |
1584 JNINativeMethod loadavg_method[] = { | 1615 JNINativeMethod loadavg_method[] = { |
1585 {CC"getLoadAverage", CC"([DI)I", FN_PTR(Unsafe_Loadavg)} | 1616 {CC"getLoadAverage", CC"([DI)I", FN_PTR(Unsafe_Loadavg)} |
1586 }; | 1617 }; |
1587 | 1618 |
1588 JNINativeMethod prefetch_methods[] = { | 1619 JNINativeMethod prefetch_methods[] = { |
1589 {CC"prefetchRead", CC"("OBJ"J)V", FN_PTR(Unsafe_PrefetchRead)}, | 1620 {CC"prefetchRead", CC"("OBJ"J)V", FN_PTR(Unsafe_PrefetchRead)}, |
1590 {CC"prefetchWrite", CC"("OBJ"J)V", FN_PTR(Unsafe_PrefetchWrite)}, | 1621 {CC"prefetchWrite", CC"("OBJ"J)V", FN_PTR(Unsafe_PrefetchWrite)}, |
1591 {CC"prefetchReadStatic", CC"("OBJ"J)V", FN_PTR(Unsafe_PrefetchRead)}, | 1622 {CC"prefetchReadStatic", CC"("OBJ"J)V", FN_PTR(Unsafe_PrefetchRead)}, |
1592 {CC"prefetchWriteStatic",CC"("OBJ"J)V", FN_PTR(Unsafe_PrefetchWrite)} | 1623 {CC"prefetchWriteStatic",CC"("OBJ"J)V", FN_PTR(Unsafe_PrefetchWrite)} |
1593 }; | 1624 }; |
1594 | 1625 |
1595 JNINativeMethod memcopy_methods[] = { | 1626 JNINativeMethod memcopy_methods_17[] = { |
1596 {CC"copyMemory", CC"("OBJ"J"OBJ"JJ)V", FN_PTR(Unsafe_CopyMemory2)}, | 1627 {CC"copyMemory", CC"("OBJ"J"OBJ"JJ)V", FN_PTR(Unsafe_CopyMemory2)}, |
1597 {CC"setMemory", CC"("OBJ"JJB)V", FN_PTR(Unsafe_SetMemory2)} | 1628 {CC"setMemory", CC"("OBJ"JJB)V", FN_PTR(Unsafe_SetMemory2)} |
1598 }; | 1629 }; |
1599 | 1630 |
1600 JNINativeMethod memcopy_methods_15[] = { | 1631 JNINativeMethod memcopy_methods_15[] = { |
1606 {CC"defineAnonymousClass", CC"("DAC_Args")"CLS, FN_PTR(Unsafe_DefineAnonymousClass)}, | 1637 {CC"defineAnonymousClass", CC"("DAC_Args")"CLS, FN_PTR(Unsafe_DefineAnonymousClass)}, |
1607 }; | 1638 }; |
1608 | 1639 |
1609 JNINativeMethod lform_methods[] = { | 1640 JNINativeMethod lform_methods[] = { |
1610 {CC"shouldBeInitialized",CC"("CLS")Z", FN_PTR(Unsafe_ShouldBeInitialized)}, | 1641 {CC"shouldBeInitialized",CC"("CLS")Z", FN_PTR(Unsafe_ShouldBeInitialized)}, |
1642 }; | |
1643 | |
1644 JNINativeMethod fence_methods[] = { | |
1645 {CC"loadFence", CC"()V", FN_PTR(Unsafe_LoadFence)}, | |
1646 {CC"storeFence", CC"()V", FN_PTR(Unsafe_StoreFence)}, | |
1647 {CC"fullFence", CC"()V", FN_PTR(Unsafe_FullFence)}, | |
1611 }; | 1648 }; |
1612 | 1649 |
1613 #undef CC | 1650 #undef CC |
1614 #undef FN_PTR | 1651 #undef FN_PTR |
1615 | 1652 |
1620 #undef CTR | 1657 #undef CTR |
1621 #undef FLD | 1658 #undef FLD |
1622 #undef MTH | 1659 #undef MTH |
1623 #undef THR | 1660 #undef THR |
1624 #undef DC0_Args | 1661 #undef DC0_Args |
1625 #undef DC1_Args | 1662 #undef DC_Args |
1626 | 1663 |
1627 #undef DECLARE_GETSETOOP | 1664 #undef DECLARE_GETSETOOP |
1628 #undef DECLARE_GETSETNATIVE | 1665 #undef DECLARE_GETSETNATIVE |
1666 | |
1667 | |
1668 /** | |
1669 * Helper method to register native methods. | |
1670 */ | |
1671 static bool register_natives(const char* message, JNIEnv* env, jclass clazz, const JNINativeMethod* methods, jint nMethods) { | |
1672 int status = env->RegisterNatives(clazz, methods, nMethods); | |
1673 if (status < 0 || env->ExceptionOccurred()) { | |
1674 if (PrintMiscellaneous && (Verbose || WizardMode)) { | |
1675 tty->print_cr("Unsafe: failed registering %s", message); | |
1676 } | |
1677 env->ExceptionClear(); | |
1678 return false; | |
1679 } else { | |
1680 if (PrintMiscellaneous && (Verbose || WizardMode)) { | |
1681 tty->print_cr("Unsafe: successfully registered %s", message); | |
1682 } | |
1683 return true; | |
1684 } | |
1685 } | |
1629 | 1686 |
1630 | 1687 |
1631 // This one function is exported, used by NativeLookup. | 1688 // This one function is exported, used by NativeLookup. |
1632 // The Unsafe_xxx functions above are called only from the interpreter. | 1689 // The Unsafe_xxx functions above are called only from the interpreter. |
1633 // The optimizer looks at names and signatures to recognize | 1690 // The optimizer looks at names and signatures to recognize |
1635 | 1692 |
1636 JVM_ENTRY(void, JVM_RegisterUnsafeMethods(JNIEnv *env, jclass unsafecls)) | 1693 JVM_ENTRY(void, JVM_RegisterUnsafeMethods(JNIEnv *env, jclass unsafecls)) |
1637 UnsafeWrapper("JVM_RegisterUnsafeMethods"); | 1694 UnsafeWrapper("JVM_RegisterUnsafeMethods"); |
1638 { | 1695 { |
1639 ThreadToNativeFromVM ttnfv(thread); | 1696 ThreadToNativeFromVM ttnfv(thread); |
1697 | |
1698 // Unsafe methods | |
1640 { | 1699 { |
1641 env->RegisterNatives(unsafecls, loadavg_method, sizeof(loadavg_method)/sizeof(JNINativeMethod)); | 1700 bool success = false; |
1642 if (env->ExceptionOccurred()) { | 1701 // We need to register the 1.6 methods first because the 1.8 methods would register fine on 1.7 and 1.6 |
1643 if (PrintMiscellaneous && (Verbose || WizardMode)) { | 1702 if (!success) { |
1644 tty->print_cr("Warning: SDK 1.6 Unsafe.loadavg not found."); | 1703 success = register_natives("1.6 methods", env, unsafecls, methods_16, sizeof(methods_16)/sizeof(JNINativeMethod)); |
1645 } | |
1646 env->ExceptionClear(); | |
1647 } | 1704 } |
1648 } | 1705 if (!success) { |
1706 success = register_natives("1.8 methods", env, unsafecls, methods_18, sizeof(methods_18)/sizeof(JNINativeMethod)); | |
1707 } | |
1708 if (!success) { | |
1709 success = register_natives("1.5 methods", env, unsafecls, methods_15, sizeof(methods_15)/sizeof(JNINativeMethod)); | |
1710 } | |
1711 if (!success) { | |
1712 success = register_natives("1.4.1 methods", env, unsafecls, methods_141, sizeof(methods_141)/sizeof(JNINativeMethod)); | |
1713 } | |
1714 if (!success) { | |
1715 success = register_natives("1.4.0 methods", env, unsafecls, methods_140, sizeof(methods_140)/sizeof(JNINativeMethod)); | |
1716 } | |
1717 guarantee(success, "register unsafe natives"); | |
1718 } | |
1719 | |
1720 // Unsafe.getLoadAverage | |
1721 register_natives("1.6 loadavg method", env, unsafecls, loadavg_method, sizeof(loadavg_method)/sizeof(JNINativeMethod)); | |
1722 | |
1723 // Prefetch methods | |
1724 register_natives("1.6 prefetch methods", env, unsafecls, prefetch_methods, sizeof(prefetch_methods)/sizeof(JNINativeMethod)); | |
1725 | |
1726 // Memory copy methods | |
1649 { | 1727 { |
1650 env->RegisterNatives(unsafecls, prefetch_methods, sizeof(prefetch_methods)/sizeof(JNINativeMethod)); | 1728 bool success = false; |
1651 if (env->ExceptionOccurred()) { | 1729 if (!success) { |
1652 if (PrintMiscellaneous && (Verbose || WizardMode)) { | 1730 success = register_natives("1.7 memory copy methods", env, unsafecls, memcopy_methods_17, sizeof(memcopy_methods_17)/sizeof(JNINativeMethod)); |
1653 tty->print_cr("Warning: SDK 1.6 Unsafe.prefetchRead/Write not found."); | |
1654 } | |
1655 env->ExceptionClear(); | |
1656 } | 1731 } |
1657 } | 1732 if (!success) { |
1658 { | 1733 success = register_natives("1.5 memory copy methods", env, unsafecls, memcopy_methods_15, sizeof(memcopy_methods_15)/sizeof(JNINativeMethod)); |
1659 env->RegisterNatives(unsafecls, memcopy_methods, sizeof(memcopy_methods)/sizeof(JNINativeMethod)); | |
1660 if (env->ExceptionOccurred()) { | |
1661 if (PrintMiscellaneous && (Verbose || WizardMode)) { | |
1662 tty->print_cr("Warning: SDK 1.7 Unsafe.copyMemory not found."); | |
1663 } | |
1664 env->ExceptionClear(); | |
1665 env->RegisterNatives(unsafecls, memcopy_methods_15, sizeof(memcopy_methods_15)/sizeof(JNINativeMethod)); | |
1666 if (env->ExceptionOccurred()) { | |
1667 if (PrintMiscellaneous && (Verbose || WizardMode)) { | |
1668 tty->print_cr("Warning: SDK 1.5 Unsafe.copyMemory not found."); | |
1669 } | |
1670 env->ExceptionClear(); | |
1671 } | |
1672 } | 1734 } |
1673 } | 1735 } |
1736 | |
1737 // Unsafe.defineAnonymousClass | |
1674 if (EnableInvokeDynamic) { | 1738 if (EnableInvokeDynamic) { |
1675 env->RegisterNatives(unsafecls, anonk_methods, sizeof(anonk_methods)/sizeof(JNINativeMethod)); | 1739 register_natives("1.7 define anonymous class method", env, unsafecls, anonk_methods, sizeof(anonk_methods)/sizeof(JNINativeMethod)); |
1676 if (env->ExceptionOccurred()) { | 1740 } |
1677 if (PrintMiscellaneous && (Verbose || WizardMode)) { | 1741 |
1678 tty->print_cr("Warning: SDK 1.7 Unsafe.defineClass (anonymous version) not found."); | 1742 // Unsafe.shouldBeInitialized |
1679 } | |
1680 env->ExceptionClear(); | |
1681 } | |
1682 } | |
1683 if (EnableInvokeDynamic) { | 1743 if (EnableInvokeDynamic) { |
1684 env->RegisterNatives(unsafecls, lform_methods, sizeof(lform_methods)/sizeof(JNINativeMethod)); | 1744 register_natives("1.7 LambdaForm support", env, unsafecls, lform_methods, sizeof(lform_methods)/sizeof(JNINativeMethod)); |
1685 if (env->ExceptionOccurred()) { | 1745 } |
1686 if (PrintMiscellaneous && (Verbose || WizardMode)) { | 1746 |
1687 tty->print_cr("Warning: SDK 1.7 LambdaForm support in Unsafe not found."); | 1747 // Fence methods |
1688 } | 1748 register_natives("1.8 fence methods", env, unsafecls, fence_methods, sizeof(fence_methods)/sizeof(JNINativeMethod)); |
1689 env->ExceptionClear(); | |
1690 } | |
1691 } | |
1692 int status = env->RegisterNatives(unsafecls, methods, sizeof(methods)/sizeof(JNINativeMethod)); | |
1693 if (env->ExceptionOccurred()) { | |
1694 if (PrintMiscellaneous && (Verbose || WizardMode)) { | |
1695 tty->print_cr("Warning: SDK 1.6 version of Unsafe not found."); | |
1696 } | |
1697 env->ExceptionClear(); | |
1698 // %%% For now, be backward compatible with an older class: | |
1699 status = env->RegisterNatives(unsafecls, methods_15, sizeof(methods_15)/sizeof(JNINativeMethod)); | |
1700 } | |
1701 if (env->ExceptionOccurred()) { | |
1702 if (PrintMiscellaneous && (Verbose || WizardMode)) { | |
1703 tty->print_cr("Warning: SDK 1.5 version of Unsafe not found."); | |
1704 } | |
1705 env->ExceptionClear(); | |
1706 // %%% For now, be backward compatible with an older class: | |
1707 status = env->RegisterNatives(unsafecls, methods_141, sizeof(methods_141)/sizeof(JNINativeMethod)); | |
1708 } | |
1709 if (env->ExceptionOccurred()) { | |
1710 if (PrintMiscellaneous && (Verbose || WizardMode)) { | |
1711 tty->print_cr("Warning: SDK 1.4.1 version of Unsafe not found."); | |
1712 } | |
1713 env->ExceptionClear(); | |
1714 // %%% For now, be backward compatible with an older class: | |
1715 status = env->RegisterNatives(unsafecls, methods_140, sizeof(methods_140)/sizeof(JNINativeMethod)); | |
1716 } | |
1717 guarantee(status == 0, "register unsafe natives"); | |
1718 } | 1749 } |
1719 JVM_END | 1750 JVM_END |