< prev index next >

src/hotspot/share/ci/ciReplay.cpp

Print this page

  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   }
< prev index next >