2  * Copyright (c) 1997, 2015, Oracle and/or its affiliates. All rights reserved.

     2  * Copyright (c) 1997, 2016, Oracle and/or its affiliates. All rights reserved.

    63   static void set_coder(oop string, jbyte coder) {

    63   static inline void set_coder(oop string, jbyte coder);

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

    65     if (coder_offset > 0) {

    66       string->byte_field_put(coder_offset, coder);

    67     }

    68   }

   113   static void set_value_raw(oop string, typeArrayOop buffer) {

   108   static inline void set_value_raw(oop string, typeArrayOop buffer);

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

   109   static inline void set_value(oop string, typeArrayOop buffer);

   115     string->obj_field_put_raw(value_offset, buffer);

   110   static inline void set_hash(oop string, unsigned int hash);

   116   }

   111 

   117   static void set_value(oop string, typeArrayOop buffer) {

   112   // Accessors

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

   113   static inline typeArrayOop value(oop java_string);

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

   114   static inline unsigned int hash(oop java_string);

   120   }

   115   static inline bool is_latin1(oop java_string);

   121   static void set_hash(oop string, unsigned int hash) {

   116   static inline int length(oop java_string);

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

   123     string->int_field_put(hash_offset, hash);

   124   }

   125 

   126   // Accessors

   127   static typeArrayOop value(oop java_string) {

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

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

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

   131   }

   132   static unsigned int hash(oop java_string) {

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

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

   135     return java_string->int_field(hash_offset);

   136   }

   137   static bool is_latin1(oop java_string) {

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

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

   140     if (coder_offset > 0) {

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

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

   143       return coder == CODER_LATIN1;

   144     } else {

   145       return false;

   146     }

   147   }

   148   static int length(oop java_string) {

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

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

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

   152     if (value_array == NULL) {

   153      return 0;

   154     }

   155     int arr_length = value_array->length();

   156     if (!is_latin1(java_string)) {

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

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

   159     }

   160     return arr_length;

   161   }

   222   static bool is_instance_inlined(oop obj);

   177   static inline bool is_instance_inlined(oop obj);

   913   static oop referent(oop ref) {

   868   static inline oop referent(oop ref);

   914     return ref->obj_field(referent_offset);

   869   static inline void set_referent(oop ref, oop value);

   915   }

   870   static inline void set_referent_raw(oop ref, oop value);

   916   static void set_referent(oop ref, oop value) {

   871   static inline HeapWord* referent_addr(oop ref);

   917     ref->obj_field_put(referent_offset, value);

   872   static inline oop next(oop ref);

   918   }

   873   static inline void set_next(oop ref, oop value);

   919   static void set_referent_raw(oop ref, oop value) {

   874   static inline void set_next_raw(oop ref, oop value);

   920     ref->obj_field_put_raw(referent_offset, value);

   875   static inline HeapWord* next_addr(oop ref);

   921   }

   876   static inline oop discovered(oop ref);

   922   static HeapWord* referent_addr(oop ref) {

   877   static inline void set_discovered(oop ref, oop value);

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

   878   static inline void set_discovered_raw(oop ref, oop value);

   924   }

   879   static inline HeapWord* discovered_addr(oop ref);

   925   static oop next(oop ref) {

   880 

   926     return ref->obj_field(next_offset);

   927   }

   928   static void set_next(oop ref, oop value) {

   929     ref->obj_field_put(next_offset, value);

   930   }

   931   static void set_next_raw(oop ref, oop value) {

   932     ref->obj_field_put_raw(next_offset, value);

   933   }

   934   static HeapWord* next_addr(oop ref) {

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

   936   }

   937   static oop discovered(oop ref) {

   938     return ref->obj_field(discovered_offset);

   939   }

   940   static void set_discovered(oop ref, oop value) {

   941     ref->obj_field_put(discovered_offset, value);

   942   }

   943   static void set_discovered_raw(oop ref, oop value) {

   944     ref->obj_field_put_raw(discovered_offset, value);

   945   }

   946   static HeapWord* discovered_addr(oop ref) {

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

   948   }