32 void java_lang_String::set_coder(oop string, jbyte coder) {

    33   assert(initialized, "Must be initialized");

    34   if (coder_offset > 0) {

    35     string->byte_field_put(coder_offset, coder);

    36   }

    37 }

    38 

    39 void java_lang_String::set_value_raw(oop string, typeArrayOop buffer) {

    40   assert(initialized, "Must be initialized");

    41   string->obj_field_put_raw(value_offset, buffer);

    42 }

    43 void java_lang_String::set_value(oop string, typeArrayOop buffer) {

    44   assert(initialized && (value_offset > 0), "Must be initialized");

    45   string->obj_field_put(value_offset, (oop)buffer);

    46 }

    47 void java_lang_String::set_hash(oop string, unsigned int hash) {

    48   assert(initialized && (hash_offset > 0), "Must be initialized");

    49   string->int_field_put(hash_offset, hash);

    50 }

    51 

    52 // Accessors

    53 typeArrayOop java_lang_String::value(oop java_string) {

    54   assert(initialized && (value_offset > 0), "Must be initialized");

    55   assert(is_instance(java_string), "must be java_string");

    56   return (typeArrayOop) java_string->obj_field(value_offset);

    57 }

    58 unsigned int java_lang_String::hash(oop java_string) {

    59   assert(initialized && (hash_offset > 0), "Must be initialized");

    60   assert(is_instance(java_string), "must be java_string");

    61   return java_string->int_field(hash_offset);

    62 }

    63 bool java_lang_String::is_latin1(oop java_string) {

    64   assert(initialized, "Must be initialized");

    65   assert(is_instance(java_string), "must be java_string");

    66   if (coder_offset > 0) {

    67     jbyte coder = java_string->byte_field(coder_offset);

    68     assert(CompactStrings || coder == CODER_UTF16, "Must be UTF16 without CompactStrings");

    69     return coder == CODER_LATIN1;

    70   } else {

    71     return false;

    72   }

    73 }

    74 int java_lang_String::length(oop java_string) {

    75   assert(initialized, "Must be initialized");

    76   assert(is_instance(java_string), "must be java_string");

    77   typeArrayOop value_array = ((typeArrayOop)java_string->obj_field(value_offset));

    78   if (value_array == NULL) {

    79     return 0;

    80   }

    81   int arr_length = value_array->length();

    82   if (!is_latin1(java_string)) {

    83     assert((arr_length & 1) == 0, "should be even for UTF16 string");

    84     arr_length >>= 1; // convert number of bytes to number of elements

    85   }

    86   return arr_length;

    87 }

    88 

    89 bool java_lang_String::is_instance_inlined(oop obj) {

    90   return obj != NULL && obj->klass() == SystemDictionary::String_klass();

    91 }

    92 

    93 // Accessors

    94 oop java_lang_ref_Reference::referent(oop ref) {

    95   return ref->obj_field(referent_offset);

    96 }

    97 void java_lang_ref_Reference::set_referent(oop ref, oop value) {

    98   ref->obj_field_put(referent_offset, value);

    99 }

   100 void java_lang_ref_Reference::set_referent_raw(oop ref, oop value) {

   101   ref->obj_field_put_raw(referent_offset, value);

   102 }

   103 HeapWord* java_lang_ref_Reference::referent_addr(oop ref) {

   104   return ref->obj_field_addr<HeapWord>(referent_offset);

   105 }

   106 oop java_lang_ref_Reference::next(oop ref) {

   107   return ref->obj_field(next_offset);

   108 }

   109 void java_lang_ref_Reference::set_next(oop ref, oop value) {

   110   ref->obj_field_put(next_offset, value);

   111 }

   112 void java_lang_ref_Reference::set_next_raw(oop ref, oop value) {

   113   ref->obj_field_put_raw(next_offset, value);

   114 }

   115 HeapWord* java_lang_ref_Reference::next_addr(oop ref) {

   116   return ref->obj_field_addr<HeapWord>(next_offset);

   117 }

   118 oop java_lang_ref_Reference::discovered(oop ref) {

   119   return ref->obj_field(discovered_offset);

   120 }

   121 void java_lang_ref_Reference::set_discovered(oop ref, oop value) {

   122   ref->obj_field_put(discovered_offset, value);

   123 }

   124 void java_lang_ref_Reference::set_discovered_raw(oop ref, oop value) {

   125   ref->obj_field_put_raw(discovered_offset, value);

   126 }

   127 HeapWord* java_lang_ref_Reference::discovered_addr(oop ref) {

   128   return ref->obj_field_addr<HeapWord>(discovered_offset);

   129 }

   130 

   170 

   171 

   172