< prev index next >

src/hotspot/share/runtime/fieldDescriptor.cpp

Print this page




  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 #include "precompiled.hpp"
  26 #include "classfile/systemDictionary.hpp"
  27 #include "classfile/vmSymbols.hpp"
  28 #include "memory/resourceArea.hpp"
  29 #include "memory/universe.hpp"
  30 #include "oops/annotations.hpp"
  31 #include "oops/constantPool.hpp"
  32 #include "oops/instanceKlass.hpp"
  33 #include "oops/oop.inline.hpp"
  34 #include "oops/fieldStreams.hpp"

  35 #include "runtime/fieldDescriptor.inline.hpp"
  36 #include "runtime/handles.inline.hpp"
  37 #include "runtime/signature.hpp"
  38 
  39 
  40 oop fieldDescriptor::loader() const {
  41   return _cp->pool_holder()->class_loader();
  42 }
  43 
  44 Symbol* fieldDescriptor::generic_signature() const {
  45   if (!has_generic_signature()) {
  46     return NULL;
  47   }
  48 
  49   int idx = 0;
  50   InstanceKlass* ik = field_holder();
  51   for (AllFieldStream fs(ik); !fs.done(); fs.next()) {
  52     if (idx == _index) {
  53       return fs.generic_signature();
  54     } else {


 130   name()->print_value_on(st);
 131   st->print(" ");
 132   signature()->print_value_on(st);
 133   st->print(" @%d ", offset());
 134   if (WizardMode && has_initial_value()) {
 135     st->print("(initval ");
 136     constantTag t = initial_value_tag();
 137     if (t.is_int()) {
 138       st->print("int %d)", int_initial_value());
 139     } else if (t.is_long()){
 140       st->print_jlong(long_initial_value());
 141     } else if (t.is_float()){
 142       st->print("float %f)", float_initial_value());
 143     } else if (t.is_double()){
 144       st->print("double %lf)", double_initial_value());
 145     }
 146   }
 147 }
 148 
 149 void fieldDescriptor::print_on_for(outputStream* st, oop obj) {
 150   print_on(st);
 151   BasicType ft = field_type();



 152   jint as_int = 0;
 153   switch (ft) {
 154     case T_BYTE:
 155       as_int = (jint)obj->byte_field(offset());
 156       st->print(" %d", obj->byte_field(offset()));
 157       break;
 158     case T_CHAR:
 159       as_int = (jint)obj->char_field(offset());
 160       {
 161         jchar c = obj->char_field(offset());
 162         as_int = c;
 163         st->print(" %c %d", isprint(c) ? c : ' ', c);
 164       }
 165       break;
 166     case T_DOUBLE:
 167       st->print(" %lf", obj->double_field(offset()));
 168       break;
 169     case T_FLOAT:
 170       as_int = obj->int_field(offset());
 171       st->print(" %f", obj->float_field(offset()));


 187       st->print(" %s", obj->bool_field(offset()) ? "true" : "false");
 188       break;
 189     case T_ARRAY:
 190       st->print(" ");
 191       NOT_LP64(as_int = obj->int_field(offset()));
 192       if (obj->obj_field(offset()) != NULL) {
 193         obj->obj_field(offset())->print_value_on(st);
 194       } else {
 195         st->print_cr("NULL");
 196       }
 197       break;
 198     case T_OBJECT:
 199       st->print(" ");
 200       NOT_LP64(as_int = obj->int_field(offset()));
 201       if (obj->obj_field(offset()) != NULL) {
 202         obj->obj_field(offset())->print_value_on(st);
 203       } else {
 204         st->print_cr("NULL");
 205       }
 206       break;
























 207     default:
 208       ShouldNotReachHere();
 209       break;
 210   }
 211   // Print a hint as to the underlying integer representation. This can be wrong for
 212   // pointers on an LP64 machine
 213 #ifdef _LP64
 214   if ((ft == T_OBJECT || ft == T_ARRAY) && UseCompressedOops) {
 215     st->print(" (%x)", obj->int_field(offset()));
 216   }
 217   else // <- intended
 218 #endif
 219   if (ft == T_LONG || ft == T_DOUBLE LP64_ONLY(|| !is_java_primitive(ft)) ) {
 220     st->print(" (%x %x)", obj->int_field(offset()), obj->int_field(offset()+sizeof(jint)));
 221   } else if (as_int < 0 || as_int > 9) {
 222     st->print(" (%x)", as_int);
 223   }

 224 }
 225 
 226 #endif /* PRODUCT */


  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 #include "precompiled.hpp"
  26 #include "classfile/systemDictionary.hpp"
  27 #include "classfile/vmSymbols.hpp"
  28 #include "memory/resourceArea.hpp"
  29 #include "memory/universe.hpp"
  30 #include "oops/annotations.hpp"
  31 #include "oops/constantPool.hpp"
  32 #include "oops/instanceKlass.hpp"
  33 #include "oops/oop.inline.hpp"
  34 #include "oops/fieldStreams.hpp"
  35 #include "oops/valueKlass.hpp"
  36 #include "runtime/fieldDescriptor.inline.hpp"
  37 #include "runtime/handles.inline.hpp"
  38 #include "runtime/signature.hpp"
  39 
  40 
  41 oop fieldDescriptor::loader() const {
  42   return _cp->pool_holder()->class_loader();
  43 }
  44 
  45 Symbol* fieldDescriptor::generic_signature() const {
  46   if (!has_generic_signature()) {
  47     return NULL;
  48   }
  49 
  50   int idx = 0;
  51   InstanceKlass* ik = field_holder();
  52   for (AllFieldStream fs(ik); !fs.done(); fs.next()) {
  53     if (idx == _index) {
  54       return fs.generic_signature();
  55     } else {


 131   name()->print_value_on(st);
 132   st->print(" ");
 133   signature()->print_value_on(st);
 134   st->print(" @%d ", offset());
 135   if (WizardMode && has_initial_value()) {
 136     st->print("(initval ");
 137     constantTag t = initial_value_tag();
 138     if (t.is_int()) {
 139       st->print("int %d)", int_initial_value());
 140     } else if (t.is_long()){
 141       st->print_jlong(long_initial_value());
 142     } else if (t.is_float()){
 143       st->print("float %f)", float_initial_value());
 144     } else if (t.is_double()){
 145       st->print("double %lf)", double_initial_value());
 146     }
 147   }
 148 }
 149 
 150 void fieldDescriptor::print_on_for(outputStream* st, oop obj) {

 151   BasicType ft = field_type();
 152   if (ft != T_VALUETYPE) {
 153     print_on(st);
 154   }
 155   jint as_int = 0;
 156   switch (ft) {
 157     case T_BYTE:
 158       as_int = (jint)obj->byte_field(offset());
 159       st->print(" %d", obj->byte_field(offset()));
 160       break;
 161     case T_CHAR:
 162       as_int = (jint)obj->char_field(offset());
 163       {
 164         jchar c = obj->char_field(offset());
 165         as_int = c;
 166         st->print(" %c %d", isprint(c) ? c : ' ', c);
 167       }
 168       break;
 169     case T_DOUBLE:
 170       st->print(" %lf", obj->double_field(offset()));
 171       break;
 172     case T_FLOAT:
 173       as_int = obj->int_field(offset());
 174       st->print(" %f", obj->float_field(offset()));


 190       st->print(" %s", obj->bool_field(offset()) ? "true" : "false");
 191       break;
 192     case T_ARRAY:
 193       st->print(" ");
 194       NOT_LP64(as_int = obj->int_field(offset()));
 195       if (obj->obj_field(offset()) != NULL) {
 196         obj->obj_field(offset())->print_value_on(st);
 197       } else {
 198         st->print_cr("NULL");
 199       }
 200       break;
 201     case T_OBJECT:
 202       st->print(" ");
 203       NOT_LP64(as_int = obj->int_field(offset()));
 204       if (obj->obj_field(offset()) != NULL) {
 205         obj->obj_field(offset())->print_value_on(st);
 206       } else {
 207         st->print_cr("NULL");
 208       }
 209       break;
 210     case T_VALUETYPE:
 211       if (is_flattened()) {
 212         // Resolve klass of flattened value type field
 213         Thread* THREAD = Thread::current();
 214         ResourceMark rm(THREAD);
 215         SignatureStream ss(signature(), false);
 216         Klass* k = ss.as_klass(Handle(THREAD, field_holder()->class_loader()),
 217             Handle(THREAD, field_holder()->protection_domain()),
 218             SignatureStream::ReturnNull, THREAD);
 219         assert(k != NULL && !HAS_PENDING_EXCEPTION, "can resolve klass?");
 220         ValueKlass* vk = ValueKlass::cast(k);
 221         int field_offset = offset() - vk->first_field_offset();
 222         obj = (oop)((address)obj + field_offset);
 223         // Print flattened fields of the value type field
 224         st->print_cr("Flattened value type '%s':", vk->name()->as_C_string());
 225         FieldPrinter print_field(st, obj);
 226         vk->do_nonstatic_fields(&print_field);
 227         return; // Do not print underlying representation
 228       } else {
 229         st->print(" ");
 230         NOT_LP64(as_int = obj->int_field(offset()));
 231         obj->obj_field(offset())->print_value_on(st);
 232       }
 233       break;
 234     default:
 235       ShouldNotReachHere();
 236       break;
 237   }
 238   // Print a hint as to the underlying integer representation. This can be wrong for
 239   // pointers on an LP64 machine
 240 #ifdef _LP64
 241   if ((ft == T_OBJECT || ft == T_ARRAY || ft == T_VALUETYPE) && UseCompressedOops) {
 242     st->print(" (%x)", obj->int_field(offset()));
 243   }
 244   else // <- intended
 245 #endif
 246   if (ft == T_LONG || ft == T_DOUBLE LP64_ONLY(|| !is_java_primitive(ft)) ) {
 247     st->print(" (%x %x)", obj->int_field(offset()), obj->int_field(offset()+sizeof(jint)));
 248   } else if (as_int < 0 || as_int > 9) {
 249     st->print(" (%x)", as_int);
 250   }
 251   st->cr();
 252 }
 253 
 254 #endif /* PRODUCT */
< prev index next >