rev 50307 : [mq]: cont

   1 /*
   2  * Copyright (c) 2015, 2018, 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/access.inline.hpp"
  30 #include "oops/oop.inline.hpp"
  31 #include "oops/oopsHierarchy.hpp"

  32 
  33 void java_lang_String::set_coder(oop string, jbyte coder) {
  34   assert(initialized && (coder_offset > 0), "Must be initialized");
  35   string->byte_field_put(coder_offset, coder);
  36 }
  37 
  38 void java_lang_String::set_value_raw(oop string, typeArrayOop buffer) {
  39   assert(initialized, "Must be initialized");
  40   string->obj_field_put_raw(value_offset, buffer);
  41 }
  42 void java_lang_String::set_value(oop string, typeArrayOop buffer) {
  43   assert(initialized && (value_offset > 0), "Must be initialized");
  44   string->obj_field_put(value_offset, (oop)buffer);
  45 }
  46 void java_lang_String::set_hash(oop string, unsigned int hash) {
  47   assert(initialized && (hash_offset > 0), "Must be initialized");
  48   string->int_field_put(hash_offset, hash);
  49 }
  50 
  51 // Accessors
  52 typeArrayOop java_lang_String::value(oop java_string) {
  53   assert(initialized && (value_offset > 0), "Must be initialized");
  54   assert(is_instance(java_string), "must be java_string");
  55   return (typeArrayOop) java_string->obj_field(value_offset);
  56 }
  57 typeArrayOop java_lang_String::value_no_keepalive(oop java_string) {
  58   assert(initialized && (value_offset > 0), "Must be initialized");
  59   assert(is_instance(java_string), "must be java_string");
  60   return (typeArrayOop) java_string->obj_field_access<AS_NO_KEEPALIVE>(value_offset);
  61 }
  62 unsigned int java_lang_String::hash(oop java_string) {
  63   assert(initialized && (hash_offset > 0), "Must be initialized");
  64   assert(is_instance(java_string), "must be java_string");
  65   return java_string->int_field(hash_offset);
  66 }
  67 bool java_lang_String::is_latin1(oop java_string) {
  68   assert(initialized && (coder_offset > 0), "Must be initialized");
  69   assert(is_instance(java_string), "must be java_string");
  70   jbyte coder = java_string->byte_field(coder_offset);
  71   assert(CompactStrings || coder == CODER_UTF16, "Must be UTF16 without CompactStrings");
  72   return coder == CODER_LATIN1;
  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 = java_lang_String::value_no_keepalive(java_string);
  78   if (value == NULL) {
  79     return 0;
  80   }
  81   int arr_length = value->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_raw(oop ref) {
 104   return ref->obj_field_addr_raw<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_raw(oop ref) {
 116   return ref->obj_field_addr_raw<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_raw(oop ref) {
 128   return ref->obj_field_addr_raw<HeapWord>(discovered_offset);
 129 }
 130 bool java_lang_ref_Reference::is_phantom(oop ref) {
 131   return InstanceKlass::cast(ref->klass())->reference_type() == REF_PHANTOM;
 132 }
 133 





























































































 134 inline void java_lang_invoke_CallSite::set_target_volatile(oop site, oop target) {
 135   site->obj_field_put_volatile(_target_offset, target);
 136 }
 137 
 138 inline oop  java_lang_invoke_CallSite::target(oop site) {
 139   return site->obj_field(_target_offset);
 140 }
 141 
 142 inline void java_lang_invoke_CallSite::set_target(oop site, oop target) {
 143   site->obj_field_put(_target_offset, target);
 144 }
 145 
 146 inline bool java_lang_invoke_CallSite::is_instance(oop obj) {
 147   return obj != NULL && is_subclass(obj->klass());
 148 }
 149 
 150 inline bool java_lang_invoke_MethodHandleNatives_CallSiteContext::is_instance(oop obj) {
 151   return obj != NULL && is_subclass(obj->klass());
 152 }
 153 
 154 inline bool java_lang_invoke_MemberName::is_instance(oop obj) {
 155   return obj != NULL && obj->klass() == SystemDictionary::MemberName_klass();
 156 }
 157 
 158 inline bool java_lang_invoke_ResolvedMethodName::is_instance(oop obj) {
 159   return obj != NULL && obj->klass() == SystemDictionary::ResolvedMethodName_klass();
 160 }
 161 
 162 inline bool java_lang_invoke_MethodType::is_instance(oop obj) {
 163   return obj != NULL && obj->klass() == SystemDictionary::MethodType_klass();
 164 }
 165 
 166 inline bool java_lang_invoke_MethodHandle::is_instance(oop obj) {
 167   return obj != NULL && is_subclass(obj->klass());
 168 }
 169 
 170 inline bool java_lang_Class::is_instance(oop obj) {
 171   return obj != NULL && obj->klass() == SystemDictionary::Class_klass();
 172 }
 173 
 174 inline bool java_lang_invoke_DirectMethodHandle::is_instance(oop obj) {
 175   return obj != NULL && is_subclass(obj->klass());
 176 }
 177 
 178 inline bool java_lang_Module::is_instance(oop obj) {
 179   return obj != NULL && obj->klass() == SystemDictionary::Module_klass();
 180 }
 181 
 182 inline int Backtrace::merge_bci_and_version(int bci, int version) {
 183   // only store u2 for version, checking for overflow.
 184   if (version > USHRT_MAX || version < 0) version = USHRT_MAX;
 185   assert((jushort)bci == bci, "bci should be short");
 186   return build_int_from_shorts(version, bci);
 187 }
 188 
 189 inline int Backtrace::merge_mid_and_cpref(int mid, int cpref) {
 190   // only store u2 for mid and cpref, checking for overflow.
 191   assert((jushort)mid == mid, "mid should be short");
 192   assert((jushort)cpref == cpref, "cpref should be short");
 193   return build_int_from_shorts(cpref, mid);
 194 }
 195 
 196 inline int Backtrace::bci_at(unsigned int merged) {
 197   return extract_high_short_from_int(merged);
 198 }
 199 
 200 inline int Backtrace::version_at(unsigned int merged) {
 201   return extract_low_short_from_int(merged);
 202 }
 203 
 204 inline int Backtrace::mid_at(unsigned int merged) {
 205   return extract_high_short_from_int(merged);
 206 }
 207 
 208 inline int Backtrace::cpref_at(unsigned int merged) {
 209   return extract_low_short_from_int(merged);
 210 }
 211 
 212 inline int Backtrace::get_line_number(const methodHandle& method, int bci) {
 213   int line_number = 0;
 214   if (method->is_native()) {
 215     // Negative value different from -1 below, enabling Java code in
 216     // class java.lang.StackTraceElement to distinguish "native" from
 217     // "no LineNumberTable".  JDK tests for -2.
 218     line_number = -2;
 219   } else {
 220     // Returns -1 if no LineNumberTable, and otherwise actual line number
 221     line_number = method->line_number_from_bci(bci);
 222     if (line_number == -1 && ShowHiddenFrames) {
 223       line_number = bci + 1000000;
 224     }
 225   }
 226   return line_number;
 227 }
 228 
 229 inline Symbol* Backtrace::get_source_file_name(InstanceKlass* holder, int version) {
 230   // RedefineClasses() currently permits redefine operations to
 231   // happen in parallel using a "last one wins" philosophy. That
 232   // spec laxness allows the constant pool entry associated with
 233   // the source_file_name_index for any older constant pool version
 234   // to be unstable so we shouldn't try to use it.
 235   if (holder->constants()->version() != version) {
 236     return NULL;
 237   } else {
 238     return holder->source_file_name();
 239   }
 240 }
 241 
 242 #endif // SHARE_VM_CLASSFILE_JAVACLASSES_INLINE_HPP
--- EOF ---