1 /*

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

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.

     8  *

     9  * This code is distributed in the hope that it will be useful, but WITHOUT

    10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    12  * version 2 for more details (a copy is included in the LICENSE file that

    13  * accompanied this code).

    14  *

    15  * You should have received a copy of the GNU General Public License version

    16  * 2 along with this work; if not, write to the Free Software Foundation,

    17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    18  *

    19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    20  * or visit www.oracle.com if you need additional information or have any

    21  * questions.

    22  *

    23  */

    24 

    25 #ifndef SHARE_VM_CLASSFILE_JAVACLASSES_INLINE_HPP

    26 #define SHARE_VM_CLASSFILE_JAVACLASSES_INLINE_HPP

    27 

    28 #include "classfile/javaClasses.hpp"

    29 #include "oops/oop.inline.hpp"

    30 #include "oops/oopsHierarchy.hpp"

    31 

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

    33   assert(initialized && (coder_offset > 0), "Must be initialized");

    34   string->byte_field_put(coder_offset, coder);

    35 }

    36 

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

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

    39   string->obj_field_put_raw(value_offset, buffer);

    40 }

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

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

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

    44 }

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

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

    47   string->int_field_put(hash_offset, hash);

    48 }

    49 

    50 // Accessors

    51 typeArrayOop java_lang_String::value(oop java_string) {

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

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

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

    55 }

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

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

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

    59   return java_string->int_field(hash_offset);

    60 }

    61 bool java_lang_String::is_latin1(oop java_string) {

    62   assert(initialized && (coder_offset > 0), "Must be initialized");

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

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

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

    66   return coder == CODER_LATIN1;

    67 }

    68 int java_lang_String::length(oop java_string) {

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

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

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

    72   if (value_array == NULL) {

    73     return 0;

    74   }

    75   int arr_length = value_array->length();

    76   if (!is_latin1(java_string)) {

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

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

    79   }

    80   return arr_length;

    81 }

    82 

    83 bool java_lang_String::is_instance_inlined(oop obj) {

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

    85 }

    86 

    87 // Accessors

    88 oop java_lang_ref_Reference::referent(oop ref) {

    89   return ref->obj_field(referent_offset);

    90 }

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

    92   ref->obj_field_put(referent_offset, value);

    93 }

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

    95   ref->obj_field_put_raw(referent_offset, value);

    96 }

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

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

    99 }

   100 oop java_lang_ref_Reference::next(oop ref) {

   101   return ref->obj_field(next_offset);

   102 }

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

   104   ref->obj_field_put(next_offset, value);

   105 }

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

   107   ref->obj_field_put_raw(next_offset, value);

   108 }

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

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

   111 }

   112 oop java_lang_ref_Reference::discovered(oop ref) {

   113   return ref->obj_field(discovered_offset);

   114 }

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

   116   ref->obj_field_put(discovered_offset, value);

   117 }

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

   119   ref->obj_field_put_raw(discovered_offset, value);

   120 }

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

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

   123 }

   124 

   125 inline void java_lang_invoke_CallSite::set_target_volatile(oop site, oop target) {

   126   site->obj_field_put_volatile(_target_offset, target);

   127 }

   128 

   129 inline oop  java_lang_invoke_CallSite::target(oop site) {

   130   return site->obj_field(_target_offset);

   131 }

   132 

   133 inline void java_lang_invoke_CallSite::set_target(oop site, oop target) {

   134   site->obj_field_put(_target_offset, target);

   135 }

   136 

   137 inline bool java_lang_invoke_CallSite::is_instance(oop obj) {

   138   return obj != NULL && is_subclass(obj->klass());

   139 }

   140 

   141 inline bool java_lang_invoke_MethodHandleNatives_CallSiteContext::is_instance(oop obj) {

   142   return obj != NULL && is_subclass(obj->klass());

   143 }

   144 

   145 inline bool java_lang_invoke_MemberName::is_instance(oop obj) {

   146   return obj != NULL && obj->klass() == SystemDictionary::MemberName_klass();

   147 }

   148 

   149 inline bool java_lang_invoke_ResolvedMethodName::is_instance(oop obj) {

   150   return obj != NULL && obj->klass() == SystemDictionary::ResolvedMethodName_klass();

   151 }

   152 

   153 inline bool java_lang_invoke_MethodType::is_instance(oop obj) {

   154   return obj != NULL && obj->klass() == SystemDictionary::MethodType_klass();

   155 }

   156 

   157 inline bool java_lang_invoke_MethodHandle::is_instance(oop obj) {

   158   return obj != NULL && is_subclass(obj->klass());

   159 }

   160 

   161 inline bool java_lang_Class::is_instance(oop obj) {

   162   return obj != NULL && obj->klass() == SystemDictionary::Class_klass();

   163 }

   164 

   165 inline bool java_lang_invoke_DirectMethodHandle::is_instance(oop obj) {

   166   return obj != NULL && is_subclass(obj->klass());

   167 }

   168 

   169 inline bool java_lang_Module::is_instance(oop obj) {

   170   return obj != NULL && obj->klass() == SystemDictionary::Module_klass();

   171 }

   172 

   173 inline int Backtrace::merge_bci_and_version(int bci, int version) {

   174   // only store u2 for version, checking for overflow.

   175   if (version > USHRT_MAX || version < 0) version = USHRT_MAX;

   176   assert((jushort)bci == bci, "bci should be short");

   177   return build_int_from_shorts(version, bci);

   178 }

   179 

   180 inline int Backtrace::merge_mid_and_cpref(int mid, int cpref) {

   181   // only store u2 for mid and cpref, checking for overflow.

   182   assert((jushort)mid == mid, "mid should be short");

   183   assert((jushort)cpref == cpref, "cpref should be short");

   184   return build_int_from_shorts(cpref, mid);

   185 }

   186 

   187 inline int Backtrace::bci_at(unsigned int merged) {

   188   return extract_high_short_from_int(merged);

   189 }

   190 

   191 inline int Backtrace::version_at(unsigned int merged) {

   192   return extract_low_short_from_int(merged);

   193 }

   194 

   195 inline int Backtrace::mid_at(unsigned int merged) {

   196   return extract_high_short_from_int(merged);

   197 }

   198 

   199 inline int Backtrace::cpref_at(unsigned int merged) {

   200   return extract_low_short_from_int(merged);

   201 }

   202 

   203 inline int Backtrace::get_line_number(const methodHandle& method, int bci) {

   204   int line_number = 0;

   205   if (method->is_native()) {

   206     // Negative value different from -1 below, enabling Java code in

   207     // class java.lang.StackTraceElement to distinguish "native" from

   208     // "no LineNumberTable".  JDK tests for -2.

   209     line_number = -2;

   210   } else {

   211     // Returns -1 if no LineNumberTable, and otherwise actual line number

   212     line_number = method->line_number_from_bci(bci);

   213     if (line_number == -1 && ShowHiddenFrames) {

   214       line_number = bci + 1000000;

   215     }

   216   }

   217   return line_number;

   218 }

   219 

   220 inline Symbol* Backtrace::get_source_file_name(InstanceKlass* holder, int version) {

   221   // RedefineClasses() currently permits redefine operations to

   222   // happen in parallel using a "last one wins" philosophy. That

   223   // spec laxness allows the constant pool entry associated with

   224   // the source_file_name_index for any older constant pool version

   225   // to be unstable so we shouldn't try to use it.

   226   if (holder->constants()->version() != version) {

   227     return NULL;

   228   } else {

   229     return holder->source_file_name();

   230   }

   231 }

   232 

   233 #endif // SHARE_VM_CLASSFILE_JAVACLASSES_INLINE_HPP