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