25 #include "precompiled.hpp"
26 #include "jvm.h"
27 #include "ci/ciMethodData.hpp"
28 #include "ci/ciReplay.hpp"
29 #include "ci/ciSymbol.hpp"
30 #include "ci/ciKlass.hpp"
31 #include "ci/ciUtilities.inline.hpp"
32 #include "classfile/javaClasses.hpp"
33 #include "classfile/symbolTable.hpp"
34 #include "classfile/systemDictionary.hpp"
35 #include "compiler/compilationPolicy.hpp"
36 #include "compiler/compileBroker.hpp"
37 #include "compiler/compilerDefinitions.inline.hpp"
38 #include "interpreter/linkResolver.hpp"
39 #include "memory/allocation.inline.hpp"
40 #include "memory/oopFactory.hpp"
41 #include "memory/resourceArea.hpp"
42 #include "oops/constantPool.hpp"
43 #include "oops/cpCache.inline.hpp"
44 #include "oops/fieldStreams.inline.hpp"
45 #include "oops/klass.inline.hpp"
46 #include "oops/method.inline.hpp"
47 #include "oops/oop.inline.hpp"
48 #include "prims/jvmtiExport.hpp"
49 #include "prims/methodHandles.hpp"
50 #include "runtime/fieldDescriptor.inline.hpp"
51 #include "runtime/globals_extension.hpp"
52 #include "runtime/handles.inline.hpp"
53 #include "runtime/java.hpp"
54 #include "runtime/jniHandles.inline.hpp"
55 #include "runtime/threads.hpp"
56 #include "utilities/copy.hpp"
57 #include "utilities/macros.hpp"
58 #include "utilities/utf8.hpp"
59
60 // ciReplay
61
62 typedef struct _ciMethodDataRecord {
63 const char* _klass_name;
64 const char* _method_name;
961 ConstantPool* cp = k->constants();
962 if (length != cp->length()) {
963 report_error("constant pool length mismatch: wrong class files?");
964 return;
965 }
966
967 int parsed_two_word = 0;
968 for (int i = 1; i < length; i++) {
969 int tag = parse_int("tag");
970 if (had_error()) {
971 return;
972 }
973 switch (cp->tag_at(i).value()) {
974 case JVM_CONSTANT_UnresolvedClass: {
975 if (tag == JVM_CONSTANT_Class) {
976 tty->print_cr("Resolving klass %s at %d", cp->klass_name_at(i)->as_utf8(), i);
977 Klass* k = cp->klass_at(i, CHECK);
978 }
979 break;
980 }
981 case JVM_CONSTANT_Long:
982 case JVM_CONSTANT_Double:
983 parsed_two_word = i + 1;
984
985 case JVM_CONSTANT_ClassIndex:
986 case JVM_CONSTANT_StringIndex:
987 case JVM_CONSTANT_String:
988 case JVM_CONSTANT_UnresolvedClassInError:
989 case JVM_CONSTANT_Fieldref:
990 case JVM_CONSTANT_Methodref:
991 case JVM_CONSTANT_InterfaceMethodref:
992 case JVM_CONSTANT_NameAndType:
993 case JVM_CONSTANT_Utf8:
994 case JVM_CONSTANT_Integer:
995 case JVM_CONSTANT_Float:
996 case JVM_CONSTANT_MethodHandle:
997 case JVM_CONSTANT_MethodType:
998 case JVM_CONSTANT_Dynamic:
999 case JVM_CONSTANT_InvokeDynamic:
1000 if (tag != cp->tag_at(i).value()) {
1007 if (tag == JVM_CONSTANT_UnresolvedClass) {
1008 Klass* k = cp->klass_at(i, CHECK);
1009 tty->print_cr("Warning: entry was unresolved in the replay data: %s", k->name()->as_utf8());
1010 } else if (tag != JVM_CONSTANT_Class) {
1011 report_error("Unexpected tag");
1012 return;
1013 }
1014 break;
1015
1016 case 0:
1017 if (parsed_two_word == i) continue;
1018
1019 default:
1020 fatal("Unexpected tag: %d", cp->tag_at(i).value());
1021 break;
1022 }
1023
1024 }
1025 }
1026
1027 // staticfield <klass> <name> <signature> <value>
1028 //
1029 // Initialize a class and fill in the value for a static field.
1030 // This is useful when the compile was dependent on the value of
1031 // static fields but it's impossible to properly rerun the static
1032 // initializer.
1033 void process_staticfield(TRAPS) {
1034 InstanceKlass* k = (InstanceKlass *)parse_klass(CHECK);
1035
1036 if (k == NULL || ReplaySuppressInitializers == 0 ||
1037 (ReplaySuppressInitializers == 2 && k->class_loader() == NULL)) {
1038 skip_remaining();
1039 return;
1040 }
1041
1042 assert(k->is_initialized(), "must be");
1043
1044 const char* field_name = parse_escaped_string();
1045 const char* field_signature = parse_string();
1046 fieldDescriptor fd;
1047 Symbol* name = SymbolTable::new_symbol(field_name);
1048 Symbol* sig = SymbolTable::new_symbol(field_signature);
1049 if (!k->find_local_field(name, sig, &fd) ||
1050 !fd.is_static() ||
1051 fd.has_initial_value()) {
1052 report_error(field_name);
1053 return;
1054 }
1055
1056 oop java_mirror = k->java_mirror();
1057 if (field_signature[0] == JVM_SIGNATURE_ARRAY) {
1058 int length = parse_int("array length");
1059 oop value = NULL;
1060
1061 if (field_signature[1] == JVM_SIGNATURE_ARRAY) {
1062 // multi dimensional array
1063 ArrayKlass* kelem = (ArrayKlass *)parse_klass(CHECK);
1064 if (kelem == NULL) {
1065 return;
1066 }
1067 int rank = 0;
1068 while (field_signature[rank] == JVM_SIGNATURE_ARRAY) {
1069 rank++;
1070 }
1071 jint* dims = NEW_RESOURCE_ARRAY(jint, rank);
1072 dims[0] = length;
1073 for (int i = 1; i < rank; i++) {
1074 dims[i] = 1; // These aren't relevant to the compiler
1075 }
1076 value = kelem->multi_allocate(rank, dims, CHECK);
1077 } else {
1078 if (strcmp(field_signature, "[B") == 0) {
1079 value = oopFactory::new_byteArray(length, CHECK);
1080 } else if (strcmp(field_signature, "[Z") == 0) {
1081 value = oopFactory::new_boolArray(length, CHECK);
1082 } else if (strcmp(field_signature, "[C") == 0) {
1083 value = oopFactory::new_charArray(length, CHECK);
1084 } else if (strcmp(field_signature, "[S") == 0) {
1085 value = oopFactory::new_shortArray(length, CHECK);
1086 } else if (strcmp(field_signature, "[F") == 0) {
1087 value = oopFactory::new_floatArray(length, CHECK);
1088 } else if (strcmp(field_signature, "[D") == 0) {
1089 value = oopFactory::new_doubleArray(length, CHECK);
1090 } else if (strcmp(field_signature, "[I") == 0) {
1091 value = oopFactory::new_intArray(length, CHECK);
1092 } else if (strcmp(field_signature, "[J") == 0) {
1093 value = oopFactory::new_longArray(length, CHECK);
1094 } else if (field_signature[0] == JVM_SIGNATURE_ARRAY &&
1095 field_signature[1] == JVM_SIGNATURE_CLASS) {
1096 Klass* kelem = resolve_klass(field_signature + 1, CHECK);
1097 value = oopFactory::new_objArray(kelem, length, CHECK);
1098 } else {
1099 report_error("unhandled array staticfield");
1100 }
1101 }
1102 java_mirror->obj_field_put(fd.offset(), value);
1103 } else {
1104 const char* string_value = parse_escaped_string();
1105 if (strcmp(field_signature, "I") == 0) {
1106 int value = atoi(string_value);
1107 java_mirror->int_field_put(fd.offset(), value);
1108 } else if (strcmp(field_signature, "B") == 0) {
1109 int value = atoi(string_value);
1110 java_mirror->byte_field_put(fd.offset(), value);
1111 } else if (strcmp(field_signature, "C") == 0) {
1112 int value = atoi(string_value);
1113 java_mirror->char_field_put(fd.offset(), value);
1114 } else if (strcmp(field_signature, "S") == 0) {
1115 int value = atoi(string_value);
1116 java_mirror->short_field_put(fd.offset(), value);
1117 } else if (strcmp(field_signature, "Z") == 0) {
1118 int value = atoi(string_value);
1119 java_mirror->bool_field_put(fd.offset(), value);
1120 } else if (strcmp(field_signature, "J") == 0) {
1121 jlong value;
1122 if (sscanf(string_value, JLONG_FORMAT, &value) != 1) {
1123 fprintf(stderr, "Error parsing long: %s\n", string_value);
1124 return;
1125 }
1126 java_mirror->long_field_put(fd.offset(), value);
1127 } else if (strcmp(field_signature, "F") == 0) {
1128 float value = atof(string_value);
1129 java_mirror->float_field_put(fd.offset(), value);
1130 } else if (strcmp(field_signature, "D") == 0) {
1131 double value = atof(string_value);
1132 java_mirror->double_field_put(fd.offset(), value);
1133 } else if (strcmp(field_signature, "Ljava/lang/String;") == 0) {
1134 Handle value = java_lang_String::create_from_str(string_value, CHECK);
1135 java_mirror->obj_field_put(fd.offset(), value());
1136 } else if (field_signature[0] == JVM_SIGNATURE_CLASS) {
1137 Klass* k = resolve_klass(string_value, CHECK);
1138 oop value = InstanceKlass::cast(k)->allocate_instance(CHECK);
1139 java_mirror->obj_field_put(fd.offset(), value);
1140 } else {
1141 report_error("unhandled staticfield");
1142 }
1143 }
1144 }
1145
1146 #if INCLUDE_JVMTI
1147 // JvmtiExport <field> <value>
1148 void process_JvmtiExport(TRAPS) {
1149 const char* field = parse_string();
1150 bool value = parse_int("JvmtiExport flag") != 0;
1151 if (strcmp(field, "can_access_local_variables") == 0) {
1152 JvmtiExport::set_can_access_local_variables(value);
1153 } else if (strcmp(field, "can_hotswap_or_post_breakpoint") == 0) {
1154 JvmtiExport::set_can_hotswap_or_post_breakpoint(value);
1155 } else if (strcmp(field, "can_post_on_exceptions") == 0) {
1156 JvmtiExport::set_can_post_on_exceptions(value);
1157 } else {
1158 report_error("Unrecognized JvmtiExport directive");
1159 }
1160 }
|
25 #include "precompiled.hpp"
26 #include "jvm.h"
27 #include "ci/ciMethodData.hpp"
28 #include "ci/ciReplay.hpp"
29 #include "ci/ciSymbol.hpp"
30 #include "ci/ciKlass.hpp"
31 #include "ci/ciUtilities.inline.hpp"
32 #include "classfile/javaClasses.hpp"
33 #include "classfile/symbolTable.hpp"
34 #include "classfile/systemDictionary.hpp"
35 #include "compiler/compilationPolicy.hpp"
36 #include "compiler/compileBroker.hpp"
37 #include "compiler/compilerDefinitions.inline.hpp"
38 #include "interpreter/linkResolver.hpp"
39 #include "memory/allocation.inline.hpp"
40 #include "memory/oopFactory.hpp"
41 #include "memory/resourceArea.hpp"
42 #include "oops/constantPool.hpp"
43 #include "oops/cpCache.inline.hpp"
44 #include "oops/fieldStreams.inline.hpp"
45 #include "oops/inlineKlass.inline.hpp"
46 #include "oops/klass.inline.hpp"
47 #include "oops/method.inline.hpp"
48 #include "oops/oop.inline.hpp"
49 #include "prims/jvmtiExport.hpp"
50 #include "prims/methodHandles.hpp"
51 #include "runtime/fieldDescriptor.inline.hpp"
52 #include "runtime/globals_extension.hpp"
53 #include "runtime/handles.inline.hpp"
54 #include "runtime/java.hpp"
55 #include "runtime/jniHandles.inline.hpp"
56 #include "runtime/threads.hpp"
57 #include "utilities/copy.hpp"
58 #include "utilities/macros.hpp"
59 #include "utilities/utf8.hpp"
60
61 // ciReplay
62
63 typedef struct _ciMethodDataRecord {
64 const char* _klass_name;
65 const char* _method_name;
962 ConstantPool* cp = k->constants();
963 if (length != cp->length()) {
964 report_error("constant pool length mismatch: wrong class files?");
965 return;
966 }
967
968 int parsed_two_word = 0;
969 for (int i = 1; i < length; i++) {
970 int tag = parse_int("tag");
971 if (had_error()) {
972 return;
973 }
974 switch (cp->tag_at(i).value()) {
975 case JVM_CONSTANT_UnresolvedClass: {
976 if (tag == JVM_CONSTANT_Class) {
977 tty->print_cr("Resolving klass %s at %d", cp->klass_name_at(i)->as_utf8(), i);
978 Klass* k = cp->klass_at(i, CHECK);
979 }
980 break;
981 }
982
983 case JVM_CONSTANT_Long:
984 case JVM_CONSTANT_Double:
985 parsed_two_word = i + 1;
986
987 case JVM_CONSTANT_ClassIndex:
988 case JVM_CONSTANT_StringIndex:
989 case JVM_CONSTANT_String:
990 case JVM_CONSTANT_UnresolvedClassInError:
991 case JVM_CONSTANT_Fieldref:
992 case JVM_CONSTANT_Methodref:
993 case JVM_CONSTANT_InterfaceMethodref:
994 case JVM_CONSTANT_NameAndType:
995 case JVM_CONSTANT_Utf8:
996 case JVM_CONSTANT_Integer:
997 case JVM_CONSTANT_Float:
998 case JVM_CONSTANT_MethodHandle:
999 case JVM_CONSTANT_MethodType:
1000 case JVM_CONSTANT_Dynamic:
1001 case JVM_CONSTANT_InvokeDynamic:
1002 if (tag != cp->tag_at(i).value()) {
1009 if (tag == JVM_CONSTANT_UnresolvedClass) {
1010 Klass* k = cp->klass_at(i, CHECK);
1011 tty->print_cr("Warning: entry was unresolved in the replay data: %s", k->name()->as_utf8());
1012 } else if (tag != JVM_CONSTANT_Class) {
1013 report_error("Unexpected tag");
1014 return;
1015 }
1016 break;
1017
1018 case 0:
1019 if (parsed_two_word == i) continue;
1020
1021 default:
1022 fatal("Unexpected tag: %d", cp->tag_at(i).value());
1023 break;
1024 }
1025
1026 }
1027 }
1028
1029 class InlineTypeFieldInitializer : public FieldClosure {
1030 oop _vt;
1031 CompileReplay* _replay;
1032 public:
1033 InlineTypeFieldInitializer(oop vt, CompileReplay* replay)
1034 : _vt(vt), _replay(replay) {}
1035
1036 void do_field(fieldDescriptor* fd) {
1037 BasicType bt = fd->field_type();
1038 const char* string_value = bt != T_PRIMITIVE_OBJECT ? _replay->parse_escaped_string() : NULL;
1039 switch (bt) {
1040 case T_BYTE: {
1041 int value = atoi(string_value);
1042 _vt->byte_field_put(fd->offset(), value);
1043 break;
1044 }
1045 case T_BOOLEAN: {
1046 int value = atoi(string_value);
1047 _vt->bool_field_put(fd->offset(), value);
1048 break;
1049 }
1050 case T_SHORT: {
1051 int value = atoi(string_value);
1052 _vt->short_field_put(fd->offset(), value);
1053 break;
1054 }
1055 case T_CHAR: {
1056 int value = atoi(string_value);
1057 _vt->char_field_put(fd->offset(), value);
1058 break;
1059 }
1060 case T_INT: {
1061 int value = atoi(string_value);
1062 _vt->int_field_put(fd->offset(), value);
1063 break;
1064 }
1065 case T_LONG: {
1066 jlong value;
1067 if (sscanf(string_value, JLONG_FORMAT, &value) != 1) {
1068 fprintf(stderr, "Error parsing long: %s\n", string_value);
1069 break;
1070 }
1071 _vt->long_field_put(fd->offset(), value);
1072 break;
1073 }
1074 case T_FLOAT: {
1075 float value = atof(string_value);
1076 _vt->float_field_put(fd->offset(), value);
1077 break;
1078 }
1079 case T_DOUBLE: {
1080 double value = atof(string_value);
1081 _vt->double_field_put(fd->offset(), value);
1082 break;
1083 }
1084 case T_ARRAY:
1085 case T_OBJECT: {
1086 JavaThread* THREAD = JavaThread::current();
1087 bool res = _replay->process_staticfield_reference(string_value, _vt, fd, THREAD);
1088 assert(res, "should succeed for arrays & objects");
1089 break;
1090 }
1091 case T_PRIMITIVE_OBJECT: {
1092 InlineKlass* vk = InlineKlass::cast(fd->field_holder()->get_inline_type_field_klass(fd->index()));
1093 if (fd->is_inlined()) {
1094 int field_offset = fd->offset() - vk->first_field_offset();
1095 oop obj = cast_to_oop(cast_from_oop<address>(_vt) + field_offset);
1096 InlineTypeFieldInitializer init_fields(obj, _replay);
1097 vk->do_nonstatic_fields(&init_fields);
1098 } else {
1099 oop value = vk->allocate_instance(JavaThread::current());
1100 _vt->obj_field_put(fd->offset(), value);
1101 }
1102 break;
1103 }
1104 default: {
1105 fatal("Unhandled type: %s", type2name(bt));
1106 }
1107 }
1108 }
1109 };
1110
1111 bool process_staticfield_reference(const char* field_signature, oop java_mirror, fieldDescriptor* fd, TRAPS) {
1112 if (field_signature[0] == JVM_SIGNATURE_ARRAY) {
1113 int length = parse_int("array length");
1114 oop value = NULL;
1115
1116 if (field_signature[1] == JVM_SIGNATURE_ARRAY) {
1117 // multi dimensional array
1118 Klass* k = resolve_klass(field_signature, CHECK_(true));
1119 ArrayKlass* kelem = (ArrayKlass *)k;
1120 int rank = 0;
1121 while (field_signature[rank] == JVM_SIGNATURE_ARRAY) {
1122 rank++;
1123 }
1124 jint* dims = NEW_RESOURCE_ARRAY(jint, rank);
1125 dims[0] = length;
1126 for (int i = 1; i < rank; i++) {
1127 dims[i] = 1; // These aren't relevant to the compiler
1128 }
1129 value = kelem->multi_allocate(rank, dims, CHECK_(true));
1130 } else {
1131 if (strcmp(field_signature, "[B") == 0) {
1132 value = oopFactory::new_byteArray(length, CHECK_(true));
1133 } else if (strcmp(field_signature, "[Z") == 0) {
1134 value = oopFactory::new_boolArray(length, CHECK_(true));
1135 } else if (strcmp(field_signature, "[C") == 0) {
1136 value = oopFactory::new_charArray(length, CHECK_(true));
1137 } else if (strcmp(field_signature, "[S") == 0) {
1138 value = oopFactory::new_shortArray(length, CHECK_(true));
1139 } else if (strcmp(field_signature, "[F") == 0) {
1140 value = oopFactory::new_floatArray(length, CHECK_(true));
1141 } else if (strcmp(field_signature, "[D") == 0) {
1142 value = oopFactory::new_doubleArray(length, CHECK_(true));
1143 } else if (strcmp(field_signature, "[I") == 0) {
1144 value = oopFactory::new_intArray(length, CHECK_(true));
1145 } else if (strcmp(field_signature, "[J") == 0) {
1146 value = oopFactory::new_longArray(length, CHECK_(true));
1147 } else if (field_signature[0] == JVM_SIGNATURE_ARRAY &&
1148 field_signature[1] == JVM_SIGNATURE_CLASS) {
1149 Klass* kelem = resolve_klass(field_signature + 1, CHECK_(true));
1150 value = oopFactory::new_objArray(kelem, length, CHECK_(true));
1151 } else if (field_signature[0] == JVM_SIGNATURE_ARRAY &&
1152 field_signature[1] == JVM_SIGNATURE_PRIMITIVE_OBJECT) {
1153 Klass* kelem = resolve_klass(field_signature + 1, CHECK_(true));
1154 value = oopFactory::new_valueArray(kelem, length, CHECK_(true));
1155 } else {
1156 report_error("unhandled array staticfield");
1157 }
1158 }
1159 java_mirror->obj_field_put(fd->offset(), value);
1160 return true;
1161 } else if (strcmp(field_signature, "Ljava/lang/String;") == 0) {
1162 const char* string_value = parse_escaped_string();
1163 Handle value = java_lang_String::create_from_str(string_value, CHECK_(true));
1164 java_mirror->obj_field_put(fd->offset(), value());
1165 return true;
1166 } else if (field_signature[0] == 'L') {
1167 const char* instance = parse_escaped_string();
1168 Klass* k = resolve_klass(instance, CHECK_(true));
1169 oop value = InstanceKlass::cast(k)->allocate_instance(CHECK_(true));
1170 java_mirror->obj_field_put(fd->offset(), value);
1171 return true;
1172 }
1173 return false;
1174 }
1175
1176 // Initialize a class and fill in the value for a static field.
1177 // This is useful when the compile was dependent on the value of
1178 // static fields but it's impossible to properly rerun the static
1179 // initializer.
1180 void process_staticfield(TRAPS) {
1181 InstanceKlass* k = (InstanceKlass *)parse_klass(CHECK);
1182
1183 if (k == NULL || ReplaySuppressInitializers == 0 ||
1184 (ReplaySuppressInitializers == 2 && k->class_loader() == NULL)) {
1185 skip_remaining();
1186 return;
1187 }
1188
1189 assert(k->is_initialized(), "must be");
1190
1191 const char* field_name = parse_escaped_string();
1192 const char* field_signature = parse_string();
1193 fieldDescriptor fd;
1194 Symbol* name = SymbolTable::new_symbol(field_name);
1195 Symbol* sig = SymbolTable::new_symbol(field_signature);
1196 if (!k->find_local_field(name, sig, &fd) ||
1197 !fd.is_static() ||
1198 fd.has_initial_value()) {
1199 report_error(field_name);
1200 return;
1201 }
1202
1203 oop java_mirror = k->java_mirror();
1204 if (strcmp(field_signature, "I") == 0) {
1205 const char* string_value = parse_escaped_string();
1206 int value = atoi(string_value);
1207 java_mirror->int_field_put(fd.offset(), value);
1208 } else if (strcmp(field_signature, "B") == 0) {
1209 const char* string_value = parse_escaped_string();
1210 int value = atoi(string_value);
1211 java_mirror->byte_field_put(fd.offset(), value);
1212 } else if (strcmp(field_signature, "C") == 0) {
1213 const char* string_value = parse_escaped_string();
1214 int value = atoi(string_value);
1215 java_mirror->char_field_put(fd.offset(), value);
1216 } else if (strcmp(field_signature, "S") == 0) {
1217 const char* string_value = parse_escaped_string();
1218 int value = atoi(string_value);
1219 java_mirror->short_field_put(fd.offset(), value);
1220 } else if (strcmp(field_signature, "Z") == 0) {
1221 const char* string_value = parse_escaped_string();
1222 int value = atoi(string_value);
1223 java_mirror->bool_field_put(fd.offset(), value);
1224 } else if (strcmp(field_signature, "J") == 0) {
1225 const char* string_value = parse_escaped_string();
1226 jlong value;
1227 if (sscanf(string_value, JLONG_FORMAT, &value) != 1) {
1228 fprintf(stderr, "Error parsing long: %s\n", string_value);
1229 return;
1230 }
1231 java_mirror->long_field_put(fd.offset(), value);
1232 } else if (strcmp(field_signature, "F") == 0) {
1233 const char* string_value = parse_escaped_string();
1234 float value = atof(string_value);
1235 java_mirror->float_field_put(fd.offset(), value);
1236 } else if (strcmp(field_signature, "D") == 0) {
1237 const char* string_value = parse_escaped_string();
1238 double value = atof(string_value);
1239 java_mirror->double_field_put(fd.offset(), value);
1240 } else if (field_signature[0] == JVM_SIGNATURE_PRIMITIVE_OBJECT) {
1241 Klass* kelem = resolve_klass(field_signature, CHECK);
1242 InlineKlass* vk = InlineKlass::cast(kelem);
1243 oop value = vk->allocate_instance(CHECK);
1244 InlineTypeFieldInitializer init_fields(value, this);
1245 vk->do_nonstatic_fields(&init_fields);
1246 java_mirror->obj_field_put(fd.offset(), value);
1247 } else {
1248 bool res = process_staticfield_reference(field_signature, java_mirror, &fd, CHECK);
1249 if (!res) {
1250 report_error("unhandled staticfield");
1251 }
1252 }
1253 }
1254
1255 #if INCLUDE_JVMTI
1256 // JvmtiExport <field> <value>
1257 void process_JvmtiExport(TRAPS) {
1258 const char* field = parse_string();
1259 bool value = parse_int("JvmtiExport flag") != 0;
1260 if (strcmp(field, "can_access_local_variables") == 0) {
1261 JvmtiExport::set_can_access_local_variables(value);
1262 } else if (strcmp(field, "can_hotswap_or_post_breakpoint") == 0) {
1263 JvmtiExport::set_can_hotswap_or_post_breakpoint(value);
1264 } else if (strcmp(field, "can_post_on_exceptions") == 0) {
1265 JvmtiExport::set_can_post_on_exceptions(value);
1266 } else {
1267 report_error("Unrecognized JvmtiExport directive");
1268 }
1269 }
|