jdk-sandbox: comparison src/hotspot/share/interpreter/bytecodeUtils.cpp

equal deleted inserted replaced

-:1735d39dbff9
+:472db1657c6d
 if ((bci >= start) && (bci < end) && (elem->slot == slot)) {
 ConstantPool* cp = method->constants();
 char *var =  cp->symbol_at(elem->name_cp_index)->as_C_string();
 if (strlen(var) == 4 && strcmp(var, "this") == 0) {
-reason.print("loaded from 'this'");
+reason.print("this");
 } else {
-reason.print("loaded from local variable '%s'", var);
+reason.print("%s", var);
 }
 return TrackingStackSource(TrackingStackSource::LOCAL_VAR, bci, reason.as_string());
 }
 }
 }
 // Handle at least some cases we know.
 if (!method->is_static() && (slot == 0)) {
-reason.print("loaded from 'this'");
+reason.print("this");
 } else {
 int curr = method->is_static() ? 0 : 1;
 SignatureStream ss(method->signature());
 int param_index = 0;
 bool found = false;
 param_index += 1;
 curr += size;
 }
 if (found) {
-reason.print("loaded from the parameter nr. %d of the method", 1 + param_index);
+reason.print("<parameter%d>", 1 + param_index);
 } else {
 // This is the best we can do.
-reason.print("loaded from a local variable at slot %d", slot);
+reason.print("<local%d>", slot);
 }
 }
 return TrackingStackSource(TrackingStackSource::LOCAL_VAR, bci, reason.as_string());
 }
-static TrackingStackSource createMethodSource(int bci, Method* method, int cp_index) {
-// We assume outermost caller has ResourceMark.
+static TrackingStackSource createConstantSource(int bci, const char *text) {
-stringStream reason;
+return TrackingStackSource(TrackingStackSource::CONSTANT, bci, text);
-reason.print("returned from '%s'", MethodBytecodePrinter::get_method_name(method, cp_index));
-return TrackingStackSource(TrackingStackSource::METHOD, bci, reason.as_string());
-}
-static TrackingStackSource createConstantSource(int bci) {
-return TrackingStackSource(TrackingStackSource::CONSTANT, bci, "loaded from a constant");
 }
 static TrackingStackSource createArraySource(int bci, TrackingStackSource const& array_source,
 TrackingStackSource const& index_source) {
 // We assume outermost caller has ResourceMark.
 stringStream reason;
 if (array_source.get_type() != TrackingStackSource::INVALID) {
-if (index_source.get_type() != TrackingStackSource::INVALID) {
+reason.print("%s", array_source.as_string());
-reason.print("loaded from an array (which itself was %s) with an index %s",
-array_source.as_string(), index_source.as_string());
-} else {
-reason.print("loaded from an array (which itself was %s)", array_source.as_string());
-}
 } else {
-if (index_source.get_type() != TrackingStackSource::INVALID) {
+reason.print("array");
-reason.print("loaded from an array with an index %s", index_source.as_string());
+}
-} else {
+if (index_source.get_type() != TrackingStackSource::INVALID) {
-reason.print("loaded from an array");
+reason.print("[%s]", index_source.as_string());
-}
+} else {
+reason.print("[...]");
 }
 return TrackingStackSource(TrackingStackSource::ARRAY_ELEM, bci, reason.as_string());
 }
 static TrackingStackSource createFieldSource(int bci, Method* method, int cp_index,
 TrackingStackSource const& object_source) {
 // We assume outermost caller has ResourceMark.
 stringStream reason;
+// GLGL We could also print the type of the field. Should we do that?
+//MethodBytecodePrinter::get_klass_name(method, cp_index)
 if (object_source.get_type() != TrackingStackSource::INVALID) {
-reason.print("loaded from field '%s' of an object %s",
+reason.print("%s.", object_source.as_string());
-MethodBytecodePrinter::get_field_and_class(method, cp_index),
+}
-object_source.as_string());
+reason.print("%s", MethodBytecodePrinter::get_field_name(method, cp_index));
-} else {
-reason.print("loaded from field '%s' of an object",
-MethodBytecodePrinter::get_field_and_class(method, cp_index));
-}
 return TrackingStackSource(TrackingStackSource::FIELD_ELEM, bci, reason.as_string());
 }
 static TrackingStackSource createStaticFieldSource(int bci, Method* method, int cp_index) {
 // We assume outermost caller has ResourceMark.
 stringStream reason;
-reason.print("loaded from static field '%s'",
+reason.print("static %s",
 MethodBytecodePrinter::get_field_and_class(method, cp_index));
 return TrackingStackSource(TrackingStackSource::FIELD_ELEM, bci, reason.as_string());
 }
 case Bytecodes::_dload_3:
 case Bytecodes::_aload_3:
 return createLocalVarSource(source_bci, _method, 3);
 case Bytecodes::_aconst_null:
+return createConstantSource(source_bci, "null");
 case Bytecodes::_iconst_m1:
+return createConstantSource(source_bci, "-1");
 case Bytecodes::_iconst_0:
+return createConstantSource(source_bci, "0");
 case Bytecodes::_iconst_1:
+return createConstantSource(source_bci, "1");
 case Bytecodes::_iconst_2:
+return createConstantSource(source_bci, "2");
 case Bytecodes::_iconst_3:
+return createConstantSource(source_bci, "3");
 case Bytecodes::_iconst_4:
+return createConstantSource(source_bci, "4");
 case Bytecodes::_iconst_5:
+return createConstantSource(source_bci, "5");
 case Bytecodes::_lconst_0:
+return createConstantSource(source_bci, "0L");
 case Bytecodes::_lconst_1:
+return createConstantSource(source_bci, "1L");
 case Bytecodes::_fconst_0:
+return createConstantSource(source_bci, "0.0f");
 case Bytecodes::_fconst_1:
+return createConstantSource(source_bci, "1.0f");
 case Bytecodes::_fconst_2:
+return createConstantSource(source_bci, "2.0f");
 case Bytecodes::_dconst_0:
+return createConstantSource(source_bci, "0.0");
 case Bytecodes::_dconst_1:
-case Bytecodes::_bipush:
+return createConstantSource(source_bci, "1.0");
-case Bytecodes::_sipush:
+case Bytecodes::_bipush: {
-return createConstantSource(source_bci);
+jbyte con = *(jbyte*) (code_base + source_bci + 1);
+stringStream ss;
+ss.print("%d", con);
+return createConstantSource(source_bci, ss.as_string());
+}
+case Bytecodes::_sipush: {
+u2 con = Bytes::get_Java_u2(code_base + source_bci + 1);
+stringStream ss;
+ss.print("%d", con);
+return createConstantSource(source_bci, ss.as_string());
+}
 case Bytecodes::_iaload:
 case Bytecodes::_faload:
 case Bytecodes::_aaload:
 case Bytecodes::_baload:
 case Bytecodes::_caload:
 case Bytecodes::_invokevirtual:
 case Bytecodes::_invokespecial:
 case Bytecodes::_invokestatic:
 case Bytecodes::_invokeinterface: {
 int cp_index = Bytes::get_native_u2(code_base + pos) DEBUG_ONLY(+ ConstantPool::CPCACHE_INDEX_TAG);
-return createMethodSource(source_bci, _method, cp_index);
+// We assume outermost caller has ResourceMark.
+stringStream reason;
+if (max_detail == 5 /* Todo: introduce a constant ... */) {
+reason.print("The return value of '%s'", MethodBytecodePrinter::get_method_name(_method, cp_index));
+} else {
+reason.print("%s", MethodBytecodePrinter::get_method_name(_method, cp_index));
+}
+return TrackingStackSource(TrackingStackSource::METHOD, source_bci, reason.as_string());
 }
 case Bytecodes::_getstatic:
 return createStaticFieldSource(source_bci, _method,
 Bytes::get_native_u2(code_base + pos) + ConstantPool::CPCACHE_INDEX_TAG);
 int result = -1;
 switch (code) {
 case Bytecodes::_iaload:
 if (reason != NULL) {
-*reason = "while trying to load from a null int array";
+*reason = "Can not load from null int array.";
 }
 result = 1;
 break;
 case Bytecodes::_faload:
 if (reason != NULL) {
-*reason = "while trying to load from a null float array";
+*reason = "Can not load from null float array.";
 }
 result = 1;
 break;
 case Bytecodes::_aaload:
 if (reason != NULL) {
-*reason = "while trying to load from a null object array";
+*reason = "Can not load from null object array.";
 }
 result = 1;
 break;
 case Bytecodes::_baload:
 if (reason != NULL) {
-*reason = "while trying to load from a null byte (or boolean) array";
+*reason = "Can not load from null byte/boolean array.";
 }
 result = 1;
 break;
 case Bytecodes::_caload:
 if (reason != NULL) {
-*reason = "while trying to load from a null char array";
+*reason = "Can not load from null char array.";
 }
 result = 1;
 break;
 case Bytecodes::_saload:
 if (reason != NULL) {
-*reason = "while trying to load from a null short array";
+*reason = "Can not load from null short array.";
 }
 result = 1;
 break;
 case Bytecodes::_laload:
 if (reason != NULL) {
-*reason = "while trying to load from a null long array";
+*reason = "Can not load from null long array.";
 }
 result = 1;
 break;
 case Bytecodes::_daload:
 if (reason != NULL) {
-*reason = "while trying to load from a null double array";
+*reason = "Can not load from null double array.";
 }
 result = 1;
 break;
 case Bytecodes::_iastore:
 if (reason != NULL) {
-*reason = "while trying to store to a null int array";
+*reason = "Can not store to null int array.";
 }
 result = 2;
 break;
 case Bytecodes::_lastore:
 if (reason != NULL) {
-*reason = "while trying to store to a null long array";
+*reason = "Can not store to null long array.";
 }
 result = 3;
 break;
 case Bytecodes::_fastore:
 if (reason != NULL) {
-*reason = "while trying to store to a null float array";
+*reason = "Can not store to null float array.";
 }
 result = 2;
 break;
 case Bytecodes::_dastore:
 if (reason != NULL) {
-*reason = "while trying to store to a null double array";
+*reason = "Can not store to null double array.";
 }
 result = 3;
 break;
 case Bytecodes::_aastore:
 if (reason != NULL) {
-*reason = "while trying to store to a null object array";
+*reason = "Can not store to null object array.";
 }
 result = 2;
 break;
 case Bytecodes::_bastore:
 if (reason != NULL) {
-*reason = "while trying to store to a null byte (or boolean) array";
+*reason = "Can not store to to null byte/boolean array.";
 }
 result = 2;
 break;
 case Bytecodes::_castore:
 if (reason != NULL) {
-*reason = "while trying to store to a null char array";
+*reason = "Can not store to to null char array.";
 }
 result = 2;
 break;
 case Bytecodes::_sastore:
 if (reason != NULL) {
-*reason = "while trying to store to a null short array";
+*reason = "Can not store to null short array.";
 }
 result = 2;
 break;
 ConstantPool* cp = _method->constants();
 int name_and_type_index = cp->name_and_type_ref_index_at(cp_index);
 int name_index = cp->name_ref_index_at(name_and_type_index);
 Symbol* name = cp->symbol_at(name_index);
 stringStream ss;
-ss.print("while trying to read the field '%s' of a null object", name->as_C_string());
+ss.print("Can not read field '%s'.", name->as_C_string());
 *reason = ss.as_string();
 }
 result = 0;
 }
 break;
 case Bytecodes::_arraylength:
 if (reason != NULL) {
-*reason = "while trying to get the length of a null array";
+*reason = "Can not read the array length.";
 }
 result = 0;
 break;
 case Bytecodes::_athrow:
 if (reason != NULL) {
-*reason = "while trying to throw a null exception object";
+*reason = "Can not throw a null exception object.";
 }
 result = 0;
 break;
 case Bytecodes::_monitorenter:
 if (reason != NULL) {
-*reason = "while trying to enter a null monitor";
+*reason = "Can not enter a null monitor.";
 }
 result = 0;
 break;
 case Bytecodes::_monitorexit:
 if (reason != NULL) {
-*reason = "while trying to exit a null monitor";
+*reason = "Can not exit a null monitor.";
 }
 result = 0;
 break;
 int type_index = cp->signature_ref_index_at(name_and_type_index);
 Symbol* signature = cp->symbol_at(type_index);
 if (reason != NULL) {
 stringStream ss;
-ss.print("while trying to write the field '%s' of a null object",
+ss.print("Can not write field '%s'.",
-MethodBytecodePrinter::get_field_and_class(_method, cp_index));
+MethodBytecodePrinter::get_field_name(_method, cp_index));
 *reason = ss.as_string();
 }
 result = type2size[char2type((char) signature->char_at(0))];
 }
 // (which is true in Java). This is mainly used to avoid generating wrong
 // messages for NullPointerExceptions created explicitly by new in Java code.
 if (name != vmSymbols::object_initializer_name()) {
 if (reason != NULL) {
 stringStream ss;
-ss.print("while trying to invoke the method '%s' on a null reference",
+ss.print("Can not invoke method '%s'.",
 MethodBytecodePrinter::get_method_name(_method, cp_index));
 *reason = ss.as_string();
 }
 result = ArgumentSizeComputer(signature).size();

branch	JEP-8220715-NPE_messages
changeset 57272	472db1657c6d
parent 57271	1735d39dbff9
child 57319	aa400d41ebd6