src/share/vm/ci/ciField.cpp
Index Unified diffs Context diffs Sdiffs Patch New Old Previous File Next File 8014013 Sdiff src/share/vm/ci

src/share/vm/ci/ciField.cpp

Print this page


   1 /*
   2  * Copyright (c) 1999, 2012, 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  *


  58 
  59 // It is not a vicious circularity for a ciField to recursively create
  60 // the ciSymbols necessary to represent its name and signature.
  61 // Therefore, these items are created eagerly, and the name and signature
  62 // of a shared field are themselves shared symbols.  This somewhat
  63 // pollutes the set of shared CI objects:  It grows from 50 to 93 items,
  64 // with all of the additional 43 being uninteresting shared ciSymbols.
  65 // This adds at most one step to the binary search, an amount which
  66 // decreases for complex compilation tasks.
  67 
  68 // ------------------------------------------------------------------
  69 // ciField::ciField
  70 ciField::ciField(ciInstanceKlass* klass, int index): _known_to_link_with_put(NULL), _known_to_link_with_get(NULL) {
  71   ASSERT_IN_VM;
  72   CompilerThread *thread = CompilerThread::current();
  73 
  74   assert(ciObjectFactory::is_initialized(), "not a shared field");
  75 
  76   assert(klass->get_instanceKlass()->is_linked(), "must be linked before using its constan-pool");
  77 
  78   _cp_index = index;
  79   constantPoolHandle cpool(thread, klass->get_instanceKlass()->constants());
  80 
  81   // Get the field's name, signature, and type.
  82   Symbol* name  = cpool->name_ref_at(index);
  83   _name = ciEnv::current(thread)->get_symbol(name);
  84 
  85   int nt_index = cpool->name_and_type_ref_index_at(index);
  86   int sig_index = cpool->signature_ref_index_at(nt_index);
  87   Symbol* signature = cpool->symbol_at(sig_index);
  88   _signature = ciEnv::current(thread)->get_symbol(signature);
  89 
  90   BasicType field_type = FieldType::basic_type(signature);
  91 
  92   // If the field is a pointer type, get the klass of the
  93   // field.
  94   if (field_type == T_OBJECT || field_type == T_ARRAY) {
  95     bool ignore;
  96     // This is not really a class reference; the index always refers to the
  97     // field's type signature, as a symbol.  Linkage checks do not apply.
  98     _type = ciEnv::current(thread)->get_klass_by_index(cpool, sig_index, ignore, klass);
  99   } else {
 100     _type = ciType::make(field_type);
 101   }
 102 
 103   _name = (ciSymbol*)ciEnv::current(thread)->get_symbol(name);
 104 
 105   // Get the field's declared holder.
 106   //
 107   // Note: we actually create a ciInstanceKlass for this klass,
 108   // even though we may not need to.
 109   int holder_index = cpool->klass_ref_index_at(index);
 110   bool holder_is_accessible;
 111   ciInstanceKlass* declared_holder =
 112     ciEnv::current(thread)->get_klass_by_index(cpool, holder_index,
 113                                                holder_is_accessible,
 114                                                klass)->as_instance_klass();
 115 
 116   // The declared holder of this field may not have been loaded.
 117   // Bail out with partial field information.
 118   if (!holder_is_accessible) {
 119     // _cp_index and _type have already been set.
 120     // The default values for _flags and _constant_value will suffice.
 121     // We need values for _holder, _offset,  and _is_constant,
 122     _holder = declared_holder;
 123     _offset = -1;
 124     _is_constant = false;
 125     return;
 126   }
 127 
 128   InstanceKlass* loaded_decl_holder = declared_holder->get_instanceKlass();
 129 
 130   // Perform the field lookup.
 131   fieldDescriptor field_desc;
 132   Klass* canonical_holder =
 133     loaded_decl_holder->find_field(name, signature, &field_desc);
 134   if (canonical_holder == NULL) {
 135     // Field lookup failed.  Will be detected by will_link.
 136     _holder = declared_holder;
 137     _offset = -1;
 138     _is_constant = false;
 139     return;
 140   }
 141 
 142   assert(canonical_holder == field_desc.field_holder(), "just checking");
 143   initialize_from(&field_desc);
 144 }
 145 
 146 ciField::ciField(fieldDescriptor *fd): _known_to_link_with_put(NULL), _known_to_link_with_get(NULL) {
 147   ASSERT_IN_VM;
 148 
 149   _cp_index = -1;
 150 
 151   // Get the field's name, signature, and type.
 152   ciEnv* env = CURRENT_ENV;
 153   _name = env->get_symbol(fd->name());
 154   _signature = env->get_symbol(fd->signature());
 155 
 156   BasicType field_type = fd->field_type();
 157 
 158   // If the field is a pointer type, get the klass of the
 159   // field.
 160   if (field_type == T_OBJECT || field_type == T_ARRAY) {
 161     _type = NULL;  // must call compute_type on first access
 162   } else {
 163     _type = ciType::make(field_type);
 164   }
 165 
 166   initialize_from(fd);
 167 
 168   // Either (a) it is marked shared, or else (b) we are done bootstrapping.
 169   assert(is_shared() || ciObjectFactory::is_initialized(),
 170          "bootstrap classes must not create & cache unshared fields");


 327   }
 328 
 329   // Check for static/nonstatic mismatch
 330   bool is_static = (bc == Bytecodes::_getstatic || bc == Bytecodes::_putstatic);
 331   if (is_static != this->is_static()) {
 332     return false;
 333   }
 334 
 335   // Get and put can have different accessibility rules
 336   bool is_put    = (bc == Bytecodes::_putfield  || bc == Bytecodes::_putstatic);
 337   if (is_put) {
 338     if (_known_to_link_with_put == accessing_klass) {
 339       return true;
 340     }
 341   } else {
 342     if (_known_to_link_with_get == accessing_klass) {
 343       return true;
 344     }
 345   }
 346 
 347   FieldAccessInfo result;
 348   constantPoolHandle c_pool(THREAD,
 349                          accessing_klass->get_instanceKlass()->constants());
 350   LinkResolver::resolve_field(result, c_pool, _cp_index,
 351                               Bytecodes::java_code(bc),
 352                               true, false, KILL_COMPILE_ON_FATAL_(false));
 353 
 354   // update the hit-cache, unless there is a problem with memory scoping:
 355   if (accessing_klass->is_shared() || !is_shared()) {
 356     if (is_put) {
 357       _known_to_link_with_put = accessing_klass;
 358     } else {
 359       _known_to_link_with_get = accessing_klass;
 360     }
 361   }
 362 
 363   return true;
 364 }
 365 
 366 // ------------------------------------------------------------------
 367 // ciField::print
 368 void ciField::print() {
 369   tty->print("<ciField name=");
 370   _holder->print_name();
 371   tty->print(".");
 372   _name->print_symbol();
   1 /*
   2  * Copyright (c) 1999, 2013, 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  *


  58 
  59 // It is not a vicious circularity for a ciField to recursively create
  60 // the ciSymbols necessary to represent its name and signature.
  61 // Therefore, these items are created eagerly, and the name and signature
  62 // of a shared field are themselves shared symbols.  This somewhat
  63 // pollutes the set of shared CI objects:  It grows from 50 to 93 items,
  64 // with all of the additional 43 being uninteresting shared ciSymbols.
  65 // This adds at most one step to the binary search, an amount which
  66 // decreases for complex compilation tasks.
  67 
  68 // ------------------------------------------------------------------
  69 // ciField::ciField
  70 ciField::ciField(ciInstanceKlass* klass, int index): _known_to_link_with_put(NULL), _known_to_link_with_get(NULL) {
  71   ASSERT_IN_VM;
  72   CompilerThread *thread = CompilerThread::current();
  73 
  74   assert(ciObjectFactory::is_initialized(), "not a shared field");
  75 
  76   assert(klass->get_instanceKlass()->is_linked(), "must be linked before using its constan-pool");
  77 

  78   constantPoolHandle cpool(thread, klass->get_instanceKlass()->constants());
  79 
  80   // Get the field's name, signature, and type.
  81   Symbol* name  = cpool->name_ref_at(index);
  82   _name = ciEnv::current(thread)->get_symbol(name);
  83 
  84   int nt_index = cpool->name_and_type_ref_index_at(index);
  85   int sig_index = cpool->signature_ref_index_at(nt_index);
  86   Symbol* signature = cpool->symbol_at(sig_index);
  87   _signature = ciEnv::current(thread)->get_symbol(signature);
  88 
  89   BasicType field_type = FieldType::basic_type(signature);
  90 
  91   // If the field is a pointer type, get the klass of the
  92   // field.
  93   if (field_type == T_OBJECT || field_type == T_ARRAY) {
  94     bool ignore;
  95     // This is not really a class reference; the index always refers to the
  96     // field's type signature, as a symbol.  Linkage checks do not apply.
  97     _type = ciEnv::current(thread)->get_klass_by_index(cpool, sig_index, ignore, klass);
  98   } else {
  99     _type = ciType::make(field_type);
 100   }
 101 
 102   _name = (ciSymbol*)ciEnv::current(thread)->get_symbol(name);
 103 
 104   // Get the field's declared holder.
 105   //
 106   // Note: we actually create a ciInstanceKlass for this klass,
 107   // even though we may not need to.
 108   int holder_index = cpool->klass_ref_index_at(index);
 109   bool holder_is_accessible;
 110   ciInstanceKlass* declared_holder =
 111     ciEnv::current(thread)->get_klass_by_index(cpool, holder_index,
 112                                                holder_is_accessible,
 113                                                klass)->as_instance_klass();
 114 
 115   // The declared holder of this field may not have been loaded.
 116   // Bail out with partial field information.
 117   if (!holder_is_accessible) {
 118     // _type has already been set.
 119     // The default values for _flags and _constant_value will suffice.
 120     // We need values for _holder, _offset,  and _is_constant,
 121     _holder = declared_holder;
 122     _offset = -1;
 123     _is_constant = false;
 124     return;
 125   }
 126 
 127   InstanceKlass* loaded_decl_holder = declared_holder->get_instanceKlass();
 128 
 129   // Perform the field lookup.
 130   fieldDescriptor field_desc;
 131   Klass* canonical_holder =
 132     loaded_decl_holder->find_field(name, signature, &field_desc);
 133   if (canonical_holder == NULL) {
 134     // Field lookup failed.  Will be detected by will_link.
 135     _holder = declared_holder;
 136     _offset = -1;
 137     _is_constant = false;
 138     return;
 139   }
 140 
 141   assert(canonical_holder == field_desc.field_holder(), "just checking");
 142   initialize_from(&field_desc);
 143 }
 144 
 145 ciField::ciField(fieldDescriptor *fd): _known_to_link_with_put(NULL), _known_to_link_with_get(NULL) {
 146   ASSERT_IN_VM;
 147 


 148   // Get the field's name, signature, and type.
 149   ciEnv* env = CURRENT_ENV;
 150   _name = env->get_symbol(fd->name());
 151   _signature = env->get_symbol(fd->signature());
 152 
 153   BasicType field_type = fd->field_type();
 154 
 155   // If the field is a pointer type, get the klass of the
 156   // field.
 157   if (field_type == T_OBJECT || field_type == T_ARRAY) {
 158     _type = NULL;  // must call compute_type on first access
 159   } else {
 160     _type = ciType::make(field_type);
 161   }
 162 
 163   initialize_from(fd);
 164 
 165   // Either (a) it is marked shared, or else (b) we are done bootstrapping.
 166   assert(is_shared() || ciObjectFactory::is_initialized(),
 167          "bootstrap classes must not create & cache unshared fields");


 324   }
 325 
 326   // Check for static/nonstatic mismatch
 327   bool is_static = (bc == Bytecodes::_getstatic || bc == Bytecodes::_putstatic);
 328   if (is_static != this->is_static()) {
 329     return false;
 330   }
 331 
 332   // Get and put can have different accessibility rules
 333   bool is_put    = (bc == Bytecodes::_putfield  || bc == Bytecodes::_putstatic);
 334   if (is_put) {
 335     if (_known_to_link_with_put == accessing_klass) {
 336       return true;
 337     }
 338   } else {
 339     if (_known_to_link_with_get == accessing_klass) {
 340       return true;
 341     }
 342   }
 343 
 344   fieldDescriptor result;
 345   LinkResolver::resolve_field(result, _holder->get_instanceKlass(),
 346                               _name->get_symbol(), _signature->get_symbol(),
 347                               accessing_klass->get_Klass(), bc, true, false,
 348                               KILL_COMPILE_ON_FATAL_(false));

 349 
 350   // update the hit-cache, unless there is a problem with memory scoping:
 351   if (accessing_klass->is_shared() || !is_shared()) {
 352     if (is_put) {
 353       _known_to_link_with_put = accessing_klass;
 354     } else {
 355       _known_to_link_with_get = accessing_klass;
 356     }
 357   }
 358 
 359   return true;
 360 }
 361 
 362 // ------------------------------------------------------------------
 363 // ciField::print
 364 void ciField::print() {
 365   tty->print("<ciField name=");
 366   _holder->print_name();
 367   tty->print(".");
 368   _name->print_symbol();
src/share/vm/ci/ciField.cpp
Index Unified diffs Context diffs Sdiffs Patch New Old Previous File Next File