src/hotspot/share/classfile/javaClasses.inline.hpp

rev 54069 : 8220496: Race in java_lang_String::length() when deduplicating
Reviewed-by: shade

*** 37,93 ****
  
  void java_lang_String::set_value_raw(oop string, typeArrayOop buffer) {
    assert(initialized, "Must be initialized");
    string->obj_field_put_raw(value_offset, buffer);
  }
  void java_lang_String::set_value(oop string, typeArrayOop buffer) {
    assert(initialized && (value_offset > 0), "Must be initialized");
    string->obj_field_put(value_offset, (oop)buffer);
  }
  void java_lang_String::set_hash(oop string, unsigned int hash) {
    assert(initialized && (hash_offset > 0), "Must be initialized");
    string->int_field_put(hash_offset, hash);
  }
  
  // Accessors
  typeArrayOop java_lang_String::value(oop java_string) {
    assert(initialized && (value_offset > 0), "Must be initialized");
    assert(is_instance(java_string), "must be java_string");
    return (typeArrayOop) java_string->obj_field(value_offset);
  }
  typeArrayOop java_lang_String::value_no_keepalive(oop java_string) {
    assert(initialized && (value_offset > 0), "Must be initialized");
    assert(is_instance(java_string), "must be java_string");
    return (typeArrayOop) java_string->obj_field_access<AS_NO_KEEPALIVE>(value_offset);
  }
  unsigned int java_lang_String::hash(oop java_string) {
    assert(initialized && (hash_offset > 0), "Must be initialized");
    assert(is_instance(java_string), "must be java_string");
    return java_string->int_field(hash_offset);
  }
  bool java_lang_String::is_latin1(oop java_string) {
    assert(initialized && (coder_offset > 0), "Must be initialized");
    assert(is_instance(java_string), "must be java_string");
    jbyte coder = java_string->byte_field(coder_offset);
    assert(CompactStrings || coder == CODER_UTF16, "Must be UTF16 without CompactStrings");
    return coder == CODER_LATIN1;
  }
  int java_lang_String::length(oop java_string, typeArrayOop value) {
    assert(initialized, "Must be initialized");
    assert(is_instance(java_string), "must be java_string");
!   assert(oopDesc::equals(value, java_lang_String::value(java_string)),
!          "value must be same as java_lang_String::value(java_string)");
    if (value == NULL) {
      return 0;
    }
    int arr_length = value->length();
    if (!is_latin1(java_string)) {
      assert((arr_length & 1) == 0, "should be even for UTF16 string");
      arr_length >>= 1; // convert number of bytes to number of elements
    }
    return arr_length;
  }
  int java_lang_String::length(oop java_string) {
    assert(initialized, "Must be initialized");
    assert(is_instance(java_string), "must be java_string");
    typeArrayOop value = java_lang_String::value_no_keepalive(java_string);
    return length(java_string, value);
--- 37,108 ----
  
  void java_lang_String::set_value_raw(oop string, typeArrayOop buffer) {
    assert(initialized, "Must be initialized");
    string->obj_field_put_raw(value_offset, buffer);
  }
+ 
  void java_lang_String::set_value(oop string, typeArrayOop buffer) {
    assert(initialized && (value_offset > 0), "Must be initialized");
    string->obj_field_put(value_offset, (oop)buffer);
  }
+ 
  void java_lang_String::set_hash(oop string, unsigned int hash) {
    assert(initialized && (hash_offset > 0), "Must be initialized");
    string->int_field_put(hash_offset, hash);
  }
  
  // Accessors
+ bool java_lang_String::values_equal(typeArrayOop str_value1, typeArrayOop str_value2) {
+   return (oopDesc::equals(str_value1, str_value2) ||
+           (str_value1->length() == str_value2->length() &&
+            (!memcmp(str_value1->base(T_BYTE),
+                     str_value2->base(T_BYTE),
+                     str_value2->length() * sizeof(jbyte)))));
+ }
+ 
  typeArrayOop java_lang_String::value(oop java_string) {
    assert(initialized && (value_offset > 0), "Must be initialized");
    assert(is_instance(java_string), "must be java_string");
    return (typeArrayOop) java_string->obj_field(value_offset);
  }
+ 
  typeArrayOop java_lang_String::value_no_keepalive(oop java_string) {
    assert(initialized && (value_offset > 0), "Must be initialized");
    assert(is_instance(java_string), "must be java_string");
    return (typeArrayOop) java_string->obj_field_access<AS_NO_KEEPALIVE>(value_offset);
  }
+ 
  unsigned int java_lang_String::hash(oop java_string) {
    assert(initialized && (hash_offset > 0), "Must be initialized");
    assert(is_instance(java_string), "must be java_string");
    return java_string->int_field(hash_offset);
  }
+ 
  bool java_lang_String::is_latin1(oop java_string) {
    assert(initialized && (coder_offset > 0), "Must be initialized");
    assert(is_instance(java_string), "must be java_string");
    jbyte coder = java_string->byte_field(coder_offset);
    assert(CompactStrings || coder == CODER_UTF16, "Must be UTF16 without CompactStrings");
    return coder == CODER_LATIN1;
  }
+ 
  int java_lang_String::length(oop java_string, typeArrayOop value) {
    assert(initialized, "Must be initialized");
    assert(is_instance(java_string), "must be java_string");
!   assert(values_equal(value, java_lang_String::value(java_string)),
!          "value must be equal to java_lang_String::value(java_string)");
    if (value == NULL) {
      return 0;
    }
    int arr_length = value->length();
    if (!is_latin1(java_string)) {
      assert((arr_length & 1) == 0, "should be even for UTF16 string");
      arr_length >>= 1; // convert number of bytes to number of elements
    }
    return arr_length;
  }
+ 
  int java_lang_String::length(oop java_string) {
    assert(initialized, "Must be initialized");
    assert(is_instance(java_string), "must be java_string");
    typeArrayOop value = java_lang_String::value_no_keepalive(java_string);
    return length(java_string, value);
*** 99,144 ****
--- 114,172 ----
  
  // Accessors
  oop java_lang_ref_Reference::referent(oop ref) {
    return ref->obj_field(referent_offset);
  }
+ 
  void java_lang_ref_Reference::set_referent(oop ref, oop value) {
    ref->obj_field_put(referent_offset, value);
  }
+ 
  void java_lang_ref_Reference::set_referent_raw(oop ref, oop value) {
    ref->obj_field_put_raw(referent_offset, value);
  }
+ 
  HeapWord* java_lang_ref_Reference::referent_addr_raw(oop ref) {
    return ref->obj_field_addr_raw<HeapWord>(referent_offset);
  }
+ 
  oop java_lang_ref_Reference::next(oop ref) {
    return ref->obj_field(next_offset);
  }
+ 
  void java_lang_ref_Reference::set_next(oop ref, oop value) {
    ref->obj_field_put(next_offset, value);
  }
+ 
  void java_lang_ref_Reference::set_next_raw(oop ref, oop value) {
    ref->obj_field_put_raw(next_offset, value);
  }
+ 
  HeapWord* java_lang_ref_Reference::next_addr_raw(oop ref) {
    return ref->obj_field_addr_raw<HeapWord>(next_offset);
  }
+ 
  oop java_lang_ref_Reference::discovered(oop ref) {
    return ref->obj_field(discovered_offset);
  }
+ 
  void java_lang_ref_Reference::set_discovered(oop ref, oop value) {
    ref->obj_field_put(discovered_offset, value);
  }
+ 
  void java_lang_ref_Reference::set_discovered_raw(oop ref, oop value) {
    ref->obj_field_put_raw(discovered_offset, value);
  }
+ 
  HeapWord* java_lang_ref_Reference::discovered_addr_raw(oop ref) {
    return ref->obj_field_addr_raw<HeapWord>(discovered_offset);
  }
+ 
  bool java_lang_ref_Reference::is_final(oop ref) {
    return InstanceKlass::cast(ref->klass())->reference_type() == REF_FINAL;
  }
+ 
  bool java_lang_ref_Reference::is_phantom(oop ref) {
    return InstanceKlass::cast(ref->klass())->reference_type() == REF_PHANTOM;
  }
  
  inline void java_lang_invoke_CallSite::set_target_volatile(oop site, oop target) {