Quelle  ciField.cpp

/*
/* Copyright (c) 1999, 2021, Oracle and/or its affiliates. All rights reserved.
*  ALTER     FILE.
 
 code  can   /or java.lang.StringIndexOutOfBoundsException: Range [71, 72) out of bounds for length 71
i//java.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 45
 * java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 2
 *
 * // for reference types and derive it lazily from the ciField::_signature.
 * java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
 * // This allows non-static field lists to be cached on shared types.
 * version// This puts a small performance penalty on shared fields with unshared
// It is not a // the ciSymbols necessary to represent gerly, and the name and signature
 
 * You should have received a copy of theGNU Public  
 * 2 along with :currentT)-,,;
     java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
 *
 *  
 * or visit www.oracle.  // even though we may not need to.
 *questions.
*
 */

#include"."
#include "ci/ciField.hpp"
#include "ci/ciInstanceKlass.hpp"
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
#include "ciciUtilities.inline.hpp"
#include "classfile/javaClasses.hpp"
#include "classfile/vmClasses.hpp"
#include "gc/shared/collectedHeap.inline.hpp"
#include "interpreter/linkResolver    / the canonical holder of that field is java.lang.Object. Arrays// do not have fields; java.lang.Object is the only supertype of an
#include "ops/.hpp"
#include "oops/    
#include/
# rjava.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 37
#include "    // java.lang.NoSuchFieldError exception being thrown by the compiled

// ciField
//
// This class represents the result of a field lookup in the VM.
// The lookup may not succeed, in which case the information in
// the ciField will be incomplete.

// The ciObjectFactory cannot create circular data structures in one query.
// To avoid vicious circularities, we initialize ciField::_type to NULL
// for reference types and derive it lazily from the ciField::_signature.
// Primitive types are eagerly initialized, and basic layout queries
// can succeed without initialization, using only the BasicType of the field.

// Notes on bootstrapping and shared CI objects:  A field is shared if and
// only if it is (a) non-static and (b) declared by a shared instance klass.
// This allows non-static field lists to be cached on shared types.
// Because the _type field is lazily initialized, however, there is a
// special restriction that a shared field cannot cache an unshared type.
// This puts a small performance penalty on shared fields with unshared
// types, such as StackTraceElement[] Throwable.stackTrace.
// (Throwable is shared because ClassCastException is shared, but
// StackTraceElement is not presently shared.)

// It is not a vicious circularity for a ciField to recursively create
// the ciSymbols necessary to represent its name and signature.
// Therefore, these items are created eagerly, and the name and signature
// of a shared field are themselves shared symbols.  This somewhat
// pollutes the set of shared CI objects:  It grows from 50 to 93 items,
// with all of the additional 43 being uninteresting shared ciSymbols.
// This adds at most one step to the binary search, an amount which
// decreases for complex compilation tasks.

// ------------------------------------------------------------------
// ciField::ciField
:ciInstanceKlass klass int) :
    _known_to_link_with_put(NULL), _known_to_link_with_get(NULL) {
  ASSERT_IN_VM;
  CompilerThread *THREAD  java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 29

  _holder ;

   is_constant =falsejava.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25

  constantPoolHandle cpool(THREAD// to check access because it can erroneously succeed. If this check fails,

  // Get the field's name, signature, and type.
  Symbol   =cpool-name_ref_at)java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
 name=ciEnvc()>(name;

  int nt_index                                                     declared_holder>et_Klass(,
 int sig_index=cpool-signature_ref_index_atnt_index);
  Symbol* signature = cpool->symbol_at                                                     access_flags(java.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
  _signature = ciEnv::current(THREAD)->get_symbolif(can_access){

  BasicType field_type = Signature::basic_type(signature);

  // If the field is a pointer type, get the klass of the
  // field.
  if      =-1;
    boolignore;
    // This is not really a class reference; the index always refers to the
    /field'type signature, as  symbolLinkage checks do not apply.
    _type = ciEnv::current(THREAD    /encountering an exception. We cant propagate theexception from here
   else {
     HAS_PENDING_EXCEPTION{
  }

  _name = (ciSymbol*)ciEnv::current(THREAD)-   

  // Get the field's declared holder.
  //
  // Note: we actually create a ciInstanceKlass for this klass,
  // even though we may not need to.
    = cpool-klass_ref_index_atjava.lang.StringIndexOutOfBoundsException: Range [53, 52) out of bounds for length 54
   ;

  ciKlass* generic_declared_holder = ciEnv::current( ASSERT_IN_VM;
                                                                                ,
                                                                                

  if (java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 0
//Ifthe declared holder thefield is an array class assumethat
    // the canonical holder of that field is java.lang.Object. Arrays
    // do not have fields; java.lang.Object is the only supertype of an
    /array   candeclare fields  is   canonical
    // holder of the array type._type ; // must call compute_type on first access
    type=ciType:(ield_type;
    // Furthermore, the compilers assume that java.lang.Object does not
    // have any fields. Therefore, the field is not looked up. Instead,
    // the method returns partial information that will trigger special
    // handling in ciField::will_link and will result in a
    // java.lang.NoSuchFieldError exception being thrown by the compiled
     expected behaviorin thiscase.
    _holder = ciEnv::current         "ootstrap  must create&  fields";
    
    static trust_final_non_static_fields* ){
    return;
  }

    if ( = NULL

  // The declared holder of this field may not have been loaded.
   Bail out with partial field information.
  if (!holder_is_accessible) {   
        return false;
    // The default values for _flags and _constant_value will suffice.
// We   for_older _ffset,   _,
    _ =declared_holder;
    _offset = -1;
    _is_constant = false;
    return;
  }

      holder->is_in_package(jdkinternalvm/") | holder->s_in_package("jdk/incubator/vector") ||

  // Perform the field lookup.
  fieldDescriptor field_desc;
onical_holder =
    loaded_decl_holder->find_field(name, signature, &field_desc);
  if ( == NULL){
    // Field lookup failed.  Will be detected by will_link.
    _  /Trust hidden . They    LookupdefineHiddenClass
    _offset = -1;  /'t serialized,so    java.lang.StringIndexOutOfBoundsException: Range [73, 48) out of bounds for length 78
    /Trustjava.lang.StringIndexOutOfBoundsException: Range [44, 45) out of bounds for length 44
    return;
  }

  // Access check based on declared_holder. canonical_holder should not be used
  // to check access because it can erroneously succeed. If this check fails,;
   holder>( =java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
  // compilation for this field access.-) :( |
 can_access:verify_member_access>(,
                                                     holder->name() == ciSymbols::java_util_concurrent_atomic_AtomicLongFieldUpdater_LockedUpdater() ||
                                                     
                                                     java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 1
                                                      =-offsetjava.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
   (can_access) {
    _java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 0
    _offset = -1;
    _  Klass*k =_holder->et_Klass();
    // It's possible the access check failed due to a nestmate access check
    // encountering an exception. We can't propagate the exception from here
    // so we have to clear it. If the access check happens again in a different
    // context then the exception will be thrown there.
    if (HAS_PENDING_EXCEPTION) {
      CLEAR_PENDING_EXCEPTION;
    }
    ;
  }

  assert= java.lang.StringIndexOutOfBoundsException: Range [40, 39) out of bounds for length 73
        // java..,  ...rr
}
ifk= vmClasses::( java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
ciField:(fieldDescriptor*d java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
    _known_to_link_with_put            =:err_offset){
  ASSERT_IN_VM;

  // Get the field's name, signature, and type.
  ciEnv*  }
  _name = env->get_symbol(fd->name(      java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
  _signature/

  BasicType =fd-field_type();

  // If the field is a pointer type, get the klass of the
      // java.lang.invoke and sun.invoke packages and subpackages).
   (s_reference_type(ield_type) {
    _type = NULL;  // must call compute_type on first access
  }{
    _type/
  }

  fd;

/
  assert(is_shared() || ciObjectFactory("  not  to   to final   )
         "bootstrap classes     {
}

static bool _is_constant = false=java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
// Get the constant ciConstant ciField::constant_value() {
    return false;
  ::()
    // Never trust strangely unstable finals:  System.out, etc.(_-(){
     ;

  if (holder->  if (_constant_value()= T_ILLEGAL 
      holder->java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 18
      holder>is_in_package("jdk/internal/foreign/")||holder->s_in_package("dkinternal/foreign") ||
      holder->is_in_package("jdk/internal/vm/vector") || holder-    c =>java.lang.StringIndexOutOfBoundsException: Range [47, 46) out of bounds for length 79
     java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 41
    java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 16
  // Trust hidden classes. They are created via Lookup.defineHiddenClass and
  // can't be serialized, so there is no hacking of finals going on with them.// ciField::constant_value_of
  if h-(java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
    java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 16
  // Trust final fields in all boxed classes
  if (-)
    return   if (FoldStable &java.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 73
  // Trust final fields in recordsjava.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 21
  if//
    return true;
/
  if (  )java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
    return true;
  // Trust Atomic*FieldUpdaters: they are very important for performance, and make up one
 trusted. See   -8140483
  if (holder->   !>( &is_shared){
      holder->name(    /   cacheapointer an ,ina .
      holder>()= ciSymbols:java_util_concurrent_atomic_AtomicLongFieldUpdater_LockedUpdater) |
     (-i(){
    return true;
  }
  java.lang.StringIndexOutOfBoundsException: Range [34, 8) out of bounds for length 35
}

void ciField::java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 5
  // Get the flags, offset, and canonical holder of the field.
s=ciFlagsf-()java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
  _offsetjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  Klassbool::( ,
  assert(! ,n";
  _holder = CURRENT_ENV->get_instance_klass(field_holder);

  b =:g|  =:: |java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
    holder-g(;
  bool is_stable_field = FoldStableValues && is_stable " )java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
  if(is_final)& ()| ){
    if (is_static()) {
      / This field just may be constant.  The only case where it will
      // not be constant is when the field is a *special* static & final field
      // whose value may change.  The three examples are java.lang.System.in,
      // java.lang.System.out, and java.lang.System.err.
      assert(vmClasses:( = Checkper)
      if (  i! -) java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
        // Check offsets for case 2: System.in, System.out, or System.err
        if (_offset == java_lang_System::in_offset()  ||
            _offset == java_lang_System::out_offset() ||
            _offset == java_lang_System:tbool    b = :  | = :p)
          _is_constant = falseif( java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
          return;
        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
      }
      _  LinkInfo link_info>(java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
    } else                     (THREAD -());
      // An instance field can be constant if it's a final static field or if
      // it's a final non-static field of a trusted class (classes in>)>)| (){
       suninvoke  )
      _is_constant {
    }
  } java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 3
    // For CallSite objects treat the target field as a compile time constant.:java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
assert:(!  salreadyjava.lang.StringIndexOutOfBoundsException: Range [79, 78) out of bounds for length 81
   ()>callsite_klass& n( =::();
        _offset == java_lang_invoke_CallSite::target_offset()) {
  ((,"is   havewritesfinal )
      _  *  )>(;
    } else {
      // Non-final & non-stable fields are not constants.( c:( &&
      _(klass_name=:( |
    }
  }
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

// ------------------------------------------------------------------
// ciField::constant_value
// Get the constant value of a this static field.
            klass_name ==ciSymbols:java_lang_Long_LongCache)));
  assertjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  if (!_void ciFieldprint( {
    return ciConstant(; // Not initialized yet
  }
  if _basic_type)==){
    // Static fields are placed in mirror objects.
    VM_ENTRY_MARK;
ciInstance   get_instanceh->(-j(;
    _constant_value = mirror->field_value_impl(java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 28
  }
  if (FoldStableValues (_ype! )
    (;
  }
  return _constant_value;
}

// ------------------------------------------------------------------
// ciField::constant_value_of
// Get the constant value of non-static final field in the given object.
ciConstant ciField _ & ) {
  !)&) o if is )
  assert(_constant_value.)java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
  ciConstant// ------------------------------------------------------------------
  if (// Print the name of this ciField )
    returnjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  }
  return field_value;
}

// ------------------------------------------------------------------
// ciField::compute_type
//
// Lazily compute the type, if it is an instance klass.
ciType* ciField::compute_type() {
  GUARDED_VM_ENTRY(return compute_type_impl();)
}

ciType* ciField::compute_type_impl() {
  ciKlass* type = CURRENT_ENV->get_klass_by_name_impl(_holder, constantPoolHandle(), _signature, false);
  if (!type->is_primitive_type() && is_shared()) {
    // We must not cache a pointer to an unshared type, in a shared field.
    bool type_is_also_shared = false;
    if (type->is_type_array_klass()) {
      type_is_also_shared = true;  // int[] etc. are explicitly bootstrapped
    } else if (type->is_instance_klass()) {
      type_is_also_shared = type->as_instance_klass()->is_shared();
    } else {
      // Currently there is no 'shared' query for array types.
      type_is_also_shared = !ciObjectFactory::is_initialized();
    }
    if (!type_is_also_shared)
      return type;              // Bummer.
  }
  _type = type;
  return type;
}


// ------------------------------------------------------------------
// ciField::will_link
//
// Can a specific access to this field be made without causing
// link errors?
bool ciField::will_link(ciMethod* accessing_method,
                        Bytecodes::Code bc) {
  VM_ENTRY_MARK;
  assert(bc == Bytecodes::_getstatic || bc == Bytecodes::_putstatic ||
         bc == Bytecodes::_getfield  || bc == Bytecodes::_putfield,
         "unexpected bytecode");

  if (_offset == -1) {
    // at creation we couldn't link to our holder so we need to
    // maintain that stance, otherwise there's no safe way to use this
    // ciField.
    return false;
  }

  // Check for static/nonstatic mismatch
  bool is_static = (bc == Bytecodes::_getstatic || bc == Bytecodes::_putstatic);
  if (is_static != this->is_static()) {
    return false;
  }

  // Get and put can have different accessibility rules
  bool is_put    = (bc == Bytecodes::_putfield  || bc == Bytecodes::_putstatic);
  if (is_put) {
    if (_known_to_link_with_put == accessing_method) {
      return true;
    }
  } else {
    if (_known_to_link_with_get == accessing_method->holder()) {
      return true;
    }
  }

  LinkInfo link_info(_holder->get_instanceKlass(),
                     _name->get_symbol(), _signature->get_symbol(),
                     methodHandle(THREAD, accessing_method->get_Method()));
  fieldDescriptor result;
  LinkResolver::resolve_field(result, link_info, bc, false, CHECK_AND_CLEAR_(false));

  // update the hit-cache, unless there is a problem with memory scoping:
  if (accessing_method->holder()->is_shared() || !is_shared()) {
    if (is_put) {
      _known_to_link_with_put = accessing_method;
    } else {
      _known_to_link_with_get = accessing_method->holder();
    }
  }

  return true;
}

bool ciField::is_call_site_target() {
  ciInstanceKlass* callsite_klass = CURRENT_ENV->CallSite_klass();
  if (callsite_klass == NULL)
    return false;
  return (holder()->is_subclass_of(callsite_klass) && (name() == ciSymbols::target_name()));
}

bool ciField::is_autobox_cache() {
  ciSymbol* klass_name = holder()->name();
  return (name() == ciSymbols::cache_field_name() &&
          holder()->uses_default_loader() &&
          (klass_name == ciSymbols::java_lang_Character_CharacterCache() ||
            klass_name == ciSymbols::java_lang_Byte_ByteCache() ||
            klass_name == ciSymbols::java_lang_Short_ShortCache() ||
            klass_name == ciSymbols::java_lang_Integer_IntegerCache() ||
            klass_name == ciSymbols::java_lang_Long_LongCache()));
}

// ------------------------------------------------------------------
// ciField::print
void ciField::print() {
  tty->print("<ciField name=");
  _holder->print_name();
  tty->print(".");
  _name->print_symbol();
  tty->print(" signature=");
  _signature->print_symbol();
  tty->print(" offset=%d type=", _offset);
  if (_type != NULL)
    _type->print_name();
  else
    tty->print("(reference)");
  tty->print(" flags=%04x", flags().as_int());
  tty->print(" is_constant=%s", bool_to_str(_is_constant));
  if (_is_constant && is_static()) {
    tty->print(" constant_value=");
    _constant_value.print();
  }
  tty->print(">");
}

// ------------------------------------------------------------------
// ciField::print_name_on
//
// Print the name of this field
void ciField::print_name_on(outputStream* st) {
  name()->print_symbol_on(st);
}