src/share/vm/classfile/javaClasses.cpp

@@ -210,11 +210,13 @@
     return Handle();
   }
   int length = UTF8::unicode_length(utf8_str);
   Handle h_obj = basic_create(length, CHECK_NH);
   if (length > 0) {
-    UTF8::convert_to_unicode(utf8_str, value(h_obj())->char_at_addr(0), length);
+    typeArrayOop buffer = value(h_obj());
+    buffer = typeArrayOop(oopDesc::bs()->write_barrier(buffer));
+    UTF8::convert_to_unicode(utf8_str, buffer->char_at_addr(0), length);
   }
   return h_obj;
 }
 
 oop java_lang_String::create_oop_from_str(const char* utf8_str, TRAPS) {

@@ -224,11 +226,13 @@
 
 Handle java_lang_String::create_from_symbol(Symbol* symbol, TRAPS) {
   int length = UTF8::unicode_length((char*)symbol->bytes(), symbol->utf8_length());
   Handle h_obj = basic_create(length, CHECK_NH);
   if (length > 0) {
-    UTF8::convert_to_unicode((char*)symbol->bytes(), value(h_obj())->char_at_addr(0), length);
+    typeArrayOop buffer = value(h_obj());
+    buffer = typeArrayOop(oopDesc::bs()->write_barrier(buffer));
+    UTF8::convert_to_unicode((char*)symbol->bytes(), buffer->char_at_addr(0), length);
   }
   return h_obj;
 }
 
 // Converts a C string to a Java String based on current encoding

@@ -345,18 +349,20 @@
   // Zero length string will hash to zero with String.hashCode() function.
   if (length == 0) return 0;
 
   typeArrayOop value  = java_lang_String::value(java_string);
   int          offset = java_lang_String::offset(java_string);
+  value = typeArrayOop(oopDesc::bs()->read_barrier(value));
   return java_lang_String::hash_code(value->char_at_addr(offset), length);
 }
 
 char* java_lang_String::as_quoted_ascii(oop java_string) {
   typeArrayOop value  = java_lang_String::value(java_string);
   int          offset = java_lang_String::offset(java_string);
   int          length = java_lang_String::length(java_string);
 
+  value = typeArrayOop(oopDesc::bs()->read_barrier(value));
   jchar* base = (length == 0) ? NULL : value->char_at_addr(offset);
   if (base == NULL) return NULL;
 
   int result_length = UNICODE::quoted_ascii_length(base, length) + 1;
   char* result = NEW_RESOURCE_ARRAY(char, result_length);

@@ -373,78 +379,89 @@
     return StringTable::hash_string(NULL, 0);
   }
 
   typeArrayOop value  = java_lang_String::value(java_string);
   int          offset = java_lang_String::offset(java_string);
+  value = typeArrayOop(oopDesc::bs()->read_barrier(value));
   return StringTable::hash_string(value->char_at_addr(offset), length);
 }
 
 Symbol* java_lang_String::as_symbol(Handle java_string, TRAPS) {
   oop          obj    = java_string();
   typeArrayOop value  = java_lang_String::value(obj);
   int          offset = java_lang_String::offset(obj);
   int          length = java_lang_String::length(obj);
+  value = typeArrayOop(oopDesc::bs()->read_barrier(value));
   jchar* base = (length == 0) ? NULL : value->char_at_addr(offset);
   Symbol* sym = SymbolTable::lookup_unicode(base, length, THREAD);
   return sym;
 }
 
 Symbol* java_lang_String::as_symbol_or_null(oop java_string) {
   typeArrayOop value  = java_lang_String::value(java_string);
   int          offset = java_lang_String::offset(java_string);
   int          length = java_lang_String::length(java_string);
+  value = typeArrayOop(oopDesc::bs()->read_barrier(value));
   jchar* base = (length == 0) ? NULL : value->char_at_addr(offset);
   return SymbolTable::probe_unicode(base, length);
 }
 
 
 int java_lang_String::utf8_length(oop java_string) {
   typeArrayOop value  = java_lang_String::value(java_string);
   int          offset = java_lang_String::offset(java_string);
   int          length = java_lang_String::length(java_string);
+  value = typeArrayOop(oopDesc::bs()->read_barrier(value));
   jchar* position = (length == 0) ? NULL : value->char_at_addr(offset);
   return UNICODE::utf8_length(position, length);
 }
 
 char* java_lang_String::as_utf8_string(oop java_string) {
   typeArrayOop value  = java_lang_String::value(java_string);
   int          offset = java_lang_String::offset(java_string);
   int          length = java_lang_String::length(java_string);
+  value = typeArrayOop(oopDesc::bs()->read_barrier(value));
   jchar* position = (length == 0) ? NULL : value->char_at_addr(offset);
   return UNICODE::as_utf8(position, length);
 }
 
 char* java_lang_String::as_utf8_string(oop java_string, char* buf, int buflen) {
   typeArrayOop value  = java_lang_String::value(java_string);
   int          offset = java_lang_String::offset(java_string);
   int          length = java_lang_String::length(java_string);
+  value = typeArrayOop(oopDesc::bs()->read_barrier(value));
   jchar* position = (length == 0) ? NULL : value->char_at_addr(offset);
   return UNICODE::as_utf8(position, length, buf, buflen);
 }
 
 char* java_lang_String::as_utf8_string(oop java_string, int start, int len) {
   typeArrayOop value  = java_lang_String::value(java_string);
   int          offset = java_lang_String::offset(java_string);
   int          length = java_lang_String::length(java_string);
   assert(start + len <= length, "just checking");
+  value = typeArrayOop(oopDesc::bs()->read_barrier(value));
   jchar* position = value->char_at_addr(offset + start);
   return UNICODE::as_utf8(position, len);
 }
 
 char* java_lang_String::as_utf8_string(oop java_string, int start, int len, char* buf, int buflen) {
   typeArrayOop value  = java_lang_String::value(java_string);
   int          offset = java_lang_String::offset(java_string);
   int          length = java_lang_String::length(java_string);
   assert(start + len <= length, "just checking");
+  value = typeArrayOop(oopDesc::bs()->read_barrier(value));
   jchar* position = value->char_at_addr(offset + start);
   return UNICODE::as_utf8(position, len, buf, buflen);
 }
 
 bool java_lang_String::equals(oop java_string, jchar* chars, int len) {
   assert(java_string->klass() == SystemDictionary::String_klass(),
          "must be java_string");
   typeArrayOop value  = java_lang_String::value(java_string);
+  if (ShenandoahVerifyReadsToFromSpace) {
+    value = (typeArrayOop) oopDesc::bs()->read_barrier(value);
+  }
   int          offset = java_lang_String::offset(java_string);
   int          length = java_lang_String::length(java_string);
   if (length != len) {
     return false;
   }

@@ -861,13 +878,13 @@
   BasicType type = T_VOID;
   if (ak != NULL) {
     // Note: create_basic_type_mirror above initializes ak to a non-null value.
     type = ArrayKlass::cast(ak)->element_type();
   } else {
-    assert(java_class == Universe::void_mirror(), "only valid non-array primitive");
+    assert(oopDesc::bs()->write_barrier(java_class) == oopDesc::bs()->write_barrier(Universe::void_mirror()), "only valid non-array primitive");
   }
-  assert(Universe::java_mirror(type) == java_class, "must be consistent");
+  assert(oopDesc::bs()->write_barrier(Universe::java_mirror(type)) == oopDesc::bs()->write_barrier(java_class), "must be consistent");
   return type;
 }
 
 BasicType java_lang_Class::as_BasicType(oop java_class, Klass** reference_klass) {
   assert(java_lang_Class::is_instance(java_class), "must be a Class object");

@@ -3089,10 +3106,11 @@
     assert(loader != NULL && loader->is_oop(), "loader must be oop");
     return (ClassLoaderData**) loader->address_field_addr(_loader_data_offset);
 }
 
 ClassLoaderData* java_lang_ClassLoader::loader_data(oop loader) {
+  loader = oopDesc::bs()->read_barrier(loader);
   return *java_lang_ClassLoader::loader_data_addr(loader);
 }
 
 void java_lang_ClassLoader::compute_offsets() {
   assert(!offsets_computed, "offsets should be initialized only once");

@@ -3105,10 +3123,13 @@
 
   CLASSLOADER_INJECTED_FIELDS(INJECTED_FIELD_COMPUTE_OFFSET);
 }
 
 oop java_lang_ClassLoader::parent(oop loader) {
+  if (ShenandoahVerifyReadsToFromSpace) {
+    loader = oopDesc::bs()->read_barrier(loader);
+  }
   assert(is_instance(loader), "loader must be oop");
   return loader->obj_field(parent_offset);
 }
 
 bool java_lang_ClassLoader::isAncestor(oop loader, oop cl) {